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 2009, 2010, 2011 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"
28 #include "gdbthread.h"
29 #ifdef HAVE_SYS_RESOURCE_H
30 #include <sys/resource.h>
31 #endif /* HAVE_SYS_RESOURCE_H */
34 #include "tui/tui.h" /* For tui_get_command_dimension. */
41 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
52 #include "expression.h"
56 #include "filenames.h"
58 #include "gdb_obstack.h"
63 #include "inferior.h" /* for signed_pointer_to_address */
65 #include <sys/param.h> /* For MAXPATHLEN */
67 #include "gdb_curses.h"
69 #include "readline/readline.h"
74 #include "gdb_usleep.h"
76 #include "gdb_regex.h"
79 extern PTR
malloc (); /* ARI: PTR */
81 #if !HAVE_DECL_REALLOC
82 extern PTR
realloc (); /* ARI: PTR */
88 /* readline defines this. */
91 void (*deprecated_error_begin_hook
) (void);
93 /* Prototypes for local functions */
95 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
96 va_list, int) ATTRIBUTE_PRINTF (2, 0);
98 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
100 static void do_my_cleanups (struct cleanup
**, struct cleanup
*);
102 static void prompt_for_continue (void);
104 static void set_screen_size (void);
105 static void set_width (void);
107 /* A flag indicating whether to timestamp debugging messages. */
109 static int debug_timestamp
= 0;
111 /* Chain of cleanup actions established with make_cleanup,
112 to be executed if an error happens. */
114 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
115 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
117 /* Nonzero if we have job control. */
121 /* Nonzero means a quit has been requested. */
125 /* Nonzero means quit immediately if Control-C is typed now, rather
126 than waiting until QUIT is executed. Be careful in setting this;
127 code which executes with immediate_quit set has to be very careful
128 about being able to deal with being interrupted at any time. It is
129 almost always better to use QUIT; the only exception I can think of
130 is being able to quit out of a system call (using EINTR loses if
131 the SIGINT happens between the previous QUIT and the system call).
132 To immediately quit in the case in which a SIGINT happens between
133 the previous QUIT and setting immediate_quit (desirable anytime we
134 expect to block), call QUIT after setting immediate_quit. */
138 /* Nonzero means that encoded C++/ObjC names should be printed out in their
139 C++/ObjC form rather than raw. */
143 show_demangle (struct ui_file
*file
, int from_tty
,
144 struct cmd_list_element
*c
, const char *value
)
146 fprintf_filtered (file
,
147 _("Demangling of encoded C++/ObjC names "
148 "when displaying symbols is %s.\n"),
152 /* Nonzero means that encoded C++/ObjC names should be printed out in their
153 C++/ObjC form even in assembler language displays. If this is set, but
154 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
156 int asm_demangle
= 0;
158 show_asm_demangle (struct ui_file
*file
, int from_tty
,
159 struct cmd_list_element
*c
, const char *value
)
161 fprintf_filtered (file
,
162 _("Demangling of C++/ObjC names in "
163 "disassembly listings is %s.\n"),
167 /* Nonzero means that strings with character values >0x7F should be printed
168 as octal escapes. Zero means just print the value (e.g. it's an
169 international character, and the terminal or window can cope.) */
171 int sevenbit_strings
= 0;
173 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
174 struct cmd_list_element
*c
, const char *value
)
176 fprintf_filtered (file
, _("Printing of 8-bit characters "
177 "in strings as \\nnn is %s.\n"),
181 /* String to be printed before error messages, if any. */
183 char *error_pre_print
;
185 /* String to be printed before quit messages, if any. */
187 char *quit_pre_print
;
189 /* String to be printed before warning messages, if any. */
191 char *warning_pre_print
= "\nwarning: ";
193 int pagination_enabled
= 1;
195 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
196 struct cmd_list_element
*c
, const char *value
)
198 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
203 /* Add a new cleanup to the cleanup_chain,
204 and return the previous chain pointer
205 to be passed later to do_cleanups or discard_cleanups.
206 Args are FUNCTION to clean up with, and ARG to pass to it. */
209 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
211 return make_my_cleanup (&cleanup_chain
, function
, arg
);
215 make_cleanup_dtor (make_cleanup_ftype
*function
, void *arg
,
216 void (*dtor
) (void *))
218 return make_my_cleanup2 (&cleanup_chain
,
219 function
, arg
, dtor
);
223 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
225 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
229 do_freeargv (void *arg
)
231 freeargv ((char **) arg
);
235 make_cleanup_freeargv (char **arg
)
237 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
241 do_bfd_close_cleanup (void *arg
)
247 make_cleanup_bfd_close (bfd
*abfd
)
249 return make_cleanup (do_bfd_close_cleanup
, abfd
);
253 do_close_cleanup (void *arg
)
261 make_cleanup_close (int fd
)
263 int *saved_fd
= xmalloc (sizeof (fd
));
266 return make_cleanup_dtor (do_close_cleanup
, saved_fd
, xfree
);
269 /* Helper function which does the work for make_cleanup_fclose. */
272 do_fclose_cleanup (void *arg
)
279 /* Return a new cleanup that closes FILE. */
282 make_cleanup_fclose (FILE *file
)
284 return make_cleanup (do_fclose_cleanup
, file
);
287 /* Helper function which does the work for make_cleanup_obstack_free. */
290 do_obstack_free (void *arg
)
292 struct obstack
*ob
= arg
;
294 obstack_free (ob
, NULL
);
297 /* Return a new cleanup that frees OBSTACK. */
300 make_cleanup_obstack_free (struct obstack
*obstack
)
302 return make_cleanup (do_obstack_free
, obstack
);
306 do_ui_file_delete (void *arg
)
308 ui_file_delete (arg
);
312 make_cleanup_ui_file_delete (struct ui_file
*arg
)
314 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
317 /* Helper function for make_cleanup_ui_out_redirect_pop. */
320 do_ui_out_redirect_pop (void *arg
)
322 struct ui_out
*uiout
= arg
;
324 if (ui_out_redirect (uiout
, NULL
) < 0)
325 warning (_("Cannot restore redirection of the current output protocol"));
328 /* Return a new cleanup that pops the last redirection by ui_out_redirect
329 with NULL parameter. */
332 make_cleanup_ui_out_redirect_pop (struct ui_out
*uiout
)
334 return make_my_cleanup (&cleanup_chain
, do_ui_out_redirect_pop
, uiout
);
338 do_free_section_addr_info (void *arg
)
340 free_section_addr_info (arg
);
344 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
346 return make_my_cleanup (&cleanup_chain
, do_free_section_addr_info
, addrs
);
349 struct restore_integer_closure
356 restore_integer (void *p
)
358 struct restore_integer_closure
*closure
= p
;
360 *(closure
->variable
) = closure
->value
;
363 /* Remember the current value of *VARIABLE and make it restored when
364 the cleanup is run. */
367 make_cleanup_restore_integer (int *variable
)
369 struct restore_integer_closure
*c
=
370 xmalloc (sizeof (struct restore_integer_closure
));
372 c
->variable
= variable
;
373 c
->value
= *variable
;
375 return make_my_cleanup2 (&cleanup_chain
, restore_integer
, (void *)c
,
379 /* Remember the current value of *VARIABLE and make it restored when
380 the cleanup is run. */
383 make_cleanup_restore_uinteger (unsigned int *variable
)
385 return make_cleanup_restore_integer ((int *) variable
);
388 /* Helper for make_cleanup_unpush_target. */
391 do_unpush_target (void *arg
)
393 struct target_ops
*ops
= arg
;
398 /* Return a new cleanup that unpushes OPS. */
401 make_cleanup_unpush_target (struct target_ops
*ops
)
403 return make_my_cleanup (&cleanup_chain
, do_unpush_target
, ops
);
406 struct restore_ui_file_closure
408 struct ui_file
**variable
;
409 struct ui_file
*value
;
413 do_restore_ui_file (void *p
)
415 struct restore_ui_file_closure
*closure
= p
;
417 *(closure
->variable
) = closure
->value
;
420 /* Remember the current value of *VARIABLE and make it restored when
421 the cleanup is run. */
424 make_cleanup_restore_ui_file (struct ui_file
**variable
)
426 struct restore_ui_file_closure
*c
= XNEW (struct restore_ui_file_closure
);
428 c
->variable
= variable
;
429 c
->value
= *variable
;
431 return make_cleanup_dtor (do_restore_ui_file
, (void *) c
, xfree
);
434 /* Helper for make_cleanup_value_free_to_mark. */
437 do_value_free_to_mark (void *value
)
439 value_free_to_mark ((struct value
*) value
);
442 /* Free all values allocated since MARK was obtained by value_mark
443 (except for those released) when the cleanup is run. */
446 make_cleanup_value_free_to_mark (struct value
*mark
)
448 return make_my_cleanup (&cleanup_chain
, do_value_free_to_mark
, mark
);
451 /* Helper for make_cleanup_value_free. */
454 do_value_free (void *value
)
462 make_cleanup_value_free (struct value
*value
)
464 return make_my_cleanup (&cleanup_chain
, do_value_free
, value
);
468 make_my_cleanup2 (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
469 void *arg
, void (*free_arg
) (void *))
472 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
473 struct cleanup
*old_chain
= *pmy_chain
;
475 new->next
= *pmy_chain
;
476 new->function
= function
;
477 new->free_arg
= free_arg
;
485 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
488 return make_my_cleanup2 (pmy_chain
, function
, arg
, NULL
);
491 /* Discard cleanups and do the actions they describe
492 until we get back to the point OLD_CHAIN in the cleanup_chain. */
495 do_cleanups (struct cleanup
*old_chain
)
497 do_my_cleanups (&cleanup_chain
, old_chain
);
501 do_final_cleanups (struct cleanup
*old_chain
)
503 do_my_cleanups (&final_cleanup_chain
, old_chain
);
507 do_my_cleanups (struct cleanup
**pmy_chain
,
508 struct cleanup
*old_chain
)
512 while ((ptr
= *pmy_chain
) != old_chain
)
514 *pmy_chain
= ptr
->next
; /* Do this first in case of recursion. */
515 (*ptr
->function
) (ptr
->arg
);
517 (*ptr
->free_arg
) (ptr
->arg
);
522 /* Discard cleanups, not doing the actions they describe,
523 until we get back to the point OLD_CHAIN in the cleanup_chain. */
526 discard_cleanups (struct cleanup
*old_chain
)
528 discard_my_cleanups (&cleanup_chain
, old_chain
);
532 discard_final_cleanups (struct cleanup
*old_chain
)
534 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
538 discard_my_cleanups (struct cleanup
**pmy_chain
,
539 struct cleanup
*old_chain
)
543 while ((ptr
= *pmy_chain
) != old_chain
)
545 *pmy_chain
= ptr
->next
;
547 (*ptr
->free_arg
) (ptr
->arg
);
552 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
556 return save_my_cleanups (&cleanup_chain
);
560 save_final_cleanups (void)
562 return save_my_cleanups (&final_cleanup_chain
);
566 save_my_cleanups (struct cleanup
**pmy_chain
)
568 struct cleanup
*old_chain
= *pmy_chain
;
574 /* Restore the cleanup chain from a previously saved chain. */
576 restore_cleanups (struct cleanup
*chain
)
578 restore_my_cleanups (&cleanup_chain
, chain
);
582 restore_final_cleanups (struct cleanup
*chain
)
584 restore_my_cleanups (&final_cleanup_chain
, chain
);
588 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
593 /* This function is useful for cleanups.
597 old_chain = make_cleanup (free_current_contents, &foo);
599 to arrange to free the object thus allocated. */
602 free_current_contents (void *ptr
)
604 void **location
= ptr
;
606 if (location
== NULL
)
607 internal_error (__FILE__
, __LINE__
,
608 _("free_current_contents: NULL pointer"));
609 if (*location
!= NULL
)
616 /* Provide a known function that does nothing, to use as a base for
617 a possibly long chain of cleanups. This is useful where we
618 use the cleanup chain for handling normal cleanups as well as dealing
619 with cleanups that need to be done as a result of a call to error().
620 In such cases, we may not be certain where the first cleanup is, unless
621 we have a do-nothing one to always use as the base. */
624 null_cleanup (void *arg
)
628 /* If nonzero, display time usage both at startup and for each command. */
630 static int display_time
;
632 /* If nonzero, display space usage both at startup and for each command. */
634 static int display_space
;
636 /* Records a run time and space usage to be used as a base for
637 reporting elapsed time or change in space. In addition,
638 the msg_type field indicates whether the saved time is from the
639 beginning of GDB execution (0) or the beginning of an individual
640 command execution (1). */
648 /* Set whether to display time statistics to NEW_VALUE (non-zero
651 set_display_time (int new_value
)
653 display_time
= new_value
;
656 /* Set whether to display space statistics to NEW_VALUE (non-zero
659 set_display_space (int new_value
)
661 display_space
= new_value
;
664 /* As indicated by display_time and display_space, report GDB's elapsed time
665 and space usage from the base time and space provided in ARG, which
666 must be a pointer to a struct cmd_stat. This function is intended
667 to be called as a cleanup. */
669 report_command_stats (void *arg
)
671 struct cmd_stats
*start_stats
= (struct cmd_stats
*) arg
;
672 int msg_type
= start_stats
->msg_type
;
676 long cmd_time
= get_run_time () - start_stats
->start_time
;
678 printf_unfiltered (msg_type
== 0
679 ? _("Startup time: %ld.%06ld\n")
680 : _("Command execution time: %ld.%06ld\n"),
681 cmd_time
/ 1000000, cmd_time
% 1000000);
687 char *lim
= (char *) sbrk (0);
689 long space_now
= lim
- lim_at_start
;
690 long space_diff
= space_now
- start_stats
->start_space
;
692 printf_unfiltered (msg_type
== 0
693 ? _("Space used: %ld (%s%ld during startup)\n")
694 : _("Space used: %ld (%s%ld for this command)\n"),
696 (space_diff
>= 0 ? "+" : ""),
702 /* Create a cleanup that reports time and space used since its
703 creation. Precise messages depend on MSG_TYPE:
704 0: Initial time/space
705 1: Individual command time/space. */
707 make_command_stats_cleanup (int msg_type
)
709 struct cmd_stats
*new_stat
= XMALLOC (struct cmd_stats
);
712 char *lim
= (char *) sbrk (0);
713 new_stat
->start_space
= lim
- lim_at_start
;
716 new_stat
->msg_type
= msg_type
;
717 new_stat
->start_time
= get_run_time ();
719 return make_cleanup_dtor (report_command_stats
, new_stat
, xfree
);
722 /* Continuations are implemented as cleanups internally. Inherit from
729 /* Add a continuation to the continuation list of THREAD. The new
730 continuation will be added at the front. */
732 add_continuation (struct thread_info
*thread
,
733 void (*continuation_hook
) (void *), void *args
,
734 void (*continuation_free_args
) (void *))
736 struct cleanup
*as_cleanup
= &thread
->continuations
->base
;
737 make_cleanup_ftype
*continuation_hook_fn
= continuation_hook
;
739 make_my_cleanup2 (&as_cleanup
,
740 continuation_hook_fn
,
742 continuation_free_args
);
744 thread
->continuations
= (struct continuation
*) as_cleanup
;
747 /* Add a continuation to the continuation list of INFERIOR. The new
748 continuation will be added at the front. */
751 add_inferior_continuation (void (*continuation_hook
) (void *), void *args
,
752 void (*continuation_free_args
) (void *))
754 struct inferior
*inf
= current_inferior ();
755 struct cleanup
*as_cleanup
= &inf
->continuations
->base
;
756 make_cleanup_ftype
*continuation_hook_fn
= continuation_hook
;
758 make_my_cleanup2 (&as_cleanup
,
759 continuation_hook_fn
,
761 continuation_free_args
);
763 inf
->continuations
= (struct continuation
*) as_cleanup
;
766 /* Do all continuations of the current inferior. */
769 do_all_inferior_continuations (void)
771 struct cleanup
*as_cleanup
;
772 struct inferior
*inf
= current_inferior ();
774 if (inf
->continuations
== NULL
)
777 /* Copy the list header into another pointer, and set the global
778 list header to null, so that the global list can change as a side
779 effect of invoking the continuations and the processing of the
780 preexisting continuations will not be affected. */
782 as_cleanup
= &inf
->continuations
->base
;
783 inf
->continuations
= NULL
;
785 /* Work now on the list we have set aside. */
786 do_my_cleanups (&as_cleanup
, NULL
);
789 /* Get rid of all the inferior-wide continuations of INF. */
792 discard_all_inferior_continuations (struct inferior
*inf
)
794 struct cleanup
*continuation_ptr
= &inf
->continuations
->base
;
796 discard_my_cleanups (&continuation_ptr
, NULL
);
797 inf
->continuations
= NULL
;
801 restore_thread_cleanup (void *arg
)
803 ptid_t
*ptid_p
= arg
;
805 switch_to_thread (*ptid_p
);
808 /* Walk down the continuation list of PTID, and execute all the
809 continuations. There is a problem though. In some cases new
810 continuations may be added while we are in the middle of this loop.
811 If this happens they will be added in the front, and done before we
812 have a chance of exhausting those that were already there. We need
813 to then save the beginning of the list in a pointer and do the
814 continuations from there on, instead of using the global beginning
815 of list as our iteration pointer. */
817 do_all_continuations_ptid (ptid_t ptid
,
818 struct continuation
**continuations_p
)
820 struct cleanup
*old_chain
;
821 ptid_t current_thread
;
822 struct cleanup
*as_cleanup
;
824 if (*continuations_p
== NULL
)
827 current_thread
= inferior_ptid
;
829 /* Restore selected thread on exit. Don't try to restore the frame
832 - When running continuations, the selected frame is always #0.
834 - The continuations may trigger symbol file loads, which may
835 change the frame layout (frame ids change), which would trigger
836 a warning if we used make_cleanup_restore_current_thread. */
838 old_chain
= make_cleanup (restore_thread_cleanup
, ¤t_thread
);
840 /* Let the continuation see this thread as selected. */
841 switch_to_thread (ptid
);
843 /* Copy the list header into another pointer, and set the global
844 list header to null, so that the global list can change as a side
845 effect of invoking the continuations and the processing of the
846 preexisting continuations will not be affected. */
848 as_cleanup
= &(*continuations_p
)->base
;
849 *continuations_p
= NULL
;
851 /* Work now on the list we have set aside. */
852 do_my_cleanups (&as_cleanup
, NULL
);
854 do_cleanups (old_chain
);
857 /* Callback for iterate over threads. */
859 do_all_continuations_thread_callback (struct thread_info
*thread
, void *data
)
861 do_all_continuations_ptid (thread
->ptid
, &thread
->continuations
);
865 /* Do all continuations of thread THREAD. */
867 do_all_continuations_thread (struct thread_info
*thread
)
869 do_all_continuations_thread_callback (thread
, NULL
);
872 /* Do all continuations of all threads. */
874 do_all_continuations (void)
876 iterate_over_threads (do_all_continuations_thread_callback
, NULL
);
879 /* Callback for iterate over threads. */
881 discard_all_continuations_thread_callback (struct thread_info
*thread
,
884 struct cleanup
*continuation_ptr
= &thread
->continuations
->base
;
886 discard_my_cleanups (&continuation_ptr
, NULL
);
887 thread
->continuations
= NULL
;
891 /* Get rid of all the continuations of THREAD. */
893 discard_all_continuations_thread (struct thread_info
*thread
)
895 discard_all_continuations_thread_callback (thread
, NULL
);
898 /* Get rid of all the continuations of all threads. */
900 discard_all_continuations (void)
902 iterate_over_threads (discard_all_continuations_thread_callback
, NULL
);
906 /* Add a continuation to the intermediate continuation list of THREAD.
907 The new continuation will be added at the front. */
909 add_intermediate_continuation (struct thread_info
*thread
,
910 void (*continuation_hook
)
911 (void *), void *args
,
912 void (*continuation_free_args
) (void *))
914 struct cleanup
*as_cleanup
= &thread
->intermediate_continuations
->base
;
915 make_cleanup_ftype
*continuation_hook_fn
= continuation_hook
;
917 make_my_cleanup2 (&as_cleanup
,
918 continuation_hook_fn
,
920 continuation_free_args
);
922 thread
->intermediate_continuations
= (struct continuation
*) as_cleanup
;
925 /* Walk down the cmd_continuation list, and execute all the
926 continuations. There is a problem though. In some cases new
927 continuations may be added while we are in the middle of this
928 loop. If this happens they will be added in the front, and done
929 before we have a chance of exhausting those that were already
930 there. We need to then save the beginning of the list in a pointer
931 and do the continuations from there on, instead of using the
932 global beginning of list as our iteration pointer. */
934 do_all_intermediate_continuations_thread_callback (struct thread_info
*thread
,
937 do_all_continuations_ptid (thread
->ptid
,
938 &thread
->intermediate_continuations
);
942 /* Do all intermediate continuations of thread THREAD. */
944 do_all_intermediate_continuations_thread (struct thread_info
*thread
)
946 do_all_intermediate_continuations_thread_callback (thread
, NULL
);
949 /* Do all intermediate continuations of all threads. */
951 do_all_intermediate_continuations (void)
953 iterate_over_threads (do_all_intermediate_continuations_thread_callback
,
957 /* Callback for iterate over threads. */
959 discard_all_intermediate_continuations_thread_callback (struct thread_info
*thread
,
962 struct cleanup
*continuation_ptr
= &thread
->intermediate_continuations
->base
;
964 discard_my_cleanups (&continuation_ptr
, NULL
);
965 thread
->intermediate_continuations
= NULL
;
969 /* Get rid of all the intermediate continuations of THREAD. */
971 discard_all_intermediate_continuations_thread (struct thread_info
*thread
)
973 discard_all_intermediate_continuations_thread_callback (thread
, NULL
);
976 /* Get rid of all the intermediate continuations of all threads. */
978 discard_all_intermediate_continuations (void)
980 iterate_over_threads (discard_all_intermediate_continuations_thread_callback
,
986 /* Print a warning message. The first argument STRING is the warning
987 message, used as an fprintf format string, the second is the
988 va_list of arguments for that string. A warning is unfiltered (not
989 paginated) so that the user does not need to page through each
990 screen full of warnings when there are lots of them. */
993 vwarning (const char *string
, va_list args
)
995 if (deprecated_warning_hook
)
996 (*deprecated_warning_hook
) (string
, args
);
999 target_terminal_ours ();
1000 wrap_here (""); /* Force out any buffered output. */
1001 gdb_flush (gdb_stdout
);
1002 if (warning_pre_print
)
1003 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
1004 vfprintf_unfiltered (gdb_stderr
, string
, args
);
1005 fprintf_unfiltered (gdb_stderr
, "\n");
1010 /* Print a warning message.
1011 The first argument STRING is the warning message, used as a fprintf string,
1012 and the remaining args are passed as arguments to it.
1013 The primary difference between warnings and errors is that a warning
1014 does not force the return to command level. */
1017 warning (const char *string
, ...)
1021 va_start (args
, string
);
1022 vwarning (string
, args
);
1026 /* Print an error message and return to command level.
1027 The first argument STRING is the error message, used as a fprintf string,
1028 and the remaining args are passed as arguments to it. */
1031 verror (const char *string
, va_list args
)
1033 throw_verror (GENERIC_ERROR
, string
, args
);
1037 error (const char *string
, ...)
1041 va_start (args
, string
);
1042 throw_verror (GENERIC_ERROR
, string
, args
);
1046 /* Print an error message and quit.
1047 The first argument STRING is the error message, used as a fprintf string,
1048 and the remaining args are passed as arguments to it. */
1051 vfatal (const char *string
, va_list args
)
1053 throw_vfatal (string
, args
);
1057 fatal (const char *string
, ...)
1061 va_start (args
, string
);
1062 throw_vfatal (string
, args
);
1067 error_stream (struct ui_file
*stream
)
1069 char *message
= ui_file_xstrdup (stream
, NULL
);
1071 make_cleanup (xfree
, message
);
1072 error (("%s"), message
);
1075 /* Dump core trying to increase the core soft limit to hard limit first. */
1080 #ifdef HAVE_SETRLIMIT
1081 struct rlimit rlim
= { RLIM_INFINITY
, RLIM_INFINITY
};
1083 setrlimit (RLIMIT_CORE
, &rlim
);
1084 #endif /* HAVE_SETRLIMIT */
1086 abort (); /* NOTE: GDB has only three calls to abort(). */
1089 /* Check whether GDB will be able to dump core using the dump_core
1093 can_dump_core (const char *reason
)
1095 #ifdef HAVE_GETRLIMIT
1098 /* Be quiet and assume we can dump if an error is returned. */
1099 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
1102 if (rlim
.rlim_max
== 0)
1104 fprintf_unfiltered (gdb_stderr
,
1105 _("%s\nUnable to dump core, use `ulimit -c"
1106 " unlimited' before executing GDB next time.\n"),
1110 #endif /* HAVE_GETRLIMIT */
1115 /* Allow the user to configure the debugger behavior with respect to
1116 what to do when an internal problem is detected. */
1118 const char internal_problem_ask
[] = "ask";
1119 const char internal_problem_yes
[] = "yes";
1120 const char internal_problem_no
[] = "no";
1121 static const char *internal_problem_modes
[] =
1123 internal_problem_ask
,
1124 internal_problem_yes
,
1125 internal_problem_no
,
1129 /* Print a message reporting an internal error/warning. Ask the user
1130 if they want to continue, dump core, or just exit. Return
1131 something to indicate a quit. */
1133 struct internal_problem
1136 const char *should_quit
;
1137 const char *should_dump_core
;
1140 /* Report a problem, internal to GDB, to the user. Once the problem
1141 has been reported, and assuming GDB didn't quit, the caller can
1142 either allow execution to resume or throw an error. */
1144 static void ATTRIBUTE_PRINTF (4, 0)
1145 internal_vproblem (struct internal_problem
*problem
,
1146 const char *file
, int line
, const char *fmt
, va_list ap
)
1153 /* Don't allow infinite error/warning recursion. */
1155 static char msg
[] = "Recursive internal problem.\n";
1164 fputs_unfiltered (msg
, gdb_stderr
);
1165 abort (); /* NOTE: GDB has only three calls to abort(). */
1168 /* Newer GLIBC versions put the warn_unused_result attribute
1169 on write, but this is one of those rare cases where
1170 ignoring the return value is correct. Casting to (void)
1171 does not fix this problem. This is the solution suggested
1172 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
1173 if (write (STDERR_FILENO
, msg
, sizeof (msg
)) != sizeof (msg
))
1174 abort (); /* NOTE: GDB has only three calls to abort(). */
1179 /* Try to get the message out and at the start of a new line. */
1180 target_terminal_ours ();
1183 /* Create a string containing the full error/warning message. Need
1184 to call query with this full string, as otherwize the reason
1185 (error/warning) and question become separated. Format using a
1186 style similar to a compiler error message. Include extra detail
1187 so that the user knows that they are living on the edge. */
1191 msg
= xstrvprintf (fmt
, ap
);
1192 reason
= xstrprintf ("%s:%d: %s: %s\n"
1193 "A problem internal to GDB has been detected,\n"
1194 "further debugging may prove unreliable.",
1195 file
, line
, problem
->name
, msg
);
1197 make_cleanup (xfree
, reason
);
1200 if (problem
->should_quit
== internal_problem_ask
)
1202 /* Default (yes/batch case) is to quit GDB. When in batch mode
1203 this lessens the likelihood of GDB going into an infinite
1207 /* Emit the message and quit. */
1208 fputs_unfiltered (reason
, gdb_stderr
);
1209 fputs_unfiltered ("\n", gdb_stderr
);
1213 quit_p
= query (_("%s\nQuit this debugging session? "), reason
);
1215 else if (problem
->should_quit
== internal_problem_yes
)
1217 else if (problem
->should_quit
== internal_problem_no
)
1220 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1222 if (problem
->should_dump_core
== internal_problem_ask
)
1224 if (!can_dump_core (reason
))
1228 /* Default (yes/batch case) is to dump core. This leaves a GDB
1229 `dropping' so that it is easier to see that something went
1231 dump_core_p
= query (_("%s\nCreate a core file of GDB? "), reason
);
1234 else if (problem
->should_dump_core
== internal_problem_yes
)
1235 dump_core_p
= can_dump_core (reason
);
1236 else if (problem
->should_dump_core
== internal_problem_no
)
1239 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1252 #ifdef HAVE_WORKING_FORK
1262 static struct internal_problem internal_error_problem
= {
1263 "internal-error", internal_problem_ask
, internal_problem_ask
1267 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
1269 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
1270 deprecated_throw_reason (RETURN_ERROR
);
1274 internal_error (const char *file
, int line
, const char *string
, ...)
1278 va_start (ap
, string
);
1279 internal_verror (file
, line
, string
, ap
);
1283 static struct internal_problem internal_warning_problem
= {
1284 "internal-warning", internal_problem_ask
, internal_problem_ask
1288 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
1290 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
1294 internal_warning (const char *file
, int line
, const char *string
, ...)
1298 va_start (ap
, string
);
1299 internal_vwarning (file
, line
, string
, ap
);
1303 /* Dummy functions to keep add_prefix_cmd happy. */
1306 set_internal_problem_cmd (char *args
, int from_tty
)
1311 show_internal_problem_cmd (char *args
, int from_tty
)
1315 /* When GDB reports an internal problem (error or warning) it gives
1316 the user the opportunity to quit GDB and/or create a core file of
1317 the current debug session. This function registers a few commands
1318 that make it possible to specify that GDB should always or never
1319 quit or create a core file, without asking. The commands look
1322 maint set PROBLEM-NAME quit ask|yes|no
1323 maint show PROBLEM-NAME quit
1324 maint set PROBLEM-NAME corefile ask|yes|no
1325 maint show PROBLEM-NAME corefile
1327 Where PROBLEM-NAME is currently "internal-error" or
1328 "internal-warning". */
1331 add_internal_problem_command (struct internal_problem
*problem
)
1333 struct cmd_list_element
**set_cmd_list
;
1334 struct cmd_list_element
**show_cmd_list
;
1338 set_cmd_list
= xmalloc (sizeof (*set_cmd_list
));
1339 show_cmd_list
= xmalloc (sizeof (*set_cmd_list
));
1340 *set_cmd_list
= NULL
;
1341 *show_cmd_list
= NULL
;
1343 set_doc
= xstrprintf (_("Configure what GDB does when %s is detected."),
1346 show_doc
= xstrprintf (_("Show what GDB does when %s is detected."),
1349 add_prefix_cmd ((char*) problem
->name
,
1350 class_maintenance
, set_internal_problem_cmd
, set_doc
,
1352 concat ("maintenance set ", problem
->name
, " ",
1354 0/*allow-unknown*/, &maintenance_set_cmdlist
);
1356 add_prefix_cmd ((char*) problem
->name
,
1357 class_maintenance
, show_internal_problem_cmd
, show_doc
,
1359 concat ("maintenance show ", problem
->name
, " ",
1361 0/*allow-unknown*/, &maintenance_show_cmdlist
);
1363 set_doc
= xstrprintf (_("Set whether GDB should quit "
1364 "when an %s is detected"),
1366 show_doc
= xstrprintf (_("Show whether GDB will quit "
1367 "when an %s is detected"),
1369 add_setshow_enum_cmd ("quit", class_maintenance
,
1370 internal_problem_modes
,
1371 &problem
->should_quit
,
1374 NULL
, /* help_doc */
1376 NULL
, /* showfunc */
1383 set_doc
= xstrprintf (_("Set whether GDB should create a core "
1384 "file of GDB when %s is detected"),
1386 show_doc
= xstrprintf (_("Show whether GDB will create a core "
1387 "file of GDB when %s is detected"),
1389 add_setshow_enum_cmd ("corefile", class_maintenance
,
1390 internal_problem_modes
,
1391 &problem
->should_dump_core
,
1394 NULL
, /* help_doc */
1396 NULL
, /* showfunc */
1404 /* Print the system error message for errno, and also mention STRING
1405 as the file name for which the error was encountered.
1406 Then return to command level. */
1409 perror_with_name (const char *string
)
1414 err
= safe_strerror (errno
);
1415 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
1416 strcpy (combined
, string
);
1417 strcat (combined
, ": ");
1418 strcat (combined
, err
);
1420 /* I understand setting these is a matter of taste. Still, some people
1421 may clear errno but not know about bfd_error. Doing this here is not
1423 bfd_set_error (bfd_error_no_error
);
1426 error (_("%s."), combined
);
1429 /* Print the system error message for ERRCODE, and also mention STRING
1430 as the file name for which the error was encountered. */
1433 print_sys_errmsg (const char *string
, int errcode
)
1438 err
= safe_strerror (errcode
);
1439 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
1440 strcpy (combined
, string
);
1441 strcat (combined
, ": ");
1442 strcat (combined
, err
);
1444 /* We want anything which was printed on stdout to come out first, before
1446 gdb_flush (gdb_stdout
);
1447 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
1450 /* Control C eventually causes this to be called, at a convenient time. */
1456 /* No steenking SIGINT will ever be coming our way when the
1457 program is resumed. Don't lie. */
1461 /* If there is no terminal switching for this target, then we can't
1462 possibly get screwed by the lack of job control. */
1463 || current_target
.to_terminal_ours
== NULL
)
1466 fatal ("Quit (expect signal SIGINT when the program is resumed)");
1471 /* Called when a memory allocation fails, with the number of bytes of
1472 memory requested in SIZE. */
1479 internal_error (__FILE__
, __LINE__
,
1480 _("virtual memory exhausted: can't allocate %ld bytes."),
1485 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
1489 /* The xmalloc() (libiberty.h) family of memory management routines.
1491 These are like the ISO-C malloc() family except that they implement
1492 consistent semantics and guard against typical memory management
1495 /* NOTE: These are declared using PTR to ensure consistency with
1496 "libiberty.h". xfree() is GDB local. */
1499 xmalloc (size_t size
)
1503 /* See libiberty/xmalloc.c. This function need's to match that's
1504 semantics. It never returns NULL. */
1508 val
= malloc (size
); /* ARI: malloc */
1516 xzalloc (size_t size
)
1518 return xcalloc (1, size
);
1522 xrealloc (PTR ptr
, size_t size
) /* ARI: PTR */
1526 /* See libiberty/xmalloc.c. This function need's to match that's
1527 semantics. It never returns NULL. */
1532 val
= realloc (ptr
, size
); /* ARI: realloc */
1534 val
= malloc (size
); /* ARI: malloc */
1542 xcalloc (size_t number
, size_t size
)
1546 /* See libiberty/xmalloc.c. This function need's to match that's
1547 semantics. It never returns NULL. */
1548 if (number
== 0 || size
== 0)
1554 mem
= calloc (number
, size
); /* ARI: xcalloc */
1556 nomem (number
* size
);
1565 free (ptr
); /* ARI: free */
1569 /* Like asprintf/vasprintf but get an internal_error if the call
1573 xstrprintf (const char *format
, ...)
1578 va_start (args
, format
);
1579 ret
= xstrvprintf (format
, args
);
1585 xasprintf (char **ret
, const char *format
, ...)
1589 va_start (args
, format
);
1590 (*ret
) = xstrvprintf (format
, args
);
1595 xvasprintf (char **ret
, const char *format
, va_list ap
)
1597 (*ret
) = xstrvprintf (format
, ap
);
1601 xstrvprintf (const char *format
, va_list ap
)
1604 int status
= vasprintf (&ret
, format
, ap
);
1606 /* NULL is returned when there was a memory allocation problem, or
1607 any other error (for instance, a bad format string). A negative
1608 status (the printed length) with a non-NULL buffer should never
1609 happen, but just to be sure. */
1610 if (ret
== NULL
|| status
< 0)
1611 internal_error (__FILE__
, __LINE__
, _("vasprintf call failed"));
1616 xsnprintf (char *str
, size_t size
, const char *format
, ...)
1621 va_start (args
, format
);
1622 ret
= vsnprintf (str
, size
, format
, args
);
1623 gdb_assert (ret
< size
);
1629 /* My replacement for the read system call.
1630 Used like `read' but keeps going if `read' returns too soon. */
1633 myread (int desc
, char *addr
, int len
)
1640 val
= read (desc
, addr
, len
);
1644 return orglen
- len
;
1651 /* Make a copy of the string at PTR with SIZE characters
1652 (and add a null character at the end in the copy).
1653 Uses malloc to get the space. Returns the address of the copy. */
1656 savestring (const char *ptr
, size_t size
)
1658 char *p
= (char *) xmalloc (size
+ 1);
1660 memcpy (p
, ptr
, size
);
1666 print_spaces (int n
, struct ui_file
*file
)
1668 fputs_unfiltered (n_spaces (n
), file
);
1671 /* Print a host address. */
1674 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1676 fprintf_filtered (stream
, "%s", host_address_to_string (addr
));
1680 /* A cleanup function that calls regfree. */
1683 do_regfree_cleanup (void *r
)
1688 /* Create a new cleanup that frees the compiled regular expression R. */
1691 make_regfree_cleanup (regex_t
*r
)
1693 return make_cleanup (do_regfree_cleanup
, r
);
1696 /* Return an xmalloc'd error message resulting from a regular
1697 expression compilation failure. */
1700 get_regcomp_error (int code
, regex_t
*rx
)
1702 size_t length
= regerror (code
, rx
, NULL
, 0);
1703 char *result
= xmalloc (length
);
1705 regerror (code
, rx
, result
, length
);
1711 /* This function supports the query, nquery, and yquery functions.
1712 Ask user a y-or-n question and return 0 if answer is no, 1 if
1713 answer is yes, or default the answer to the specified default
1714 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1715 default answer, or '\0' for no default.
1716 CTLSTR is the control string and should end in "? ". It should
1717 not say how to answer, because we do that.
1718 ARGS are the arguments passed along with the CTLSTR argument to
1721 static int ATTRIBUTE_PRINTF (1, 0)
1722 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1728 char def_answer
, not_def_answer
;
1729 char *y_string
, *n_string
, *question
;
1731 /* Set up according to which answer is the default. */
1732 if (defchar
== '\0')
1736 not_def_answer
= 'N';
1740 else if (defchar
== 'y')
1744 not_def_answer
= 'N';
1752 not_def_answer
= 'Y';
1757 /* Automatically answer the default value if the user did not want
1758 prompts or the command was issued with the server prefix. */
1759 if (! caution
|| server_command
)
1762 /* If input isn't coming from the user directly, just say what
1763 question we're asking, and then answer the default automatically. This
1764 way, important error messages don't get lost when talking to GDB
1766 if (! input_from_terminal_p ())
1769 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1771 printf_filtered (_("(%s or %s) [answered %c; "
1772 "input not from terminal]\n"),
1773 y_string
, n_string
, def_answer
);
1774 gdb_flush (gdb_stdout
);
1779 if (deprecated_query_hook
)
1781 return deprecated_query_hook (ctlstr
, args
);
1784 /* Format the question outside of the loop, to avoid reusing args. */
1785 question
= xstrvprintf (ctlstr
, args
);
1789 wrap_here (""); /* Flush any buffered output. */
1790 gdb_flush (gdb_stdout
);
1792 if (annotation_level
> 1)
1793 printf_filtered (("\n\032\032pre-query\n"));
1795 fputs_filtered (question
, gdb_stdout
);
1796 printf_filtered (_("(%s or %s) "), y_string
, n_string
);
1798 if (annotation_level
> 1)
1799 printf_filtered (("\n\032\032query\n"));
1802 gdb_flush (gdb_stdout
);
1804 answer
= fgetc (stdin
);
1806 /* We expect fgetc to block until a character is read. But
1807 this may not be the case if the terminal was opened with
1808 the NONBLOCK flag. In that case, if there is nothing to
1809 read on stdin, fgetc returns EOF, but also sets the error
1810 condition flag on stdin and errno to EAGAIN. With a true
1811 EOF, stdin's error condition flag is not set.
1813 A situation where this behavior was observed is a pseudo
1815 while (answer
== EOF
&& ferror (stdin
) && errno
== EAGAIN
)
1817 /* Not a real EOF. Wait a little while and try again until
1818 we read something. */
1821 answer
= fgetc (stdin
);
1824 clearerr (stdin
); /* in case of C-d */
1825 if (answer
== EOF
) /* C-d */
1827 printf_filtered ("EOF [assumed %c]\n", def_answer
);
1831 /* Eat rest of input line, to EOF or newline. */
1835 ans2
= fgetc (stdin
);
1838 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1842 /* Check answer. For the non-default, the user must specify
1843 the non-default explicitly. */
1844 if (answer
== not_def_answer
)
1846 retval
= !def_value
;
1849 /* Otherwise, if a default was specified, the user may either
1850 specify the required input or have it default by entering
1852 if (answer
== def_answer
1853 || (defchar
!= '\0' &&
1854 (answer
== '\n' || answer
== '\r' || answer
== EOF
)))
1859 /* Invalid entries are not defaulted and require another selection. */
1860 printf_filtered (_("Please answer %s or %s.\n"),
1861 y_string
, n_string
);
1865 if (annotation_level
> 1)
1866 printf_filtered (("\n\032\032post-query\n"));
1871 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1872 answer is yes, or 0 if answer is defaulted.
1873 Takes three args which are given to printf to print the question.
1874 The first, a control string, should end in "? ".
1875 It should not say how to answer, because we do that. */
1878 nquery (const char *ctlstr
, ...)
1883 va_start (args
, ctlstr
);
1884 ret
= defaulted_query (ctlstr
, 'n', args
);
1889 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1890 answer is yes, or 1 if answer is defaulted.
1891 Takes three args which are given to printf to print the question.
1892 The first, a control string, should end in "? ".
1893 It should not say how to answer, because we do that. */
1896 yquery (const char *ctlstr
, ...)
1901 va_start (args
, ctlstr
);
1902 ret
= defaulted_query (ctlstr
, 'y', args
);
1907 /* Ask user a y-or-n question and return 1 iff answer is yes.
1908 Takes three args which are given to printf to print the question.
1909 The first, a control string, should end in "? ".
1910 It should not say how to answer, because we do that. */
1913 query (const char *ctlstr
, ...)
1918 va_start (args
, ctlstr
);
1919 ret
= defaulted_query (ctlstr
, '\0', args
);
1924 /* A helper for parse_escape that converts a host character to a
1925 target character. C is the host character. If conversion is
1926 possible, then the target character is stored in *TARGET_C and the
1927 function returns 1. Otherwise, the function returns 0. */
1930 host_char_to_target (struct gdbarch
*gdbarch
, int c
, int *target_c
)
1932 struct obstack host_data
;
1934 struct cleanup
*cleanups
;
1937 obstack_init (&host_data
);
1938 cleanups
= make_cleanup_obstack_free (&host_data
);
1940 convert_between_encodings (target_charset (gdbarch
), host_charset (),
1941 &the_char
, 1, 1, &host_data
, translit_none
);
1943 if (obstack_object_size (&host_data
) == 1)
1946 *target_c
= *(char *) obstack_base (&host_data
);
1949 do_cleanups (cleanups
);
1953 /* Parse a C escape sequence. STRING_PTR points to a variable
1954 containing a pointer to the string to parse. That pointer
1955 should point to the character after the \. That pointer
1956 is updated past the characters we use. The value of the
1957 escape sequence is returned.
1959 A negative value means the sequence \ newline was seen,
1960 which is supposed to be equivalent to nothing at all.
1962 If \ is followed by a null character, we return a negative
1963 value and leave the string pointer pointing at the null character.
1965 If \ is followed by 000, we return 0 and leave the string pointer
1966 after the zeros. A value of 0 does not mean end of string. */
1969 parse_escape (struct gdbarch
*gdbarch
, char **string_ptr
)
1971 int target_char
= -2; /* Initialize to avoid GCC warnings. */
1972 int c
= *(*string_ptr
)++;
1991 int i
= host_hex_value (c
);
1996 if (isdigit (c
) && c
!= '8' && c
!= '9')
2000 i
+= host_hex_value (c
);
2036 if (!host_char_to_target (gdbarch
, c
, &target_char
))
2037 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
2038 " which has no equivalent\nin the `%s' character set."),
2039 c
, c
, target_charset (gdbarch
));
2043 /* Print the character C on STREAM as part of the contents of a literal
2044 string whose delimiter is QUOTER. Note that this routine should only
2045 be call for printing things which are independent of the language
2046 of the program being debugged. */
2049 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
2050 void (*do_fprintf
) (struct ui_file
*, const char *, ...)
2051 ATTRIBUTE_FPTR_PRINTF_2
, struct ui_file
*stream
, int quoter
)
2053 c
&= 0xFF; /* Avoid sign bit follies */
2055 if (c
< 0x20 || /* Low control chars */
2056 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
2057 (sevenbit_strings
&& c
>= 0x80))
2058 { /* high order bit set */
2062 do_fputs ("\\n", stream
);
2065 do_fputs ("\\b", stream
);
2068 do_fputs ("\\t", stream
);
2071 do_fputs ("\\f", stream
);
2074 do_fputs ("\\r", stream
);
2077 do_fputs ("\\e", stream
);
2080 do_fputs ("\\a", stream
);
2083 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
2089 if (c
== '\\' || c
== quoter
)
2090 do_fputs ("\\", stream
);
2091 do_fprintf (stream
, "%c", c
);
2095 /* Print the character C on STREAM as part of the contents of a
2096 literal string whose delimiter is QUOTER. Note that these routines
2097 should only be call for printing things which are independent of
2098 the language of the program being debugged. */
2101 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
2104 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
2108 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
2111 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
2115 fputstrn_filtered (const char *str
, int n
, int quoter
,
2116 struct ui_file
*stream
)
2120 for (i
= 0; i
< n
; i
++)
2121 printchar (str
[i
], fputs_filtered
, fprintf_filtered
, stream
, quoter
);
2125 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
2126 struct ui_file
*stream
)
2130 for (i
= 0; i
< n
; i
++)
2131 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
2135 /* Number of lines per page or UINT_MAX if paging is disabled. */
2136 static unsigned int lines_per_page
;
2138 show_lines_per_page (struct ui_file
*file
, int from_tty
,
2139 struct cmd_list_element
*c
, const char *value
)
2141 fprintf_filtered (file
,
2142 _("Number of lines gdb thinks are in a page is %s.\n"),
2146 /* Number of chars per line or UINT_MAX if line folding is disabled. */
2147 static unsigned int chars_per_line
;
2149 show_chars_per_line (struct ui_file
*file
, int from_tty
,
2150 struct cmd_list_element
*c
, const char *value
)
2152 fprintf_filtered (file
,
2153 _("Number of characters gdb thinks "
2154 "are in a line is %s.\n"),
2158 /* Current count of lines printed on this page, chars on this line. */
2159 static unsigned int lines_printed
, chars_printed
;
2161 /* Buffer and start column of buffered text, for doing smarter word-
2162 wrapping. When someone calls wrap_here(), we start buffering output
2163 that comes through fputs_filtered(). If we see a newline, we just
2164 spit it out and forget about the wrap_here(). If we see another
2165 wrap_here(), we spit it out and remember the newer one. If we see
2166 the end of the line, we spit out a newline, the indent, and then
2167 the buffered output. */
2169 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
2170 are waiting to be output (they have already been counted in chars_printed).
2171 When wrap_buffer[0] is null, the buffer is empty. */
2172 static char *wrap_buffer
;
2174 /* Pointer in wrap_buffer to the next character to fill. */
2175 static char *wrap_pointer
;
2177 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
2179 static char *wrap_indent
;
2181 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
2182 is not in effect. */
2183 static int wrap_column
;
2186 /* Inialize the number of lines per page and chars per line. */
2189 init_page_info (void)
2193 lines_per_page
= UINT_MAX
;
2194 chars_per_line
= UINT_MAX
;
2198 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
2203 #if defined(__GO32__)
2204 rows
= ScreenRows ();
2205 cols
= ScreenCols ();
2206 lines_per_page
= rows
;
2207 chars_per_line
= cols
;
2209 /* Make sure Readline has initialized its terminal settings. */
2210 rl_reset_terminal (NULL
);
2212 /* Get the screen size from Readline. */
2213 rl_get_screen_size (&rows
, &cols
);
2214 lines_per_page
= rows
;
2215 chars_per_line
= cols
;
2217 /* Readline should have fetched the termcap entry for us. */
2218 if (tgetnum ("li") < 0 || getenv ("EMACS"))
2220 /* The number of lines per page is not mentioned in the
2221 terminal description. This probably means that paging is
2222 not useful (e.g. emacs shell window), so disable paging. */
2223 lines_per_page
= UINT_MAX
;
2226 /* FIXME: Get rid of this junk. */
2227 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
2228 SIGWINCH_HANDLER (SIGWINCH
);
2231 /* If the output is not a terminal, don't paginate it. */
2232 if (!ui_file_isatty (gdb_stdout
))
2233 lines_per_page
= UINT_MAX
;
2241 /* Helper for make_cleanup_restore_page_info. */
2244 do_restore_page_info_cleanup (void *arg
)
2250 /* Provide cleanup for restoring the terminal size. */
2253 make_cleanup_restore_page_info (void)
2255 struct cleanup
*back_to
;
2257 back_to
= make_cleanup (do_restore_page_info_cleanup
, NULL
);
2258 make_cleanup_restore_uinteger (&lines_per_page
);
2259 make_cleanup_restore_uinteger (&chars_per_line
);
2264 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
2265 Provide cleanup for restoring the original state. */
2268 set_batch_flag_and_make_cleanup_restore_page_info (void)
2270 struct cleanup
*back_to
= make_cleanup_restore_page_info ();
2272 make_cleanup_restore_integer (&batch_flag
);
2279 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
2282 set_screen_size (void)
2284 int rows
= lines_per_page
;
2285 int cols
= chars_per_line
;
2293 /* Update Readline's idea of the terminal size. */
2294 rl_set_screen_size (rows
, cols
);
2297 /* Reinitialize WRAP_BUFFER according to the current value of
2303 if (chars_per_line
== 0)
2308 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
2309 wrap_buffer
[0] = '\0';
2312 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
2313 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
2317 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
2324 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
2329 /* Wait, so the user can read what's on the screen. Prompt the user
2330 to continue by pressing RETURN. */
2333 prompt_for_continue (void)
2336 char cont_prompt
[120];
2338 if (annotation_level
> 1)
2339 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
2341 strcpy (cont_prompt
,
2342 "---Type <return> to continue, or q <return> to quit---");
2343 if (annotation_level
> 1)
2344 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
2346 /* We must do this *before* we call gdb_readline, else it will eventually
2347 call us -- thinking that we're trying to print beyond the end of the
2349 reinitialize_more_filter ();
2352 /* On a real operating system, the user can quit with SIGINT.
2355 'q' is provided on all systems so users don't have to change habits
2356 from system to system, and because telling them what to do in
2357 the prompt is more user-friendly than expecting them to think of
2359 /* Call readline, not gdb_readline, because GO32 readline handles control-C
2360 whereas control-C to gdb_readline will cause the user to get dumped
2362 ignore
= gdb_readline_wrapper (cont_prompt
);
2364 if (annotation_level
> 1)
2365 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
2371 while (*p
== ' ' || *p
== '\t')
2374 async_request_quit (0);
2379 /* Now we have to do this again, so that GDB will know that it doesn't
2380 need to save the ---Type <return>--- line at the top of the screen. */
2381 reinitialize_more_filter ();
2383 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
2386 /* Reinitialize filter; ie. tell it to reset to original values. */
2389 reinitialize_more_filter (void)
2395 /* Indicate that if the next sequence of characters overflows the line,
2396 a newline should be inserted here rather than when it hits the end.
2397 If INDENT is non-null, it is a string to be printed to indent the
2398 wrapped part on the next line. INDENT must remain accessible until
2399 the next call to wrap_here() or until a newline is printed through
2402 If the line is already overfull, we immediately print a newline and
2403 the indentation, and disable further wrapping.
2405 If we don't know the width of lines, but we know the page height,
2406 we must not wrap words, but should still keep track of newlines
2407 that were explicitly printed.
2409 INDENT should not contain tabs, as that will mess up the char count
2410 on the next line. FIXME.
2412 This routine is guaranteed to force out any output which has been
2413 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
2414 used to force out output from the wrap_buffer. */
2417 wrap_here (char *indent
)
2419 /* This should have been allocated, but be paranoid anyway. */
2421 internal_error (__FILE__
, __LINE__
,
2422 _("failed internal consistency check"));
2426 *wrap_pointer
= '\0';
2427 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
2429 wrap_pointer
= wrap_buffer
;
2430 wrap_buffer
[0] = '\0';
2431 if (chars_per_line
== UINT_MAX
) /* No line overflow checking. */
2435 else if (chars_printed
>= chars_per_line
)
2437 puts_filtered ("\n");
2439 puts_filtered (indent
);
2444 wrap_column
= chars_printed
;
2448 wrap_indent
= indent
;
2452 /* Print input string to gdb_stdout, filtered, with wrap,
2453 arranging strings in columns of n chars. String can be
2454 right or left justified in the column. Never prints
2455 trailing spaces. String should never be longer than
2456 width. FIXME: this could be useful for the EXAMINE
2457 command, which currently doesn't tabulate very well. */
2460 puts_filtered_tabular (char *string
, int width
, int right
)
2466 gdb_assert (chars_per_line
> 0);
2467 if (chars_per_line
== UINT_MAX
)
2469 fputs_filtered (string
, gdb_stdout
);
2470 fputs_filtered ("\n", gdb_stdout
);
2474 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
2475 fputs_filtered ("\n", gdb_stdout
);
2477 if (width
>= chars_per_line
)
2478 width
= chars_per_line
- 1;
2480 stringlen
= strlen (string
);
2482 if (chars_printed
> 0)
2483 spaces
= width
- (chars_printed
- 1) % width
- 1;
2485 spaces
+= width
- stringlen
;
2487 spacebuf
= alloca (spaces
+ 1);
2488 spacebuf
[spaces
] = '\0';
2490 spacebuf
[spaces
] = ' ';
2492 fputs_filtered (spacebuf
, gdb_stdout
);
2493 fputs_filtered (string
, gdb_stdout
);
2497 /* Ensure that whatever gets printed next, using the filtered output
2498 commands, starts at the beginning of the line. I.e. if there is
2499 any pending output for the current line, flush it and start a new
2500 line. Otherwise do nothing. */
2505 if (chars_printed
> 0)
2507 puts_filtered ("\n");
2512 /* Like fputs but if FILTER is true, pause after every screenful.
2514 Regardless of FILTER can wrap at points other than the final
2515 character of a line.
2517 Unlike fputs, fputs_maybe_filtered does not return a value.
2518 It is OK for LINEBUFFER to be NULL, in which case just don't print
2521 Note that a longjmp to top level may occur in this routine (only if
2522 FILTER is true) (since prompt_for_continue may do so) so this
2523 routine should not be called when cleanups are not in place. */
2526 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
2529 const char *lineptr
;
2531 if (linebuffer
== 0)
2534 /* Don't do any filtering if it is disabled. */
2535 if (stream
!= gdb_stdout
2536 || ! pagination_enabled
2537 || ! input_from_terminal_p ()
2538 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
2539 || top_level_interpreter () == NULL
2540 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2542 fputs_unfiltered (linebuffer
, stream
);
2546 /* Go through and output each character. Show line extension
2547 when this is necessary; prompt user for new page when this is
2550 lineptr
= linebuffer
;
2553 /* Possible new page. */
2554 if (filter
&& (lines_printed
>= lines_per_page
- 1))
2555 prompt_for_continue ();
2557 while (*lineptr
&& *lineptr
!= '\n')
2559 /* Print a single line. */
2560 if (*lineptr
== '\t')
2563 *wrap_pointer
++ = '\t';
2565 fputc_unfiltered ('\t', stream
);
2566 /* Shifting right by 3 produces the number of tab stops
2567 we have already passed, and then adding one and
2568 shifting left 3 advances to the next tab stop. */
2569 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
2575 *wrap_pointer
++ = *lineptr
;
2577 fputc_unfiltered (*lineptr
, stream
);
2582 if (chars_printed
>= chars_per_line
)
2584 unsigned int save_chars
= chars_printed
;
2588 /* If we aren't actually wrapping, don't output newline --
2589 if chars_per_line is right, we probably just overflowed
2590 anyway; if it's wrong, let us keep going. */
2592 fputc_unfiltered ('\n', stream
);
2594 /* Possible new page. */
2595 if (lines_printed
>= lines_per_page
- 1)
2596 prompt_for_continue ();
2598 /* Now output indentation and wrapped string. */
2601 fputs_unfiltered (wrap_indent
, stream
);
2602 *wrap_pointer
= '\0'; /* Null-terminate saved stuff, */
2603 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it. */
2604 /* FIXME, this strlen is what prevents wrap_indent from
2605 containing tabs. However, if we recurse to print it
2606 and count its chars, we risk trouble if wrap_indent is
2607 longer than (the user settable) chars_per_line.
2608 Note also that this can set chars_printed > chars_per_line
2609 if we are printing a long string. */
2610 chars_printed
= strlen (wrap_indent
)
2611 + (save_chars
- wrap_column
);
2612 wrap_pointer
= wrap_buffer
; /* Reset buffer */
2613 wrap_buffer
[0] = '\0';
2614 wrap_column
= 0; /* And disable fancy wrap */
2619 if (*lineptr
== '\n')
2622 wrap_here ((char *) 0); /* Spit out chars, cancel
2625 fputc_unfiltered ('\n', stream
);
2632 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
2634 fputs_maybe_filtered (linebuffer
, stream
, 1);
2638 putchar_unfiltered (int c
)
2642 ui_file_write (gdb_stdout
, &buf
, 1);
2646 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2647 May return nonlocally. */
2650 putchar_filtered (int c
)
2652 return fputc_filtered (c
, gdb_stdout
);
2656 fputc_unfiltered (int c
, struct ui_file
*stream
)
2660 ui_file_write (stream
, &buf
, 1);
2665 fputc_filtered (int c
, struct ui_file
*stream
)
2671 fputs_filtered (buf
, stream
);
2675 /* puts_debug is like fputs_unfiltered, except it prints special
2676 characters in printable fashion. */
2679 puts_debug (char *prefix
, char *string
, char *suffix
)
2683 /* Print prefix and suffix after each line. */
2684 static int new_line
= 1;
2685 static int return_p
= 0;
2686 static char *prev_prefix
= "";
2687 static char *prev_suffix
= "";
2689 if (*string
== '\n')
2692 /* If the prefix is changing, print the previous suffix, a new line,
2693 and the new prefix. */
2694 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2696 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2697 fputs_unfiltered ("\n", gdb_stdlog
);
2698 fputs_unfiltered (prefix
, gdb_stdlog
);
2701 /* Print prefix if we printed a newline during the previous call. */
2705 fputs_unfiltered (prefix
, gdb_stdlog
);
2708 prev_prefix
= prefix
;
2709 prev_suffix
= suffix
;
2711 /* Output characters in a printable format. */
2712 while ((ch
= *string
++) != '\0')
2718 fputc_unfiltered (ch
, gdb_stdlog
);
2721 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2725 fputs_unfiltered ("\\\\", gdb_stdlog
);
2728 fputs_unfiltered ("\\b", gdb_stdlog
);
2731 fputs_unfiltered ("\\f", gdb_stdlog
);
2735 fputs_unfiltered ("\\n", gdb_stdlog
);
2738 fputs_unfiltered ("\\r", gdb_stdlog
);
2741 fputs_unfiltered ("\\t", gdb_stdlog
);
2744 fputs_unfiltered ("\\v", gdb_stdlog
);
2748 return_p
= ch
== '\r';
2751 /* Print suffix if we printed a newline. */
2754 fputs_unfiltered (suffix
, gdb_stdlog
);
2755 fputs_unfiltered ("\n", gdb_stdlog
);
2760 /* Print a variable number of ARGS using format FORMAT. If this
2761 information is going to put the amount written (since the last call
2762 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2763 call prompt_for_continue to get the users permision to continue.
2765 Unlike fprintf, this function does not return a value.
2767 We implement three variants, vfprintf (takes a vararg list and stream),
2768 fprintf (takes a stream to write on), and printf (the usual).
2770 Note also that a longjmp to top level may occur in this routine
2771 (since prompt_for_continue may do so) so this routine should not be
2772 called when cleanups are not in place. */
2775 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2776 va_list args
, int filter
)
2779 struct cleanup
*old_cleanups
;
2781 linebuffer
= xstrvprintf (format
, args
);
2782 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2783 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2784 do_cleanups (old_cleanups
);
2789 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2791 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2795 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2798 struct cleanup
*old_cleanups
;
2800 linebuffer
= xstrvprintf (format
, args
);
2801 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2802 if (debug_timestamp
&& stream
== gdb_stdlog
)
2808 gettimeofday (&tm
, NULL
);
2810 len
= strlen (linebuffer
);
2811 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
2813 timestamp
= xstrprintf ("%ld:%ld %s%s",
2814 (long) tm
.tv_sec
, (long) tm
.tv_usec
,
2816 need_nl
? "\n": "");
2817 make_cleanup (xfree
, timestamp
);
2818 fputs_unfiltered (timestamp
, stream
);
2821 fputs_unfiltered (linebuffer
, stream
);
2822 do_cleanups (old_cleanups
);
2826 vprintf_filtered (const char *format
, va_list args
)
2828 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2832 vprintf_unfiltered (const char *format
, va_list args
)
2834 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2838 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2842 va_start (args
, format
);
2843 vfprintf_filtered (stream
, format
, args
);
2848 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2852 va_start (args
, format
);
2853 vfprintf_unfiltered (stream
, format
, args
);
2857 /* Like fprintf_filtered, but prints its result indented.
2858 Called as fprintfi_filtered (spaces, stream, format, ...); */
2861 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2866 va_start (args
, format
);
2867 print_spaces_filtered (spaces
, stream
);
2869 vfprintf_filtered (stream
, format
, args
);
2875 printf_filtered (const char *format
, ...)
2879 va_start (args
, format
);
2880 vfprintf_filtered (gdb_stdout
, format
, args
);
2886 printf_unfiltered (const char *format
, ...)
2890 va_start (args
, format
);
2891 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2895 /* Like printf_filtered, but prints it's result indented.
2896 Called as printfi_filtered (spaces, format, ...); */
2899 printfi_filtered (int spaces
, const char *format
, ...)
2903 va_start (args
, format
);
2904 print_spaces_filtered (spaces
, gdb_stdout
);
2905 vfprintf_filtered (gdb_stdout
, format
, args
);
2909 /* Easy -- but watch out!
2911 This routine is *not* a replacement for puts()! puts() appends a newline.
2912 This one doesn't, and had better not! */
2915 puts_filtered (const char *string
)
2917 fputs_filtered (string
, gdb_stdout
);
2921 puts_unfiltered (const char *string
)
2923 fputs_unfiltered (string
, gdb_stdout
);
2926 /* Return a pointer to N spaces and a null. The pointer is good
2927 until the next call to here. */
2932 static char *spaces
= 0;
2933 static int max_spaces
= -1;
2939 spaces
= (char *) xmalloc (n
+ 1);
2940 for (t
= spaces
+ n
; t
!= spaces
;)
2946 return spaces
+ max_spaces
- n
;
2949 /* Print N spaces. */
2951 print_spaces_filtered (int n
, struct ui_file
*stream
)
2953 fputs_filtered (n_spaces (n
), stream
);
2956 /* C++/ObjC demangler stuff. */
2958 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2959 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2960 If the name is not mangled, or the language for the name is unknown, or
2961 demangling is off, the name is printed in its "raw" form. */
2964 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2965 enum language lang
, int arg_mode
)
2971 /* If user wants to see raw output, no problem. */
2974 fputs_filtered (name
, stream
);
2978 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2979 fputs_filtered (demangled
? demangled
: name
, stream
);
2980 if (demangled
!= NULL
)
2988 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2989 differences in whitespace. Returns 0 if they match, non-zero if they
2990 don't (slightly different than strcmp()'s range of return values).
2992 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2993 This "feature" is useful when searching for matching C++ function names
2994 (such as if the user types 'break FOO', where FOO is a mangled C++
2998 strcmp_iw (const char *string1
, const char *string2
)
3000 while ((*string1
!= '\0') && (*string2
!= '\0'))
3002 while (isspace (*string1
))
3006 while (isspace (*string2
))
3010 if (case_sensitivity
== case_sensitive_on
&& *string1
!= *string2
)
3012 if (case_sensitivity
== case_sensitive_off
3013 && (tolower ((unsigned char) *string1
)
3014 != tolower ((unsigned char) *string2
)))
3016 if (*string1
!= '\0')
3022 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
3025 /* This is like strcmp except that it ignores whitespace and treats
3026 '(' as the first non-NULL character in terms of ordering. Like
3027 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
3028 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
3029 according to that ordering.
3031 If a list is sorted according to this function and if you want to
3032 find names in the list that match some fixed NAME according to
3033 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
3034 where this function would put NAME.
3036 This function must be neutral to the CASE_SENSITIVITY setting as the user
3037 may choose it during later lookup. Therefore this function always sorts
3038 primarily case-insensitively and secondarily case-sensitively.
3040 Here are some examples of why using strcmp to sort is a bad idea:
3044 Say your partial symtab contains: "foo<char *>", "goo". Then, if
3045 we try to do a search for "foo<char*>", strcmp will locate this
3046 after "foo<char *>" and before "goo". Then lookup_partial_symbol
3047 will start looking at strings beginning with "goo", and will never
3048 see the correct match of "foo<char *>".
3050 Parenthesis example:
3052 In practice, this is less like to be an issue, but I'll give it a
3053 shot. Let's assume that '$' is a legitimate character to occur in
3054 symbols. (Which may well even be the case on some systems.) Then
3055 say that the partial symbol table contains "foo$" and "foo(int)".
3056 strcmp will put them in this order, since '$' < '('. Now, if the
3057 user searches for "foo", then strcmp will sort "foo" before "foo$".
3058 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
3059 "foo") is false, so it won't proceed to the actual match of
3060 "foo(int)" with "foo". */
3063 strcmp_iw_ordered (const char *string1
, const char *string2
)
3065 const char *saved_string1
= string1
, *saved_string2
= string2
;
3066 enum case_sensitivity case_pass
= case_sensitive_off
;
3070 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
3071 Provide stub characters if we are already at the end of one of the
3073 char c1
= 'X', c2
= 'X';
3075 while (*string1
!= '\0' && *string2
!= '\0')
3077 while (isspace (*string1
))
3079 while (isspace (*string2
))
3084 case case_sensitive_off
:
3085 c1
= tolower ((unsigned char) *string1
);
3086 c2
= tolower ((unsigned char) *string2
);
3088 case case_sensitive_on
:
3096 if (*string1
!= '\0')
3105 /* Characters are non-equal unless they're both '\0'; we want to
3106 make sure we get the comparison right according to our
3107 comparison in the cases where one of them is '\0' or '('. */
3109 if (*string2
== '\0')
3114 if (*string2
== '\0')
3119 if (*string2
== '\0' || *string2
== '(')
3128 if (case_pass
== case_sensitive_on
)
3131 /* Otherwise the strings were equal in case insensitive way, make
3132 a more fine grained comparison in a case sensitive way. */
3134 case_pass
= case_sensitive_on
;
3135 string1
= saved_string1
;
3136 string2
= saved_string2
;
3140 /* A simple comparison function with opposite semantics to strcmp. */
3143 streq (const char *lhs
, const char *rhs
)
3145 return !strcmp (lhs
, rhs
);
3151 ** Answer whether string_to_compare is a full or partial match to
3152 ** template_string. The partial match must be in sequence starting
3156 subset_compare (char *string_to_compare
, char *template_string
)
3160 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
3161 && strlen (string_to_compare
) <= strlen (template_string
))
3164 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
3171 pagination_on_command (char *arg
, int from_tty
)
3173 pagination_enabled
= 1;
3177 pagination_off_command (char *arg
, int from_tty
)
3179 pagination_enabled
= 0;
3183 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
3184 struct cmd_list_element
*c
, const char *value
)
3186 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"),
3192 initialize_utils (void)
3194 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
3195 Set number of characters gdb thinks are in a line."), _("\
3196 Show number of characters gdb thinks are in a line."), NULL
,
3198 show_chars_per_line
,
3199 &setlist
, &showlist
);
3201 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
3202 Set number of lines gdb thinks are in a page."), _("\
3203 Show number of lines gdb thinks are in a page."), NULL
,
3205 show_lines_per_page
,
3206 &setlist
, &showlist
);
3210 add_setshow_boolean_cmd ("demangle", class_support
, &demangle
, _("\
3211 Set demangling of encoded C++/ObjC names when displaying symbols."), _("\
3212 Show demangling of encoded C++/ObjC names when displaying symbols."), NULL
,
3215 &setprintlist
, &showprintlist
);
3217 add_setshow_boolean_cmd ("pagination", class_support
,
3218 &pagination_enabled
, _("\
3219 Set state of pagination."), _("\
3220 Show state of pagination."), NULL
,
3222 show_pagination_enabled
,
3223 &setlist
, &showlist
);
3227 add_com ("am", class_support
, pagination_on_command
,
3228 _("Enable pagination"));
3229 add_com ("sm", class_support
, pagination_off_command
,
3230 _("Disable pagination"));
3233 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
3234 &sevenbit_strings
, _("\
3235 Set printing of 8-bit characters in strings as \\nnn."), _("\
3236 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
3238 show_sevenbit_strings
,
3239 &setprintlist
, &showprintlist
);
3241 add_setshow_boolean_cmd ("asm-demangle", class_support
, &asm_demangle
, _("\
3242 Set demangling of C++/ObjC names in disassembly listings."), _("\
3243 Show demangling of C++/ObjC names in disassembly listings."), NULL
,
3246 &setprintlist
, &showprintlist
);
3248 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
3249 &debug_timestamp
, _("\
3250 Set timestamping of debugging messages."), _("\
3251 Show timestamping of debugging messages."), _("\
3252 When set, debugging messages will be marked with seconds and microseconds."),
3254 show_debug_timestamp
,
3255 &setdebuglist
, &showdebuglist
);
3258 /* Machine specific function to handle SIGWINCH signal. */
3260 #ifdef SIGWINCH_HANDLER_BODY
3261 SIGWINCH_HANDLER_BODY
3263 /* Print routines to handle variable size regs, etc. */
3264 /* Temporary storage using circular buffer. */
3270 static char buf
[NUMCELLS
][CELLSIZE
];
3271 static int cell
= 0;
3273 if (++cell
>= NUMCELLS
)
3279 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3281 /* Truncate address to the size of a target address, avoiding shifts
3282 larger or equal than the width of a CORE_ADDR. The local
3283 variable ADDR_BIT stops the compiler reporting a shift overflow
3284 when it won't occur. */
3285 /* NOTE: This assumes that the significant address information is
3286 kept in the least significant bits of ADDR - the upper bits were
3287 either zero or sign extended. Should gdbarch_address_to_pointer or
3288 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
3290 int addr_bit
= gdbarch_addr_bit (gdbarch
);
3292 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
3293 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
3294 return hex_string (addr
);
3297 /* This function is described in "defs.h". */
3300 print_core_address (struct gdbarch
*gdbarch
, CORE_ADDR address
)
3302 int addr_bit
= gdbarch_addr_bit (gdbarch
);
3304 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
3305 address
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
3307 /* FIXME: cagney/2002-05-03: Need local_address_string() function
3308 that returns the language localized string formatted to a width
3309 based on gdbarch_addr_bit. */
3311 return hex_string_custom (address
, 8);
3313 return hex_string_custom (address
, 16);
3317 decimal2str (char *sign
, ULONGEST addr
, int width
)
3319 /* Steal code from valprint.c:print_decimal(). Should this worry
3320 about the real size of addr as the above does? */
3321 unsigned long temp
[3];
3322 char *str
= get_cell ();
3327 temp
[i
] = addr
% (1000 * 1000 * 1000);
3328 addr
/= (1000 * 1000 * 1000);
3332 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
3341 xsnprintf (str
, CELLSIZE
, "%s%0*lu", sign
, width
, temp
[0]);
3344 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu", sign
, width
,
3348 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu%09lu", sign
, width
,
3349 temp
[2], temp
[1], temp
[0]);
3352 internal_error (__FILE__
, __LINE__
,
3353 _("failed internal consistency check"));
3360 octal2str (ULONGEST addr
, int width
)
3362 unsigned long temp
[3];
3363 char *str
= get_cell ();
3368 temp
[i
] = addr
% (0100000 * 0100000);
3369 addr
/= (0100000 * 0100000);
3373 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
3383 xsnprintf (str
, CELLSIZE
, "%*o", width
, 0);
3385 xsnprintf (str
, CELLSIZE
, "0%0*lo", width
, temp
[0]);
3388 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo", width
, temp
[1], temp
[0]);
3391 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo%010lo", width
,
3392 temp
[2], temp
[1], temp
[0]);
3395 internal_error (__FILE__
, __LINE__
,
3396 _("failed internal consistency check"));
3403 pulongest (ULONGEST u
)
3405 return decimal2str ("", u
, 0);
3409 plongest (LONGEST l
)
3412 return decimal2str ("-", -l
, 0);
3414 return decimal2str ("", l
, 0);
3417 /* Eliminate warning from compiler on 32-bit systems. */
3418 static int thirty_two
= 32;
3421 phex (ULONGEST l
, int sizeof_l
)
3429 xsnprintf (str
, CELLSIZE
, "%08lx%08lx",
3430 (unsigned long) (l
>> thirty_two
),
3431 (unsigned long) (l
& 0xffffffff));
3435 xsnprintf (str
, CELLSIZE
, "%08lx", (unsigned long) l
);
3439 xsnprintf (str
, CELLSIZE
, "%04x", (unsigned short) (l
& 0xffff));
3442 str
= phex (l
, sizeof (l
));
3450 phex_nz (ULONGEST l
, int sizeof_l
)
3458 unsigned long high
= (unsigned long) (l
>> thirty_two
);
3462 xsnprintf (str
, CELLSIZE
, "%lx",
3463 (unsigned long) (l
& 0xffffffff));
3465 xsnprintf (str
, CELLSIZE
, "%lx%08lx", high
,
3466 (unsigned long) (l
& 0xffffffff));
3471 xsnprintf (str
, CELLSIZE
, "%lx", (unsigned long) l
);
3475 xsnprintf (str
, CELLSIZE
, "%x", (unsigned short) (l
& 0xffff));
3478 str
= phex_nz (l
, sizeof (l
));
3485 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
3486 in a static string. Returns a pointer to this string. */
3488 hex_string (LONGEST num
)
3490 char *result
= get_cell ();
3492 xsnprintf (result
, CELLSIZE
, "0x%s", phex_nz (num
, sizeof (num
)));
3496 /* Converts a LONGEST number to a C-format hexadecimal literal and
3497 stores it in a static string. Returns a pointer to this string
3498 that is valid until the next call. The number is padded on the
3499 left with 0s to at least WIDTH characters. */
3501 hex_string_custom (LONGEST num
, int width
)
3503 char *result
= get_cell ();
3504 char *result_end
= result
+ CELLSIZE
- 1;
3505 const char *hex
= phex_nz (num
, sizeof (num
));
3506 int hex_len
= strlen (hex
);
3508 if (hex_len
> width
)
3510 if (width
+ 2 >= CELLSIZE
)
3511 internal_error (__FILE__
, __LINE__
, _("\
3512 hex_string_custom: insufficient space to store result"));
3514 strcpy (result_end
- width
- 2, "0x");
3515 memset (result_end
- width
, '0', width
);
3516 strcpy (result_end
- hex_len
, hex
);
3517 return result_end
- width
- 2;
3520 /* Convert VAL to a numeral in the given radix. For
3521 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
3522 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
3523 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
3524 * to use C format in all cases. If it is false, then 'x'
3525 * and 'o' formats do not include a prefix (0x or leading 0). */
3528 int_string (LONGEST val
, int radix
, int is_signed
, int width
,
3538 result
= hex_string (val
);
3540 result
= hex_string_custom (val
, width
);
3547 if (is_signed
&& val
< 0)
3548 return decimal2str ("-", -val
, width
);
3550 return decimal2str ("", val
, width
);
3554 char *result
= octal2str (val
, width
);
3556 if (use_c_format
|| val
== 0)
3562 internal_error (__FILE__
, __LINE__
,
3563 _("failed internal consistency check"));
3567 /* Convert a CORE_ADDR into a string. */
3569 core_addr_to_string (const CORE_ADDR addr
)
3571 char *str
= get_cell ();
3574 strcat (str
, phex (addr
, sizeof (addr
)));
3579 core_addr_to_string_nz (const CORE_ADDR addr
)
3581 char *str
= get_cell ();
3584 strcat (str
, phex_nz (addr
, sizeof (addr
)));
3588 /* Convert a string back into a CORE_ADDR. */
3590 string_to_core_addr (const char *my_string
)
3594 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
3596 /* Assume that it is in hex. */
3599 for (i
= 2; my_string
[i
] != '\0'; i
++)
3601 if (isdigit (my_string
[i
]))
3602 addr
= (my_string
[i
] - '0') + (addr
* 16);
3603 else if (isxdigit (my_string
[i
]))
3604 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
3606 error (_("invalid hex \"%s\""), my_string
);
3611 /* Assume that it is in decimal. */
3614 for (i
= 0; my_string
[i
] != '\0'; i
++)
3616 if (isdigit (my_string
[i
]))
3617 addr
= (my_string
[i
] - '0') + (addr
* 10);
3619 error (_("invalid decimal \"%s\""), my_string
);
3627 host_address_to_string (const void *addr
)
3629 char *str
= get_cell ();
3631 xsnprintf (str
, CELLSIZE
, "0x%s", phex_nz ((uintptr_t) addr
, sizeof (addr
)));
3636 gdb_realpath (const char *filename
)
3638 /* Method 1: The system has a compile time upper bound on a filename
3639 path. Use that and realpath() to canonicalize the name. This is
3640 the most common case. Note that, if there isn't a compile time
3641 upper bound, you want to avoid realpath() at all costs. */
3642 #if defined(HAVE_REALPATH)
3644 # if defined (PATH_MAX)
3646 # define USE_REALPATH
3647 # elif defined (MAXPATHLEN)
3648 char buf
[MAXPATHLEN
];
3649 # define USE_REALPATH
3651 # if defined (USE_REALPATH)
3652 const char *rp
= realpath (filename
, buf
);
3656 return xstrdup (rp
);
3659 #endif /* HAVE_REALPATH */
3661 /* Method 2: The host system (i.e., GNU) has the function
3662 canonicalize_file_name() which malloc's a chunk of memory and
3663 returns that, use that. */
3664 #if defined(HAVE_CANONICALIZE_FILE_NAME)
3666 char *rp
= canonicalize_file_name (filename
);
3669 return xstrdup (filename
);
3675 /* FIXME: cagney/2002-11-13:
3677 Method 2a: Use realpath() with a NULL buffer. Some systems, due
3678 to the problems described in method 3, have modified their
3679 realpath() implementation so that it will allocate a buffer when
3680 NULL is passed in. Before this can be used, though, some sort of
3681 configure time test would need to be added. Otherwize the code
3682 will likely core dump. */
3684 /* Method 3: Now we're getting desperate! The system doesn't have a
3685 compile time buffer size and no alternative function. Query the
3686 OS, using pathconf(), for the buffer limit. Care is needed
3687 though, some systems do not limit PATH_MAX (return -1 for
3688 pathconf()) making it impossible to pass a correctly sized buffer
3689 to realpath() (it could always overflow). On those systems, we
3691 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
3693 /* Find out the max path size. */
3694 long path_max
= pathconf ("/", _PC_PATH_MAX
);
3698 /* PATH_MAX is bounded. */
3699 char *buf
= alloca (path_max
);
3700 char *rp
= realpath (filename
, buf
);
3702 return xstrdup (rp
? rp
: filename
);
3707 /* This system is a lost cause, just dup the buffer. */
3708 return xstrdup (filename
);
3711 /* Return a copy of FILENAME, with its directory prefix canonicalized
3715 xfullpath (const char *filename
)
3717 const char *base_name
= lbasename (filename
);
3722 /* Extract the basename of filename, and return immediately
3723 a copy of filename if it does not contain any directory prefix. */
3724 if (base_name
== filename
)
3725 return xstrdup (filename
);
3727 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
3728 /* Allocate enough space to store the dir_name + plus one extra
3729 character sometimes needed under Windows (see below), and
3730 then the closing \000 character. */
3731 strncpy (dir_name
, filename
, base_name
- filename
);
3732 dir_name
[base_name
- filename
] = '\000';
3734 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3735 /* We need to be careful when filename is of the form 'd:foo', which
3736 is equivalent of d:./foo, which is totally different from d:/foo. */
3737 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
3740 dir_name
[3] = '\000';
3744 /* Canonicalize the directory prefix, and build the resulting
3745 filename. If the dirname realpath already contains an ending
3746 directory separator, avoid doubling it. */
3747 real_path
= gdb_realpath (dir_name
);
3748 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
3749 result
= concat (real_path
, base_name
, (char *) NULL
);
3751 result
= concat (real_path
, SLASH_STRING
, base_name
, (char *) NULL
);
3758 /* This is the 32-bit CRC function used by the GNU separate debug
3759 facility. An executable may contain a section named
3760 .gnu_debuglink, which holds the name of a separate executable file
3761 containing its debug info, and a checksum of that file's contents,
3762 computed using this function. */
3764 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
3766 static const unsigned int crc32_table
[256] = {
3767 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3768 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3769 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3770 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3771 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3772 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3773 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3774 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3775 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3776 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3777 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3778 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3779 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3780 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3781 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3782 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3783 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3784 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3785 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3786 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3787 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3788 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3789 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3790 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3791 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3792 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3793 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3794 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3795 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3796 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3797 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3798 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3799 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3800 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3801 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3802 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3803 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3804 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3805 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3806 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3807 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3808 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3809 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3810 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3811 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3812 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3813 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3814 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3815 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3816 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3817 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3822 crc
= ~crc
& 0xffffffff;
3823 for (end
= buf
+ len
; buf
< end
; ++buf
)
3824 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
3825 return ~crc
& 0xffffffff;
3829 align_up (ULONGEST v
, int n
)
3831 /* Check that N is really a power of two. */
3832 gdb_assert (n
&& (n
& (n
-1)) == 0);
3833 return (v
+ n
- 1) & -n
;
3837 align_down (ULONGEST v
, int n
)
3839 /* Check that N is really a power of two. */
3840 gdb_assert (n
&& (n
& (n
-1)) == 0);
3844 /* Allocation function for the libiberty hash table which uses an
3845 obstack. The obstack is passed as DATA. */
3848 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
3850 unsigned int total
= size
* count
;
3851 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
3853 memset (ptr
, 0, total
);
3857 /* Trivial deallocation function for the libiberty splay tree and hash
3858 table - don't deallocate anything. Rely on later deletion of the
3859 obstack. DATA will be the obstack, although it is not needed
3863 dummy_obstack_deallocate (void *object
, void *data
)
3868 /* The bit offset of the highest byte in a ULONGEST, for overflow
3871 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3873 /* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3874 where 2 <= BASE <= 36. */
3877 is_digit_in_base (unsigned char digit
, int base
)
3879 if (!isalnum (digit
))
3882 return (isdigit (digit
) && digit
< base
+ '0');
3884 return (isdigit (digit
) || tolower (digit
) < base
- 10 + 'a');
3888 digit_to_int (unsigned char c
)
3893 return tolower (c
) - 'a' + 10;
3896 /* As for strtoul, but for ULONGEST results. */
3899 strtoulst (const char *num
, const char **trailer
, int base
)
3901 unsigned int high_part
;
3906 /* Skip leading whitespace. */
3907 while (isspace (num
[i
]))
3910 /* Handle prefixes. */
3913 else if (num
[i
] == '-')
3919 if (base
== 0 || base
== 16)
3921 if (num
[i
] == '0' && (num
[i
+ 1] == 'x' || num
[i
+ 1] == 'X'))
3929 if (base
== 0 && num
[i
] == '0')
3935 if (base
< 2 || base
> 36)
3941 result
= high_part
= 0;
3942 for (; is_digit_in_base (num
[i
], base
); i
+= 1)
3944 result
= result
* base
+ digit_to_int (num
[i
]);
3945 high_part
= high_part
* base
+ (unsigned int) (result
>> HIGH_BYTE_POSN
);
3946 result
&= ((ULONGEST
) 1 << HIGH_BYTE_POSN
) - 1;
3947 if (high_part
> 0xff)
3950 result
= ~ (ULONGEST
) 0;
3957 if (trailer
!= NULL
)
3960 result
= result
+ ((ULONGEST
) high_part
<< HIGH_BYTE_POSN
);
3967 /* Simple, portable version of dirname that does not modify its
3971 ldirname (const char *filename
)
3973 const char *base
= lbasename (filename
);
3976 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
3979 if (base
== filename
)
3982 dirname
= xmalloc (base
- filename
+ 2);
3983 memcpy (dirname
, filename
, base
- filename
);
3985 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3986 create "d:./bar" later instead of the (different) "d:/bar". */
3987 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
3988 && !IS_DIR_SEPARATOR (filename
[0]))
3989 dirname
[base
++ - filename
] = '.';
3991 dirname
[base
- filename
] = '\0';
3995 /* Call libiberty's buildargv, and return the result.
3996 If buildargv fails due to out-of-memory, call nomem.
3997 Therefore, the returned value is guaranteed to be non-NULL,
3998 unless the parameter itself is NULL. */
4001 gdb_buildargv (const char *s
)
4003 char **argv
= buildargv (s
);
4005 if (s
!= NULL
&& argv
== NULL
)
4011 compare_positive_ints (const void *ap
, const void *bp
)
4013 /* Because we know we're comparing two ints which are positive,
4014 there's no danger of overflow here. */
4015 return * (int *) ap
- * (int *) bp
;
4018 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
4019 #define AMBIGUOUS_MESS2 \
4020 ".\nUse \"set gnutarget format-name\" to specify the format."
4023 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
4029 /* Check if errmsg just need simple return. */
4030 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
4031 return bfd_errmsg (error_tag
);
4033 ret_len
= strlen (bfd_errmsg (error_tag
)) + strlen (AMBIGUOUS_MESS1
)
4034 + strlen (AMBIGUOUS_MESS2
);
4035 for (p
= matching
; *p
; p
++)
4036 ret_len
+= strlen (*p
) + 1;
4037 ret
= xmalloc (ret_len
+ 1);
4039 make_cleanup (xfree
, ret
);
4041 strcpy (retp
, bfd_errmsg (error_tag
));
4042 retp
+= strlen (retp
);
4044 strcpy (retp
, AMBIGUOUS_MESS1
);
4045 retp
+= strlen (retp
);
4047 for (p
= matching
; *p
; p
++)
4049 sprintf (retp
, " %s", *p
);
4050 retp
+= strlen (retp
);
4054 strcpy (retp
, AMBIGUOUS_MESS2
);
4059 /* Return ARGS parsed as a valid pid, or throw an error. */
4062 parse_pid_to_attach (char *args
)
4068 error_no_arg (_("process-id to attach"));
4071 pid
= strtoul (args
, &dummy
, 0);
4072 /* Some targets don't set errno on errors, grrr! */
4073 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
4074 error (_("Illegal process-id: %s."), args
);
4079 /* Provide a prototype to silence -Wmissing-prototypes. */
4080 extern initialize_file_ftype _initialize_utils
;
4083 _initialize_utils (void)
4085 add_internal_problem_command (&internal_error_problem
);
4086 add_internal_problem_command (&internal_warning_problem
);