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
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_assert.h"
25 #include "gdb_string.h"
26 #include "event-top.h"
27 #include "exceptions.h"
30 #include "tui/tui.h" /* For tui_get_command_dimension. */
37 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
48 #include "expression.h"
52 #include "filenames.h"
54 #include "gdb_obstack.h"
57 #include "inferior.h" /* for signed_pointer_to_address */
59 #include <sys/param.h> /* For MAXPATHLEN */
61 #include "gdb_curses.h"
63 #include "readline/readline.h"
66 extern PTR
malloc (); /* OK: PTR */
68 #if !HAVE_DECL_REALLOC
69 extern PTR
realloc (); /* OK: PTR */
75 /* readline defines this. */
78 void (*deprecated_error_begin_hook
) (void);
80 /* Prototypes for local functions */
82 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
83 va_list, int) ATTR_FORMAT (printf
, 2, 0);
85 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
87 static void do_my_cleanups (struct cleanup
**, struct cleanup
*);
89 static void prompt_for_continue (void);
91 static void set_screen_size (void);
92 static void set_width (void);
94 /* Chain of cleanup actions established with make_cleanup,
95 to be executed if an error happens. */
97 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
98 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
99 static struct cleanup
*run_cleanup_chain
; /* cleaned up on each 'run' */
100 static struct cleanup
*exec_cleanup_chain
; /* cleaned up on each execution command */
101 /* cleaned up on each error from within an execution command */
102 static struct cleanup
*exec_error_cleanup_chain
;
104 /* Pointer to what is left to do for an execution command after the
105 target stops. Used only in asynchronous mode, by targets that
106 support async execution. The finish and until commands use it. So
107 does the target extended-remote command. */
108 struct continuation
*cmd_continuation
;
109 struct continuation
*intermediate_continuation
;
111 /* Nonzero if we have job control. */
115 /* Nonzero means a quit has been requested. */
119 /* Nonzero means quit immediately if Control-C is typed now, rather
120 than waiting until QUIT is executed. Be careful in setting this;
121 code which executes with immediate_quit set has to be very careful
122 about being able to deal with being interrupted at any time. It is
123 almost always better to use QUIT; the only exception I can think of
124 is being able to quit out of a system call (using EINTR loses if
125 the SIGINT happens between the previous QUIT and the system call).
126 To immediately quit in the case in which a SIGINT happens between
127 the previous QUIT and setting immediate_quit (desirable anytime we
128 expect to block), call QUIT after setting immediate_quit. */
132 /* Nonzero means that encoded C++/ObjC names should be printed out in their
133 C++/ObjC form rather than raw. */
137 show_demangle (struct ui_file
*file
, int from_tty
,
138 struct cmd_list_element
*c
, const char *value
)
140 fprintf_filtered (file
, _("\
141 Demangling of encoded C++/ObjC names when displaying symbols is %s.\n"),
145 /* Nonzero means that encoded C++/ObjC names should be printed out in their
146 C++/ObjC form even in assembler language displays. If this is set, but
147 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
149 int asm_demangle
= 0;
151 show_asm_demangle (struct ui_file
*file
, int from_tty
,
152 struct cmd_list_element
*c
, const char *value
)
154 fprintf_filtered (file
, _("\
155 Demangling of C++/ObjC names in disassembly listings is %s.\n"),
159 /* Nonzero means that strings with character values >0x7F should be printed
160 as octal escapes. Zero means just print the value (e.g. it's an
161 international character, and the terminal or window can cope.) */
163 int sevenbit_strings
= 0;
165 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
166 struct cmd_list_element
*c
, const char *value
)
168 fprintf_filtered (file
, _("\
169 Printing of 8-bit characters in strings as \\nnn is %s.\n"),
173 /* String to be printed before error messages, if any. */
175 char *error_pre_print
;
177 /* String to be printed before quit messages, if any. */
179 char *quit_pre_print
;
181 /* String to be printed before warning messages, if any. */
183 char *warning_pre_print
= "\nwarning: ";
185 int pagination_enabled
= 1;
187 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
188 struct cmd_list_element
*c
, const char *value
)
190 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
195 /* Add a new cleanup to the cleanup_chain,
196 and return the previous chain pointer
197 to be passed later to do_cleanups or discard_cleanups.
198 Args are FUNCTION to clean up with, and ARG to pass to it. */
201 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
203 return make_my_cleanup (&cleanup_chain
, function
, arg
);
207 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
209 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
213 make_run_cleanup (make_cleanup_ftype
*function
, void *arg
)
215 return make_my_cleanup (&run_cleanup_chain
, function
, arg
);
219 make_exec_cleanup (make_cleanup_ftype
*function
, void *arg
)
221 return make_my_cleanup (&exec_cleanup_chain
, function
, arg
);
225 make_exec_error_cleanup (make_cleanup_ftype
*function
, void *arg
)
227 return make_my_cleanup (&exec_error_cleanup_chain
, function
, arg
);
231 do_freeargv (void *arg
)
233 freeargv ((char **) arg
);
237 make_cleanup_freeargv (char **arg
)
239 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
243 do_bfd_close_cleanup (void *arg
)
249 make_cleanup_bfd_close (bfd
*abfd
)
251 return make_cleanup (do_bfd_close_cleanup
, abfd
);
255 do_close_cleanup (void *arg
)
263 make_cleanup_close (int fd
)
265 int *saved_fd
= xmalloc (sizeof (fd
));
267 return make_cleanup (do_close_cleanup
, saved_fd
);
271 do_ui_file_delete (void *arg
)
273 ui_file_delete (arg
);
277 make_cleanup_ui_file_delete (struct ui_file
*arg
)
279 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
283 do_free_section_addr_info (void *arg
)
285 free_section_addr_info (arg
);
289 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
291 return make_my_cleanup (&cleanup_chain
, do_free_section_addr_info
, addrs
);
296 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
300 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
301 struct cleanup
*old_chain
= *pmy_chain
;
303 new->next
= *pmy_chain
;
304 new->function
= function
;
311 /* Discard cleanups and do the actions they describe
312 until we get back to the point OLD_CHAIN in the cleanup_chain. */
315 do_cleanups (struct cleanup
*old_chain
)
317 do_my_cleanups (&cleanup_chain
, old_chain
);
321 do_final_cleanups (struct cleanup
*old_chain
)
323 do_my_cleanups (&final_cleanup_chain
, old_chain
);
327 do_run_cleanups (struct cleanup
*old_chain
)
329 do_my_cleanups (&run_cleanup_chain
, old_chain
);
333 do_exec_cleanups (struct cleanup
*old_chain
)
335 do_my_cleanups (&exec_cleanup_chain
, old_chain
);
339 do_exec_error_cleanups (struct cleanup
*old_chain
)
341 do_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
345 do_my_cleanups (struct cleanup
**pmy_chain
,
346 struct cleanup
*old_chain
)
349 while ((ptr
= *pmy_chain
) != old_chain
)
351 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
352 (*ptr
->function
) (ptr
->arg
);
357 /* Discard cleanups, not doing the actions they describe,
358 until we get back to the point OLD_CHAIN in the cleanup_chain. */
361 discard_cleanups (struct cleanup
*old_chain
)
363 discard_my_cleanups (&cleanup_chain
, old_chain
);
367 discard_final_cleanups (struct cleanup
*old_chain
)
369 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
373 discard_exec_error_cleanups (struct cleanup
*old_chain
)
375 discard_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
379 discard_my_cleanups (struct cleanup
**pmy_chain
,
380 struct cleanup
*old_chain
)
383 while ((ptr
= *pmy_chain
) != old_chain
)
385 *pmy_chain
= ptr
->next
;
390 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
394 return save_my_cleanups (&cleanup_chain
);
398 save_final_cleanups (void)
400 return save_my_cleanups (&final_cleanup_chain
);
404 save_my_cleanups (struct cleanup
**pmy_chain
)
406 struct cleanup
*old_chain
= *pmy_chain
;
412 /* Restore the cleanup chain from a previously saved chain. */
414 restore_cleanups (struct cleanup
*chain
)
416 restore_my_cleanups (&cleanup_chain
, chain
);
420 restore_final_cleanups (struct cleanup
*chain
)
422 restore_my_cleanups (&final_cleanup_chain
, chain
);
426 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
431 /* This function is useful for cleanups.
435 old_chain = make_cleanup (free_current_contents, &foo);
437 to arrange to free the object thus allocated. */
440 free_current_contents (void *ptr
)
442 void **location
= ptr
;
443 if (location
== NULL
)
444 internal_error (__FILE__
, __LINE__
,
445 _("free_current_contents: NULL pointer"));
446 if (*location
!= NULL
)
453 /* Provide a known function that does nothing, to use as a base for
454 for a possibly long chain of cleanups. This is useful where we
455 use the cleanup chain for handling normal cleanups as well as dealing
456 with cleanups that need to be done as a result of a call to error().
457 In such cases, we may not be certain where the first cleanup is, unless
458 we have a do-nothing one to always use as the base. */
461 null_cleanup (void *arg
)
465 /* Add a continuation to the continuation list, the global list
466 cmd_continuation. The new continuation will be added at the front.*/
468 add_continuation (void (*continuation_hook
) (struct continuation_arg
*),
469 struct continuation_arg
*arg_list
)
471 struct continuation
*continuation_ptr
;
474 (struct continuation
*) xmalloc (sizeof (struct continuation
));
475 continuation_ptr
->continuation_hook
= continuation_hook
;
476 continuation_ptr
->arg_list
= arg_list
;
477 continuation_ptr
->next
= cmd_continuation
;
478 cmd_continuation
= continuation_ptr
;
481 /* Walk down the cmd_continuation list, and execute all the
482 continuations. There is a problem though. In some cases new
483 continuations may be added while we are in the middle of this
484 loop. If this happens they will be added in the front, and done
485 before we have a chance of exhausting those that were already
486 there. We need to then save the beginning of the list in a pointer
487 and do the continuations from there on, instead of using the
488 global beginning of list as our iteration pointer. */
490 do_all_continuations (void)
492 struct continuation
*continuation_ptr
;
493 struct continuation
*saved_continuation
;
495 /* Copy the list header into another pointer, and set the global
496 list header to null, so that the global list can change as a side
497 effect of invoking the continuations and the processing of
498 the preexisting continuations will not be affected. */
499 continuation_ptr
= cmd_continuation
;
500 cmd_continuation
= NULL
;
502 /* Work now on the list we have set aside. */
503 while (continuation_ptr
)
505 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
506 saved_continuation
= continuation_ptr
;
507 continuation_ptr
= continuation_ptr
->next
;
508 xfree (saved_continuation
);
512 /* Walk down the cmd_continuation list, and get rid of all the
515 discard_all_continuations (void)
517 struct continuation
*continuation_ptr
;
519 while (cmd_continuation
)
521 continuation_ptr
= cmd_continuation
;
522 cmd_continuation
= continuation_ptr
->next
;
523 xfree (continuation_ptr
);
527 /* Add a continuation to the continuation list, the global list
528 intermediate_continuation. The new continuation will be added at
531 add_intermediate_continuation (void (*continuation_hook
)
532 (struct continuation_arg
*),
533 struct continuation_arg
*arg_list
)
535 struct continuation
*continuation_ptr
;
538 (struct continuation
*) xmalloc (sizeof (struct continuation
));
539 continuation_ptr
->continuation_hook
= continuation_hook
;
540 continuation_ptr
->arg_list
= arg_list
;
541 continuation_ptr
->next
= intermediate_continuation
;
542 intermediate_continuation
= continuation_ptr
;
545 /* Walk down the cmd_continuation list, and execute all the
546 continuations. There is a problem though. In some cases new
547 continuations may be added while we are in the middle of this
548 loop. If this happens they will be added in the front, and done
549 before we have a chance of exhausting those that were already
550 there. We need to then save the beginning of the list in a pointer
551 and do the continuations from there on, instead of using the
552 global beginning of list as our iteration pointer.*/
554 do_all_intermediate_continuations (void)
556 struct continuation
*continuation_ptr
;
557 struct continuation
*saved_continuation
;
559 /* Copy the list header into another pointer, and set the global
560 list header to null, so that the global list can change as a side
561 effect of invoking the continuations and the processing of
562 the preexisting continuations will not be affected. */
563 continuation_ptr
= intermediate_continuation
;
564 intermediate_continuation
= NULL
;
566 /* Work now on the list we have set aside. */
567 while (continuation_ptr
)
569 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
570 saved_continuation
= continuation_ptr
;
571 continuation_ptr
= continuation_ptr
->next
;
572 xfree (saved_continuation
);
576 /* Walk down the cmd_continuation list, and get rid of all the
579 discard_all_intermediate_continuations (void)
581 struct continuation
*continuation_ptr
;
583 while (intermediate_continuation
)
585 continuation_ptr
= intermediate_continuation
;
586 intermediate_continuation
= continuation_ptr
->next
;
587 xfree (continuation_ptr
);
593 /* Print a warning message. The first argument STRING is the warning
594 message, used as an fprintf format string, the second is the
595 va_list of arguments for that string. A warning is unfiltered (not
596 paginated) so that the user does not need to page through each
597 screen full of warnings when there are lots of them. */
600 vwarning (const char *string
, va_list args
)
602 if (deprecated_warning_hook
)
603 (*deprecated_warning_hook
) (string
, args
);
606 target_terminal_ours ();
607 wrap_here (""); /* Force out any buffered output */
608 gdb_flush (gdb_stdout
);
609 if (warning_pre_print
)
610 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
611 vfprintf_unfiltered (gdb_stderr
, string
, args
);
612 fprintf_unfiltered (gdb_stderr
, "\n");
617 /* Print a warning message.
618 The first argument STRING is the warning message, used as a fprintf string,
619 and the remaining args are passed as arguments to it.
620 The primary difference between warnings and errors is that a warning
621 does not force the return to command level. */
624 warning (const char *string
, ...)
627 va_start (args
, string
);
628 vwarning (string
, args
);
632 /* Print an error message and return to command level.
633 The first argument STRING is the error message, used as a fprintf string,
634 and the remaining args are passed as arguments to it. */
637 verror (const char *string
, va_list args
)
639 throw_verror (GENERIC_ERROR
, string
, args
);
643 error (const char *string
, ...)
646 va_start (args
, string
);
647 throw_verror (GENERIC_ERROR
, string
, args
);
651 /* Print an error message and quit.
652 The first argument STRING is the error message, used as a fprintf string,
653 and the remaining args are passed as arguments to it. */
656 vfatal (const char *string
, va_list args
)
658 throw_vfatal (string
, args
);
662 fatal (const char *string
, ...)
665 va_start (args
, string
);
666 throw_vfatal (string
, args
);
671 error_stream (struct ui_file
*stream
)
674 char *message
= ui_file_xstrdup (stream
, &len
);
675 make_cleanup (xfree
, message
);
676 error (("%s"), message
);
679 /* Print a message reporting an internal error/warning. Ask the user
680 if they want to continue, dump core, or just exit. Return
681 something to indicate a quit. */
683 struct internal_problem
686 /* FIXME: cagney/2002-08-15: There should be ``maint set/show''
687 commands available for controlling these variables. */
688 enum auto_boolean should_quit
;
689 enum auto_boolean should_dump_core
;
692 /* Report a problem, internal to GDB, to the user. Once the problem
693 has been reported, and assuming GDB didn't quit, the caller can
694 either allow execution to resume or throw an error. */
696 static void ATTR_FORMAT (printf
, 4, 0)
697 internal_vproblem (struct internal_problem
*problem
,
698 const char *file
, int line
, const char *fmt
, va_list ap
)
705 /* Don't allow infinite error/warning recursion. */
707 static char msg
[] = "Recursive internal problem.\n";
715 fputs_unfiltered (msg
, gdb_stderr
);
716 abort (); /* NOTE: GDB has only three calls to abort(). */
719 write (STDERR_FILENO
, msg
, sizeof (msg
));
724 /* Try to get the message out and at the start of a new line. */
725 target_terminal_ours ();
728 /* Create a string containing the full error/warning message. Need
729 to call query with this full string, as otherwize the reason
730 (error/warning) and question become separated. Format using a
731 style similar to a compiler error message. Include extra detail
732 so that the user knows that they are living on the edge. */
735 msg
= xstrvprintf (fmt
, ap
);
736 reason
= xstrprintf ("\
738 A problem internal to GDB has been detected,\n\
739 further debugging may prove unreliable.", file
, line
, problem
->name
, msg
);
741 make_cleanup (xfree
, reason
);
744 switch (problem
->should_quit
)
746 case AUTO_BOOLEAN_AUTO
:
747 /* Default (yes/batch case) is to quit GDB. When in batch mode
748 this lessens the likelhood of GDB going into an infinate
750 quit_p
= query (_("%s\nQuit this debugging session? "), reason
);
752 case AUTO_BOOLEAN_TRUE
:
755 case AUTO_BOOLEAN_FALSE
:
759 internal_error (__FILE__
, __LINE__
, _("bad switch"));
762 switch (problem
->should_dump_core
)
764 case AUTO_BOOLEAN_AUTO
:
765 /* Default (yes/batch case) is to dump core. This leaves a GDB
766 `dropping' so that it is easier to see that something went
768 dump_core_p
= query (_("%s\nCreate a core file of GDB? "), reason
);
771 case AUTO_BOOLEAN_TRUE
:
774 case AUTO_BOOLEAN_FALSE
:
778 internal_error (__FILE__
, __LINE__
, _("bad switch"));
784 abort (); /* NOTE: GDB has only three calls to abort(). */
792 #ifdef HAVE_WORKING_FORK
794 abort (); /* NOTE: GDB has only three calls to abort(). */
802 static struct internal_problem internal_error_problem
= {
803 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
807 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
809 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
810 deprecated_throw_reason (RETURN_ERROR
);
814 internal_error (const char *file
, int line
, const char *string
, ...)
817 va_start (ap
, string
);
818 internal_verror (file
, line
, string
, ap
);
822 static struct internal_problem internal_warning_problem
= {
823 "internal-warning", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
827 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
829 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
833 internal_warning (const char *file
, int line
, const char *string
, ...)
836 va_start (ap
, string
);
837 internal_vwarning (file
, line
, string
, ap
);
841 /* Print the system error message for errno, and also mention STRING
842 as the file name for which the error was encountered.
843 Then return to command level. */
846 perror_with_name (const char *string
)
851 err
= safe_strerror (errno
);
852 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
853 strcpy (combined
, string
);
854 strcat (combined
, ": ");
855 strcat (combined
, err
);
857 /* I understand setting these is a matter of taste. Still, some people
858 may clear errno but not know about bfd_error. Doing this here is not
860 bfd_set_error (bfd_error_no_error
);
863 error (_("%s."), combined
);
866 /* Print the system error message for ERRCODE, and also mention STRING
867 as the file name for which the error was encountered. */
870 print_sys_errmsg (const char *string
, int errcode
)
875 err
= safe_strerror (errcode
);
876 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
877 strcpy (combined
, string
);
878 strcat (combined
, ": ");
879 strcat (combined
, err
);
881 /* We want anything which was printed on stdout to come out first, before
883 gdb_flush (gdb_stdout
);
884 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
887 /* Control C eventually causes this to be called, at a convenient time. */
893 /* No steenking SIGINT will ever be coming our way when the
894 program is resumed. Don't lie. */
898 /* If there is no terminal switching for this target, then we can't
899 possibly get screwed by the lack of job control. */
900 || current_target
.to_terminal_ours
== NULL
)
903 fatal ("Quit (expect signal SIGINT when the program is resumed)");
908 /* Called when a memory allocation fails, with the number of bytes of
909 memory requested in SIZE. */
916 internal_error (__FILE__
, __LINE__
,
917 _("virtual memory exhausted: can't allocate %ld bytes."),
922 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
926 /* The xmalloc() (libiberty.h) family of memory management routines.
928 These are like the ISO-C malloc() family except that they implement
929 consistent semantics and guard against typical memory management
932 /* NOTE: These are declared using PTR to ensure consistency with
933 "libiberty.h". xfree() is GDB local. */
936 xmalloc (size_t size
)
940 /* See libiberty/xmalloc.c. This function need's to match that's
941 semantics. It never returns NULL. */
945 val
= malloc (size
); /* OK: malloc */
953 xzalloc (size_t size
)
955 return xcalloc (1, size
);
959 xrealloc (PTR ptr
, size_t size
) /* OK: PTR */
963 /* See libiberty/xmalloc.c. This function need's to match that's
964 semantics. It never returns NULL. */
969 val
= realloc (ptr
, size
); /* OK: realloc */
971 val
= malloc (size
); /* OK: malloc */
979 xcalloc (size_t number
, size_t size
)
983 /* See libiberty/xmalloc.c. This function need's to match that's
984 semantics. It never returns NULL. */
985 if (number
== 0 || size
== 0)
991 mem
= calloc (number
, size
); /* OK: xcalloc */
993 nomem (number
* size
);
1002 free (ptr
); /* OK: free */
1006 /* Like asprintf/vasprintf but get an internal_error if the call
1010 xstrprintf (const char *format
, ...)
1014 va_start (args
, format
);
1015 ret
= xstrvprintf (format
, args
);
1021 xasprintf (char **ret
, const char *format
, ...)
1024 va_start (args
, format
);
1025 (*ret
) = xstrvprintf (format
, args
);
1030 xvasprintf (char **ret
, const char *format
, va_list ap
)
1032 (*ret
) = xstrvprintf (format
, ap
);
1036 xstrvprintf (const char *format
, va_list ap
)
1039 int status
= vasprintf (&ret
, format
, ap
);
1040 /* NULL is returned when there was a memory allocation problem, or
1041 any other error (for instance, a bad format string). A negative
1042 status (the printed length) with a non-NULL buffer should never
1043 happen, but just to be sure. */
1044 if (ret
== NULL
|| status
< 0)
1045 internal_error (__FILE__
, __LINE__
, _("vasprintf call failed"));
1050 xsnprintf (char *str
, size_t size
, const char *format
, ...)
1055 va_start (args
, format
);
1056 ret
= vsnprintf (str
, size
, format
, args
);
1057 gdb_assert (ret
< size
);
1063 /* My replacement for the read system call.
1064 Used like `read' but keeps going if `read' returns too soon. */
1067 myread (int desc
, char *addr
, int len
)
1074 val
= read (desc
, addr
, len
);
1078 return orglen
- len
;
1085 /* Make a copy of the string at PTR with SIZE characters
1086 (and add a null character at the end in the copy).
1087 Uses malloc to get the space. Returns the address of the copy. */
1090 savestring (const char *ptr
, size_t size
)
1092 char *p
= (char *) xmalloc (size
+ 1);
1093 memcpy (p
, ptr
, size
);
1099 print_spaces (int n
, struct ui_file
*file
)
1101 fputs_unfiltered (n_spaces (n
), file
);
1104 /* Print a host address. */
1107 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1110 /* We could use the %p conversion specifier to fprintf if we had any
1111 way of knowing whether this host supports it. But the following
1112 should work on the Alpha and on 32 bit machines. */
1114 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1118 /* This function supports the query, nquery, and yquery functions.
1119 Ask user a y-or-n question and return 0 if answer is no, 1 if
1120 answer is yes, or default the answer to the specified default
1121 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1122 default answer, or '\0' for no default.
1123 CTLSTR is the control string and should end in "? ". It should
1124 not say how to answer, because we do that.
1125 ARGS are the arguments passed along with the CTLSTR argument to
1128 static int ATTR_FORMAT (printf
, 1, 0)
1129 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1135 char def_answer
, not_def_answer
;
1136 char *y_string
, *n_string
, *question
;
1138 /* Set up according to which answer is the default. */
1139 if (defchar
== '\0')
1143 not_def_answer
= 'N';
1147 else if (defchar
== 'y')
1151 not_def_answer
= 'N';
1159 not_def_answer
= 'Y';
1164 /* Automatically answer the default value if the user did not want
1169 /* If input isn't coming from the user directly, just say what
1170 question we're asking, and then answer "yes" automatically. This
1171 way, important error messages don't get lost when talking to GDB
1173 if (! input_from_terminal_p ())
1176 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1178 printf_filtered (_("(%s or %s) [answered %c; input not from terminal]\n"),
1179 y_string
, n_string
, def_answer
);
1180 gdb_flush (gdb_stdout
);
1185 /* Automatically answer the default value if input is not from the user
1186 directly, or if the user did not want prompts. */
1187 if (!input_from_terminal_p () || !caution
)
1190 if (deprecated_query_hook
)
1192 return deprecated_query_hook (ctlstr
, args
);
1195 /* Format the question outside of the loop, to avoid reusing args. */
1196 question
= xstrvprintf (ctlstr
, args
);
1200 wrap_here (""); /* Flush any buffered output */
1201 gdb_flush (gdb_stdout
);
1203 if (annotation_level
> 1)
1204 printf_filtered (("\n\032\032pre-query\n"));
1206 fputs_filtered (question
, gdb_stdout
);
1207 printf_filtered (_("(%s or %s) "), y_string
, n_string
);
1209 if (annotation_level
> 1)
1210 printf_filtered (("\n\032\032query\n"));
1213 gdb_flush (gdb_stdout
);
1215 answer
= fgetc (stdin
);
1216 clearerr (stdin
); /* in case of C-d */
1217 if (answer
== EOF
) /* C-d */
1219 printf_filtered ("EOF [assumed %c]\n", def_answer
);
1223 /* Eat rest of input line, to EOF or newline */
1227 ans2
= fgetc (stdin
);
1230 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1234 /* Check answer. For the non-default, the user must specify
1235 the non-default explicitly. */
1236 if (answer
== not_def_answer
)
1238 retval
= !def_value
;
1241 /* Otherwise, if a default was specified, the user may either
1242 specify the required input or have it default by entering
1244 if (answer
== def_answer
1245 || (defchar
!= '\0' &&
1246 (answer
== '\n' || answer
== '\r' || answer
== EOF
)))
1251 /* Invalid entries are not defaulted and require another selection. */
1252 printf_filtered (_("Please answer %s or %s.\n"),
1253 y_string
, n_string
);
1257 if (annotation_level
> 1)
1258 printf_filtered (("\n\032\032post-query\n"));
1263 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1264 answer is yes, or 0 if answer is defaulted.
1265 Takes three args which are given to printf to print the question.
1266 The first, a control string, should end in "? ".
1267 It should not say how to answer, because we do that. */
1270 nquery (const char *ctlstr
, ...)
1274 va_start (args
, ctlstr
);
1275 return defaulted_query (ctlstr
, 'n', args
);
1279 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1280 answer is yes, or 1 if answer is defaulted.
1281 Takes three args which are given to printf to print the question.
1282 The first, a control string, should end in "? ".
1283 It should not say how to answer, because we do that. */
1286 yquery (const char *ctlstr
, ...)
1290 va_start (args
, ctlstr
);
1291 return defaulted_query (ctlstr
, 'y', args
);
1295 /* Ask user a y-or-n question and return 1 iff answer is yes.
1296 Takes three args which are given to printf to print the question.
1297 The first, a control string, should end in "? ".
1298 It should not say how to answer, because we do that. */
1301 query (const char *ctlstr
, ...)
1305 va_start (args
, ctlstr
);
1306 return defaulted_query (ctlstr
, '\0', args
);
1310 /* Print an error message saying that we couldn't make sense of a
1311 \^mumble sequence in a string or character constant. START and END
1312 indicate a substring of some larger string that contains the
1313 erroneous backslash sequence, missing the initial backslash. */
1315 no_control_char_error (const char *start
, const char *end
)
1317 int len
= end
- start
;
1318 char *copy
= alloca (end
- start
+ 1);
1320 memcpy (copy
, start
, len
);
1323 error (_("There is no control character `\\%s' in the `%s' character set."),
1324 copy
, target_charset ());
1327 /* Parse a C escape sequence. STRING_PTR points to a variable
1328 containing a pointer to the string to parse. That pointer
1329 should point to the character after the \. That pointer
1330 is updated past the characters we use. The value of the
1331 escape sequence is returned.
1333 A negative value means the sequence \ newline was seen,
1334 which is supposed to be equivalent to nothing at all.
1336 If \ is followed by a null character, we return a negative
1337 value and leave the string pointer pointing at the null character.
1339 If \ is followed by 000, we return 0 and leave the string pointer
1340 after the zeros. A value of 0 does not mean end of string. */
1343 parse_escape (char **string_ptr
)
1346 int c
= *(*string_ptr
)++;
1347 if (c_parse_backslash (c
, &target_char
))
1359 /* Remember where this escape sequence started, for reporting
1361 char *sequence_start_pos
= *string_ptr
- 1;
1363 c
= *(*string_ptr
)++;
1367 /* XXXCHARSET: What is `delete' in the host character set? */
1370 if (!host_char_to_target (c
, &target_char
))
1371 error (_("There is no character corresponding to `Delete' "
1372 "in the target character set `%s'."), host_charset ());
1377 target_char
= parse_escape (string_ptr
);
1380 if (!host_char_to_target (c
, &target_char
))
1381 no_control_char_error (sequence_start_pos
, *string_ptr
);
1384 /* Now target_char is something like `c', and we want to find
1385 its control-character equivalent. */
1386 if (!target_char_to_control_char (target_char
, &target_char
))
1387 no_control_char_error (sequence_start_pos
, *string_ptr
);
1392 /* XXXCHARSET: we need to use isdigit and value-of-digit
1393 methods of the host character set here. */
1409 if (c
>= '0' && c
<= '7')
1423 if (!host_char_to_target (c
, &target_char
))
1425 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1426 " has no equivalent\n" "in the `%s' character set.", c
, c
,
1432 /* Print the character C on STREAM as part of the contents of a literal
1433 string whose delimiter is QUOTER. Note that this routine should only
1434 be call for printing things which are independent of the language
1435 of the program being debugged. */
1438 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1439 void (*do_fprintf
) (struct ui_file
*, const char *, ...)
1440 ATTRIBUTE_FPTR_PRINTF_2
, struct ui_file
*stream
, int quoter
)
1443 c
&= 0xFF; /* Avoid sign bit follies */
1445 if (c
< 0x20 || /* Low control chars */
1446 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1447 (sevenbit_strings
&& c
>= 0x80))
1448 { /* high order bit set */
1452 do_fputs ("\\n", stream
);
1455 do_fputs ("\\b", stream
);
1458 do_fputs ("\\t", stream
);
1461 do_fputs ("\\f", stream
);
1464 do_fputs ("\\r", stream
);
1467 do_fputs ("\\e", stream
);
1470 do_fputs ("\\a", stream
);
1473 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1479 if (c
== '\\' || c
== quoter
)
1480 do_fputs ("\\", stream
);
1481 do_fprintf (stream
, "%c", c
);
1485 /* Print the character C on STREAM as part of the contents of a
1486 literal string whose delimiter is QUOTER. Note that these routines
1487 should only be call for printing things which are independent of
1488 the language of the program being debugged. */
1491 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1494 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1498 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1501 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1505 fputstrn_filtered (const char *str
, int n
, int quoter
,
1506 struct ui_file
*stream
)
1509 for (i
= 0; i
< n
; i
++)
1510 printchar (str
[i
], fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1514 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1515 struct ui_file
*stream
)
1518 for (i
= 0; i
< n
; i
++)
1519 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1523 /* Number of lines per page or UINT_MAX if paging is disabled. */
1524 static unsigned int lines_per_page
;
1526 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1527 struct cmd_list_element
*c
, const char *value
)
1529 fprintf_filtered (file
, _("\
1530 Number of lines gdb thinks are in a page is %s.\n"),
1534 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1535 static unsigned int chars_per_line
;
1537 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1538 struct cmd_list_element
*c
, const char *value
)
1540 fprintf_filtered (file
, _("\
1541 Number of characters gdb thinks are in a line is %s.\n"),
1545 /* Current count of lines printed on this page, chars on this line. */
1546 static unsigned int lines_printed
, chars_printed
;
1548 /* Buffer and start column of buffered text, for doing smarter word-
1549 wrapping. When someone calls wrap_here(), we start buffering output
1550 that comes through fputs_filtered(). If we see a newline, we just
1551 spit it out and forget about the wrap_here(). If we see another
1552 wrap_here(), we spit it out and remember the newer one. If we see
1553 the end of the line, we spit out a newline, the indent, and then
1554 the buffered output. */
1556 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1557 are waiting to be output (they have already been counted in chars_printed).
1558 When wrap_buffer[0] is null, the buffer is empty. */
1559 static char *wrap_buffer
;
1561 /* Pointer in wrap_buffer to the next character to fill. */
1562 static char *wrap_pointer
;
1564 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1566 static char *wrap_indent
;
1568 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1569 is not in effect. */
1570 static int wrap_column
;
1573 /* Inialize the number of lines per page and chars per line. */
1576 init_page_info (void)
1579 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1584 #if defined(__GO32__)
1585 rows
= ScreenRows ();
1586 cols
= ScreenCols ();
1587 lines_per_page
= rows
;
1588 chars_per_line
= cols
;
1590 /* Make sure Readline has initialized its terminal settings. */
1591 rl_reset_terminal (NULL
);
1593 /* Get the screen size from Readline. */
1594 rl_get_screen_size (&rows
, &cols
);
1595 lines_per_page
= rows
;
1596 chars_per_line
= cols
;
1598 /* Readline should have fetched the termcap entry for us. */
1599 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1601 /* The number of lines per page is not mentioned in the
1602 terminal description. This probably means that paging is
1603 not useful (e.g. emacs shell window), so disable paging. */
1604 lines_per_page
= UINT_MAX
;
1607 /* FIXME: Get rid of this junk. */
1608 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1609 SIGWINCH_HANDLER (SIGWINCH
);
1612 /* If the output is not a terminal, don't paginate it. */
1613 if (!ui_file_isatty (gdb_stdout
))
1614 lines_per_page
= UINT_MAX
;
1622 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1625 set_screen_size (void)
1627 int rows
= lines_per_page
;
1628 int cols
= chars_per_line
;
1636 /* Update Readline's idea of the terminal size. */
1637 rl_set_screen_size (rows
, cols
);
1640 /* Reinitialize WRAP_BUFFER according to the current value of
1646 if (chars_per_line
== 0)
1651 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1652 wrap_buffer
[0] = '\0';
1655 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1656 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1660 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1667 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1672 /* Wait, so the user can read what's on the screen. Prompt the user
1673 to continue by pressing RETURN. */
1676 prompt_for_continue (void)
1679 char cont_prompt
[120];
1681 if (annotation_level
> 1)
1682 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1684 strcpy (cont_prompt
,
1685 "---Type <return> to continue, or q <return> to quit---");
1686 if (annotation_level
> 1)
1687 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1689 /* We must do this *before* we call gdb_readline, else it will eventually
1690 call us -- thinking that we're trying to print beyond the end of the
1692 reinitialize_more_filter ();
1695 /* On a real operating system, the user can quit with SIGINT.
1698 'q' is provided on all systems so users don't have to change habits
1699 from system to system, and because telling them what to do in
1700 the prompt is more user-friendly than expecting them to think of
1702 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1703 whereas control-C to gdb_readline will cause the user to get dumped
1705 ignore
= gdb_readline_wrapper (cont_prompt
);
1707 if (annotation_level
> 1)
1708 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1713 while (*p
== ' ' || *p
== '\t')
1716 async_request_quit (0);
1721 /* Now we have to do this again, so that GDB will know that it doesn't
1722 need to save the ---Type <return>--- line at the top of the screen. */
1723 reinitialize_more_filter ();
1725 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1728 /* Reinitialize filter; ie. tell it to reset to original values. */
1731 reinitialize_more_filter (void)
1737 /* Indicate that if the next sequence of characters overflows the line,
1738 a newline should be inserted here rather than when it hits the end.
1739 If INDENT is non-null, it is a string to be printed to indent the
1740 wrapped part on the next line. INDENT must remain accessible until
1741 the next call to wrap_here() or until a newline is printed through
1744 If the line is already overfull, we immediately print a newline and
1745 the indentation, and disable further wrapping.
1747 If we don't know the width of lines, but we know the page height,
1748 we must not wrap words, but should still keep track of newlines
1749 that were explicitly printed.
1751 INDENT should not contain tabs, as that will mess up the char count
1752 on the next line. FIXME.
1754 This routine is guaranteed to force out any output which has been
1755 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1756 used to force out output from the wrap_buffer. */
1759 wrap_here (char *indent
)
1761 /* This should have been allocated, but be paranoid anyway. */
1763 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
1767 *wrap_pointer
= '\0';
1768 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1770 wrap_pointer
= wrap_buffer
;
1771 wrap_buffer
[0] = '\0';
1772 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1776 else if (chars_printed
>= chars_per_line
)
1778 puts_filtered ("\n");
1780 puts_filtered (indent
);
1785 wrap_column
= chars_printed
;
1789 wrap_indent
= indent
;
1793 /* Print input string to gdb_stdout, filtered, with wrap,
1794 arranging strings in columns of n chars. String can be
1795 right or left justified in the column. Never prints
1796 trailing spaces. String should never be longer than
1797 width. FIXME: this could be useful for the EXAMINE
1798 command, which currently doesn't tabulate very well */
1801 puts_filtered_tabular (char *string
, int width
, int right
)
1807 gdb_assert (chars_per_line
> 0);
1808 if (chars_per_line
== UINT_MAX
)
1810 fputs_filtered (string
, gdb_stdout
);
1811 fputs_filtered ("\n", gdb_stdout
);
1815 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1816 fputs_filtered ("\n", gdb_stdout
);
1818 if (width
>= chars_per_line
)
1819 width
= chars_per_line
- 1;
1821 stringlen
= strlen (string
);
1823 if (chars_printed
> 0)
1824 spaces
= width
- (chars_printed
- 1) % width
- 1;
1826 spaces
+= width
- stringlen
;
1828 spacebuf
= alloca (spaces
+ 1);
1829 spacebuf
[spaces
] = '\0';
1831 spacebuf
[spaces
] = ' ';
1833 fputs_filtered (spacebuf
, gdb_stdout
);
1834 fputs_filtered (string
, gdb_stdout
);
1838 /* Ensure that whatever gets printed next, using the filtered output
1839 commands, starts at the beginning of the line. I.E. if there is
1840 any pending output for the current line, flush it and start a new
1841 line. Otherwise do nothing. */
1846 if (chars_printed
> 0)
1848 puts_filtered ("\n");
1853 /* Like fputs but if FILTER is true, pause after every screenful.
1855 Regardless of FILTER can wrap at points other than the final
1856 character of a line.
1858 Unlike fputs, fputs_maybe_filtered does not return a value.
1859 It is OK for LINEBUFFER to be NULL, in which case just don't print
1862 Note that a longjmp to top level may occur in this routine (only if
1863 FILTER is true) (since prompt_for_continue may do so) so this
1864 routine should not be called when cleanups are not in place. */
1867 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1870 const char *lineptr
;
1872 if (linebuffer
== 0)
1875 /* Don't do any filtering if it is disabled. */
1876 if ((stream
!= gdb_stdout
) || !pagination_enabled
1877 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1879 fputs_unfiltered (linebuffer
, stream
);
1883 /* Go through and output each character. Show line extension
1884 when this is necessary; prompt user for new page when this is
1887 lineptr
= linebuffer
;
1890 /* Possible new page. */
1891 if (filter
&& (lines_printed
>= lines_per_page
- 1))
1892 prompt_for_continue ();
1894 while (*lineptr
&& *lineptr
!= '\n')
1896 /* Print a single line. */
1897 if (*lineptr
== '\t')
1900 *wrap_pointer
++ = '\t';
1902 fputc_unfiltered ('\t', stream
);
1903 /* Shifting right by 3 produces the number of tab stops
1904 we have already passed, and then adding one and
1905 shifting left 3 advances to the next tab stop. */
1906 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1912 *wrap_pointer
++ = *lineptr
;
1914 fputc_unfiltered (*lineptr
, stream
);
1919 if (chars_printed
>= chars_per_line
)
1921 unsigned int save_chars
= chars_printed
;
1925 /* If we aren't actually wrapping, don't output newline --
1926 if chars_per_line is right, we probably just overflowed
1927 anyway; if it's wrong, let us keep going. */
1929 fputc_unfiltered ('\n', stream
);
1931 /* Possible new page. */
1932 if (lines_printed
>= lines_per_page
- 1)
1933 prompt_for_continue ();
1935 /* Now output indentation and wrapped string */
1938 fputs_unfiltered (wrap_indent
, stream
);
1939 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1940 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1941 /* FIXME, this strlen is what prevents wrap_indent from
1942 containing tabs. However, if we recurse to print it
1943 and count its chars, we risk trouble if wrap_indent is
1944 longer than (the user settable) chars_per_line.
1945 Note also that this can set chars_printed > chars_per_line
1946 if we are printing a long string. */
1947 chars_printed
= strlen (wrap_indent
)
1948 + (save_chars
- wrap_column
);
1949 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1950 wrap_buffer
[0] = '\0';
1951 wrap_column
= 0; /* And disable fancy wrap */
1956 if (*lineptr
== '\n')
1959 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
1961 fputc_unfiltered ('\n', stream
);
1968 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1970 fputs_maybe_filtered (linebuffer
, stream
, 1);
1974 putchar_unfiltered (int c
)
1977 ui_file_write (gdb_stdout
, &buf
, 1);
1981 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1982 May return nonlocally. */
1985 putchar_filtered (int c
)
1987 return fputc_filtered (c
, gdb_stdout
);
1991 fputc_unfiltered (int c
, struct ui_file
*stream
)
1994 ui_file_write (stream
, &buf
, 1);
1999 fputc_filtered (int c
, struct ui_file
*stream
)
2005 fputs_filtered (buf
, stream
);
2009 /* puts_debug is like fputs_unfiltered, except it prints special
2010 characters in printable fashion. */
2013 puts_debug (char *prefix
, char *string
, char *suffix
)
2017 /* Print prefix and suffix after each line. */
2018 static int new_line
= 1;
2019 static int return_p
= 0;
2020 static char *prev_prefix
= "";
2021 static char *prev_suffix
= "";
2023 if (*string
== '\n')
2026 /* If the prefix is changing, print the previous suffix, a new line,
2027 and the new prefix. */
2028 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2030 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2031 fputs_unfiltered ("\n", gdb_stdlog
);
2032 fputs_unfiltered (prefix
, gdb_stdlog
);
2035 /* Print prefix if we printed a newline during the previous call. */
2039 fputs_unfiltered (prefix
, gdb_stdlog
);
2042 prev_prefix
= prefix
;
2043 prev_suffix
= suffix
;
2045 /* Output characters in a printable format. */
2046 while ((ch
= *string
++) != '\0')
2052 fputc_unfiltered (ch
, gdb_stdlog
);
2055 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2059 fputs_unfiltered ("\\\\", gdb_stdlog
);
2062 fputs_unfiltered ("\\b", gdb_stdlog
);
2065 fputs_unfiltered ("\\f", gdb_stdlog
);
2069 fputs_unfiltered ("\\n", gdb_stdlog
);
2072 fputs_unfiltered ("\\r", gdb_stdlog
);
2075 fputs_unfiltered ("\\t", gdb_stdlog
);
2078 fputs_unfiltered ("\\v", gdb_stdlog
);
2082 return_p
= ch
== '\r';
2085 /* Print suffix if we printed a newline. */
2088 fputs_unfiltered (suffix
, gdb_stdlog
);
2089 fputs_unfiltered ("\n", gdb_stdlog
);
2094 /* Print a variable number of ARGS using format FORMAT. If this
2095 information is going to put the amount written (since the last call
2096 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2097 call prompt_for_continue to get the users permision to continue.
2099 Unlike fprintf, this function does not return a value.
2101 We implement three variants, vfprintf (takes a vararg list and stream),
2102 fprintf (takes a stream to write on), and printf (the usual).
2104 Note also that a longjmp to top level may occur in this routine
2105 (since prompt_for_continue may do so) so this routine should not be
2106 called when cleanups are not in place. */
2109 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2110 va_list args
, int filter
)
2113 struct cleanup
*old_cleanups
;
2115 linebuffer
= xstrvprintf (format
, args
);
2116 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2117 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2118 do_cleanups (old_cleanups
);
2123 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2125 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2129 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2132 struct cleanup
*old_cleanups
;
2134 linebuffer
= xstrvprintf (format
, args
);
2135 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2136 fputs_unfiltered (linebuffer
, stream
);
2137 do_cleanups (old_cleanups
);
2141 vprintf_filtered (const char *format
, va_list args
)
2143 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2147 vprintf_unfiltered (const char *format
, va_list args
)
2149 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2153 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2156 va_start (args
, format
);
2157 vfprintf_filtered (stream
, format
, args
);
2162 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2165 va_start (args
, format
);
2166 vfprintf_unfiltered (stream
, format
, args
);
2170 /* Like fprintf_filtered, but prints its result indented.
2171 Called as fprintfi_filtered (spaces, stream, format, ...); */
2174 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2178 va_start (args
, format
);
2179 print_spaces_filtered (spaces
, stream
);
2181 vfprintf_filtered (stream
, format
, args
);
2187 printf_filtered (const char *format
, ...)
2190 va_start (args
, format
);
2191 vfprintf_filtered (gdb_stdout
, format
, args
);
2197 printf_unfiltered (const char *format
, ...)
2200 va_start (args
, format
);
2201 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2205 /* Like printf_filtered, but prints it's result indented.
2206 Called as printfi_filtered (spaces, format, ...); */
2209 printfi_filtered (int spaces
, const char *format
, ...)
2212 va_start (args
, format
);
2213 print_spaces_filtered (spaces
, gdb_stdout
);
2214 vfprintf_filtered (gdb_stdout
, format
, args
);
2218 /* Easy -- but watch out!
2220 This routine is *not* a replacement for puts()! puts() appends a newline.
2221 This one doesn't, and had better not! */
2224 puts_filtered (const char *string
)
2226 fputs_filtered (string
, gdb_stdout
);
2230 puts_unfiltered (const char *string
)
2232 fputs_unfiltered (string
, gdb_stdout
);
2235 /* Return a pointer to N spaces and a null. The pointer is good
2236 until the next call to here. */
2241 static char *spaces
= 0;
2242 static int max_spaces
= -1;
2248 spaces
= (char *) xmalloc (n
+ 1);
2249 for (t
= spaces
+ n
; t
!= spaces
;)
2255 return spaces
+ max_spaces
- n
;
2258 /* Print N spaces. */
2260 print_spaces_filtered (int n
, struct ui_file
*stream
)
2262 fputs_filtered (n_spaces (n
), stream
);
2265 /* C++/ObjC demangler stuff. */
2267 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2268 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2269 If the name is not mangled, or the language for the name is unknown, or
2270 demangling is off, the name is printed in its "raw" form. */
2273 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2274 enum language lang
, int arg_mode
)
2280 /* If user wants to see raw output, no problem. */
2283 fputs_filtered (name
, stream
);
2287 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2288 fputs_filtered (demangled
? demangled
: name
, stream
);
2289 if (demangled
!= NULL
)
2297 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2298 differences in whitespace. Returns 0 if they match, non-zero if they
2299 don't (slightly different than strcmp()'s range of return values).
2301 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2302 This "feature" is useful when searching for matching C++ function names
2303 (such as if the user types 'break FOO', where FOO is a mangled C++
2307 strcmp_iw (const char *string1
, const char *string2
)
2309 while ((*string1
!= '\0') && (*string2
!= '\0'))
2311 while (isspace (*string1
))
2315 while (isspace (*string2
))
2319 if (*string1
!= *string2
)
2323 if (*string1
!= '\0')
2329 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2332 /* This is like strcmp except that it ignores whitespace and treats
2333 '(' as the first non-NULL character in terms of ordering. Like
2334 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2335 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2336 according to that ordering.
2338 If a list is sorted according to this function and if you want to
2339 find names in the list that match some fixed NAME according to
2340 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2341 where this function would put NAME.
2343 Here are some examples of why using strcmp to sort is a bad idea:
2347 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2348 we try to do a search for "foo<char*>", strcmp will locate this
2349 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2350 will start looking at strings beginning with "goo", and will never
2351 see the correct match of "foo<char *>".
2353 Parenthesis example:
2355 In practice, this is less like to be an issue, but I'll give it a
2356 shot. Let's assume that '$' is a legitimate character to occur in
2357 symbols. (Which may well even be the case on some systems.) Then
2358 say that the partial symbol table contains "foo$" and "foo(int)".
2359 strcmp will put them in this order, since '$' < '('. Now, if the
2360 user searches for "foo", then strcmp will sort "foo" before "foo$".
2361 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2362 "foo") is false, so it won't proceed to the actual match of
2363 "foo(int)" with "foo". */
2366 strcmp_iw_ordered (const char *string1
, const char *string2
)
2368 while ((*string1
!= '\0') && (*string2
!= '\0'))
2370 while (isspace (*string1
))
2374 while (isspace (*string2
))
2378 if (*string1
!= *string2
)
2382 if (*string1
!= '\0')
2391 /* Characters are non-equal unless they're both '\0'; we want to
2392 make sure we get the comparison right according to our
2393 comparison in the cases where one of them is '\0' or '('. */
2395 if (*string2
== '\0')
2400 if (*string2
== '\0')
2405 if (*string2
== '(')
2408 return *string1
- *string2
;
2412 /* A simple comparison function with opposite semantics to strcmp. */
2415 streq (const char *lhs
, const char *rhs
)
2417 return !strcmp (lhs
, rhs
);
2423 ** Answer whether string_to_compare is a full or partial match to
2424 ** template_string. The partial match must be in sequence starting
2428 subset_compare (char *string_to_compare
, char *template_string
)
2431 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2432 && strlen (string_to_compare
) <= strlen (template_string
))
2435 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2442 pagination_on_command (char *arg
, int from_tty
)
2444 pagination_enabled
= 1;
2448 pagination_off_command (char *arg
, int from_tty
)
2450 pagination_enabled
= 0;
2455 initialize_utils (void)
2457 struct cmd_list_element
*c
;
2459 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2460 Set number of characters gdb thinks are in a line."), _("\
2461 Show number of characters gdb thinks are in a line."), NULL
,
2463 show_chars_per_line
,
2464 &setlist
, &showlist
);
2466 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2467 Set number of lines gdb thinks are in a page."), _("\
2468 Show number of lines gdb thinks are in a page."), NULL
,
2470 show_lines_per_page
,
2471 &setlist
, &showlist
);
2475 add_setshow_boolean_cmd ("demangle", class_support
, &demangle
, _("\
2476 Set demangling of encoded C++/ObjC names when displaying symbols."), _("\
2477 Show demangling of encoded C++/ObjC names when displaying symbols."), NULL
,
2480 &setprintlist
, &showprintlist
);
2482 add_setshow_boolean_cmd ("pagination", class_support
,
2483 &pagination_enabled
, _("\
2484 Set state of pagination."), _("\
2485 Show state of pagination."), NULL
,
2487 show_pagination_enabled
,
2488 &setlist
, &showlist
);
2492 add_com ("am", class_support
, pagination_on_command
,
2493 _("Enable pagination"));
2494 add_com ("sm", class_support
, pagination_off_command
,
2495 _("Disable pagination"));
2498 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2499 &sevenbit_strings
, _("\
2500 Set printing of 8-bit characters in strings as \\nnn."), _("\
2501 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2503 show_sevenbit_strings
,
2504 &setprintlist
, &showprintlist
);
2506 add_setshow_boolean_cmd ("asm-demangle", class_support
, &asm_demangle
, _("\
2507 Set demangling of C++/ObjC names in disassembly listings."), _("\
2508 Show demangling of C++/ObjC names in disassembly listings."), NULL
,
2511 &setprintlist
, &showprintlist
);
2514 /* Machine specific function to handle SIGWINCH signal. */
2516 #ifdef SIGWINCH_HANDLER_BODY
2517 SIGWINCH_HANDLER_BODY
2519 /* print routines to handle variable size regs, etc. */
2520 /* temporary storage using circular buffer */
2526 static char buf
[NUMCELLS
][CELLSIZE
];
2527 static int cell
= 0;
2528 if (++cell
>= NUMCELLS
)
2536 return (gdbarch_addr_bit (current_gdbarch
) / 8 * 2);
2540 paddr (CORE_ADDR addr
)
2542 return phex (addr
, gdbarch_addr_bit (current_gdbarch
) / 8);
2546 paddr_nz (CORE_ADDR addr
)
2548 return phex_nz (addr
, gdbarch_addr_bit (current_gdbarch
) / 8);
2552 paddress (CORE_ADDR addr
)
2554 /* Truncate address to the size of a target address, avoiding shifts
2555 larger or equal than the width of a CORE_ADDR. The local
2556 variable ADDR_BIT stops the compiler reporting a shift overflow
2557 when it won't occur. */
2558 /* NOTE: This assumes that the significant address information is
2559 kept in the least significant bits of ADDR - the upper bits were
2560 either zero or sign extended. Should gdbarch_address_to_pointer or
2561 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2563 int addr_bit
= gdbarch_addr_bit (current_gdbarch
);
2565 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2566 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2567 return hex_string (addr
);
2571 decimal2str (char *sign
, ULONGEST addr
, int width
)
2573 /* Steal code from valprint.c:print_decimal(). Should this worry
2574 about the real size of addr as the above does? */
2575 unsigned long temp
[3];
2576 char *str
= get_cell ();
2581 temp
[i
] = addr
% (1000 * 1000 * 1000);
2582 addr
/= (1000 * 1000 * 1000);
2586 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2595 xsnprintf (str
, CELLSIZE
, "%s%0*lu", sign
, width
, temp
[0]);
2598 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu", sign
, width
,
2602 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu%09lu", sign
, width
,
2603 temp
[2], temp
[1], temp
[0]);
2606 internal_error (__FILE__
, __LINE__
,
2607 _("failed internal consistency check"));
2614 octal2str (ULONGEST addr
, int width
)
2616 unsigned long temp
[3];
2617 char *str
= get_cell ();
2622 temp
[i
] = addr
% (0100000 * 0100000);
2623 addr
/= (0100000 * 0100000);
2627 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2637 xsnprintf (str
, CELLSIZE
, "%*o", width
, 0);
2639 xsnprintf (str
, CELLSIZE
, "0%0*lo", width
, temp
[0]);
2642 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo", width
, temp
[1], temp
[0]);
2645 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo%010lo", width
,
2646 temp
[2], temp
[1], temp
[0]);
2649 internal_error (__FILE__
, __LINE__
,
2650 _("failed internal consistency check"));
2657 paddr_u (CORE_ADDR addr
)
2659 return decimal2str ("", addr
, 0);
2663 paddr_d (LONGEST addr
)
2666 return decimal2str ("-", -addr
, 0);
2668 return decimal2str ("", addr
, 0);
2671 /* Eliminate warning from compiler on 32-bit systems. */
2672 static int thirty_two
= 32;
2675 phex (ULONGEST l
, int sizeof_l
)
2683 xsnprintf (str
, CELLSIZE
, "%08lx%08lx",
2684 (unsigned long) (l
>> thirty_two
),
2685 (unsigned long) (l
& 0xffffffff));
2689 xsnprintf (str
, CELLSIZE
, "%08lx", (unsigned long) l
);
2693 xsnprintf (str
, CELLSIZE
, "%04x", (unsigned short) (l
& 0xffff));
2696 str
= phex (l
, sizeof (l
));
2704 phex_nz (ULONGEST l
, int sizeof_l
)
2712 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2715 xsnprintf (str
, CELLSIZE
, "%lx",
2716 (unsigned long) (l
& 0xffffffff));
2718 xsnprintf (str
, CELLSIZE
, "%lx%08lx", high
,
2719 (unsigned long) (l
& 0xffffffff));
2724 xsnprintf (str
, CELLSIZE
, "%lx", (unsigned long) l
);
2728 xsnprintf (str
, CELLSIZE
, "%x", (unsigned short) (l
& 0xffff));
2731 str
= phex_nz (l
, sizeof (l
));
2738 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
2739 in a static string. Returns a pointer to this string. */
2741 hex_string (LONGEST num
)
2743 char *result
= get_cell ();
2744 xsnprintf (result
, CELLSIZE
, "0x%s", phex_nz (num
, sizeof (num
)));
2748 /* Converts a LONGEST number to a C-format hexadecimal literal and
2749 stores it in a static string. Returns a pointer to this string
2750 that is valid until the next call. The number is padded on the
2751 left with 0s to at least WIDTH characters. */
2753 hex_string_custom (LONGEST num
, int width
)
2755 char *result
= get_cell ();
2756 char *result_end
= result
+ CELLSIZE
- 1;
2757 const char *hex
= phex_nz (num
, sizeof (num
));
2758 int hex_len
= strlen (hex
);
2760 if (hex_len
> width
)
2762 if (width
+ 2 >= CELLSIZE
)
2763 internal_error (__FILE__
, __LINE__
,
2764 _("hex_string_custom: insufficient space to store result"));
2766 strcpy (result_end
- width
- 2, "0x");
2767 memset (result_end
- width
, '0', width
);
2768 strcpy (result_end
- hex_len
, hex
);
2769 return result_end
- width
- 2;
2772 /* Convert VAL to a numeral in the given radix. For
2773 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
2774 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
2775 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
2776 * to use C format in all cases. If it is false, then 'x'
2777 * and 'o' formats do not include a prefix (0x or leading 0). */
2780 int_string (LONGEST val
, int radix
, int is_signed
, int width
,
2789 result
= hex_string (val
);
2791 result
= hex_string_custom (val
, width
);
2798 if (is_signed
&& val
< 0)
2799 return decimal2str ("-", -val
, width
);
2801 return decimal2str ("", val
, width
);
2805 char *result
= octal2str (val
, width
);
2806 if (use_c_format
|| val
== 0)
2812 internal_error (__FILE__
, __LINE__
,
2813 _("failed internal consistency check"));
2817 /* Convert a CORE_ADDR into a string. */
2819 core_addr_to_string (const CORE_ADDR addr
)
2821 char *str
= get_cell ();
2823 strcat (str
, phex (addr
, sizeof (addr
)));
2828 core_addr_to_string_nz (const CORE_ADDR addr
)
2830 char *str
= get_cell ();
2832 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2836 /* Convert a string back into a CORE_ADDR. */
2838 string_to_core_addr (const char *my_string
)
2841 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2843 /* Assume that it is in hex. */
2845 for (i
= 2; my_string
[i
] != '\0'; i
++)
2847 if (isdigit (my_string
[i
]))
2848 addr
= (my_string
[i
] - '0') + (addr
* 16);
2849 else if (isxdigit (my_string
[i
]))
2850 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2852 error (_("invalid hex \"%s\""), my_string
);
2857 /* Assume that it is in decimal. */
2859 for (i
= 0; my_string
[i
] != '\0'; i
++)
2861 if (isdigit (my_string
[i
]))
2862 addr
= (my_string
[i
] - '0') + (addr
* 10);
2864 error (_("invalid decimal \"%s\""), my_string
);
2871 gdb_realpath (const char *filename
)
2873 /* Method 1: The system has a compile time upper bound on a filename
2874 path. Use that and realpath() to canonicalize the name. This is
2875 the most common case. Note that, if there isn't a compile time
2876 upper bound, you want to avoid realpath() at all costs. */
2877 #if defined(HAVE_REALPATH)
2879 # if defined (PATH_MAX)
2881 # define USE_REALPATH
2882 # elif defined (MAXPATHLEN)
2883 char buf
[MAXPATHLEN
];
2884 # define USE_REALPATH
2886 # if defined (USE_REALPATH)
2887 const char *rp
= realpath (filename
, buf
);
2890 return xstrdup (rp
);
2893 #endif /* HAVE_REALPATH */
2895 /* Method 2: The host system (i.e., GNU) has the function
2896 canonicalize_file_name() which malloc's a chunk of memory and
2897 returns that, use that. */
2898 #if defined(HAVE_CANONICALIZE_FILE_NAME)
2900 char *rp
= canonicalize_file_name (filename
);
2902 return xstrdup (filename
);
2908 /* FIXME: cagney/2002-11-13:
2910 Method 2a: Use realpath() with a NULL buffer. Some systems, due
2911 to the problems described in in method 3, have modified their
2912 realpath() implementation so that it will allocate a buffer when
2913 NULL is passed in. Before this can be used, though, some sort of
2914 configure time test would need to be added. Otherwize the code
2915 will likely core dump. */
2917 /* Method 3: Now we're getting desperate! The system doesn't have a
2918 compile time buffer size and no alternative function. Query the
2919 OS, using pathconf(), for the buffer limit. Care is needed
2920 though, some systems do not limit PATH_MAX (return -1 for
2921 pathconf()) making it impossible to pass a correctly sized buffer
2922 to realpath() (it could always overflow). On those systems, we
2924 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2926 /* Find out the max path size. */
2927 long path_max
= pathconf ("/", _PC_PATH_MAX
);
2930 /* PATH_MAX is bounded. */
2931 char *buf
= alloca (path_max
);
2932 char *rp
= realpath (filename
, buf
);
2933 return xstrdup (rp
? rp
: filename
);
2938 /* This system is a lost cause, just dup the buffer. */
2939 return xstrdup (filename
);
2942 /* Return a copy of FILENAME, with its directory prefix canonicalized
2946 xfullpath (const char *filename
)
2948 const char *base_name
= lbasename (filename
);
2953 /* Extract the basename of filename, and return immediately
2954 a copy of filename if it does not contain any directory prefix. */
2955 if (base_name
== filename
)
2956 return xstrdup (filename
);
2958 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
2959 /* Allocate enough space to store the dir_name + plus one extra
2960 character sometimes needed under Windows (see below), and
2961 then the closing \000 character */
2962 strncpy (dir_name
, filename
, base_name
- filename
);
2963 dir_name
[base_name
- filename
] = '\000';
2965 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2966 /* We need to be careful when filename is of the form 'd:foo', which
2967 is equivalent of d:./foo, which is totally different from d:/foo. */
2968 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
2971 dir_name
[3] = '\000';
2975 /* Canonicalize the directory prefix, and build the resulting
2976 filename. If the dirname realpath already contains an ending
2977 directory separator, avoid doubling it. */
2978 real_path
= gdb_realpath (dir_name
);
2979 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
2980 result
= concat (real_path
, base_name
, (char *)NULL
);
2982 result
= concat (real_path
, SLASH_STRING
, base_name
, (char *)NULL
);
2989 /* This is the 32-bit CRC function used by the GNU separate debug
2990 facility. An executable may contain a section named
2991 .gnu_debuglink, which holds the name of a separate executable file
2992 containing its debug info, and a checksum of that file's contents,
2993 computed using this function. */
2995 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
2997 static const unsigned long crc32_table
[256] = {
2998 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
2999 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3000 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3001 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3002 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3003 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3004 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3005 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3006 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3007 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3008 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3009 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3010 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3011 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3012 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3013 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3014 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3015 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3016 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3017 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3018 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3019 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3020 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3021 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3022 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3023 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3024 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3025 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3026 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3027 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3028 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3029 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3030 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3031 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3032 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3033 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3034 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3035 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3036 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3037 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3038 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3039 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3040 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3041 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3042 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3043 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3044 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3045 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3046 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3047 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3048 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3053 crc
= ~crc
& 0xffffffff;
3054 for (end
= buf
+ len
; buf
< end
; ++buf
)
3055 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
3056 return ~crc
& 0xffffffff;;
3060 align_up (ULONGEST v
, int n
)
3062 /* Check that N is really a power of two. */
3063 gdb_assert (n
&& (n
& (n
-1)) == 0);
3064 return (v
+ n
- 1) & -n
;
3068 align_down (ULONGEST v
, int n
)
3070 /* Check that N is really a power of two. */
3071 gdb_assert (n
&& (n
& (n
-1)) == 0);
3075 /* Allocation function for the libiberty hash table which uses an
3076 obstack. The obstack is passed as DATA. */
3079 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
3081 unsigned int total
= size
* count
;
3082 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
3083 memset (ptr
, 0, total
);
3087 /* Trivial deallocation function for the libiberty splay tree and hash
3088 table - don't deallocate anything. Rely on later deletion of the
3089 obstack. DATA will be the obstack, although it is not needed
3093 dummy_obstack_deallocate (void *object
, void *data
)
3098 /* The bit offset of the highest byte in a ULONGEST, for overflow
3101 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3103 /* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3104 where 2 <= BASE <= 36. */
3107 is_digit_in_base (unsigned char digit
, int base
)
3109 if (!isalnum (digit
))
3112 return (isdigit (digit
) && digit
< base
+ '0');
3114 return (isdigit (digit
) || tolower (digit
) < base
- 10 + 'a');
3118 digit_to_int (unsigned char c
)
3123 return tolower (c
) - 'a' + 10;
3126 /* As for strtoul, but for ULONGEST results. */
3129 strtoulst (const char *num
, const char **trailer
, int base
)
3131 unsigned int high_part
;
3136 /* Skip leading whitespace. */
3137 while (isspace (num
[i
]))
3140 /* Handle prefixes. */
3143 else if (num
[i
] == '-')
3149 if (base
== 0 || base
== 16)
3151 if (num
[i
] == '0' && (num
[i
+ 1] == 'x' || num
[i
+ 1] == 'X'))
3159 if (base
== 0 && num
[i
] == '0')
3165 if (base
< 2 || base
> 36)
3171 result
= high_part
= 0;
3172 for (; is_digit_in_base (num
[i
], base
); i
+= 1)
3174 result
= result
* base
+ digit_to_int (num
[i
]);
3175 high_part
= high_part
* base
+ (unsigned int) (result
>> HIGH_BYTE_POSN
);
3176 result
&= ((ULONGEST
) 1 << HIGH_BYTE_POSN
) - 1;
3177 if (high_part
> 0xff)
3180 result
= ~ (ULONGEST
) 0;
3187 if (trailer
!= NULL
)
3190 result
= result
+ ((ULONGEST
) high_part
<< HIGH_BYTE_POSN
);
3197 /* Simple, portable version of dirname that does not modify its
3201 ldirname (const char *filename
)
3203 const char *base
= lbasename (filename
);
3206 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
3209 if (base
== filename
)
3212 dirname
= xmalloc (base
- filename
+ 2);
3213 memcpy (dirname
, filename
, base
- filename
);
3215 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3216 create "d:./bar" later instead of the (different) "d:/bar". */
3217 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
3218 && !IS_DIR_SEPARATOR (filename
[0]))
3219 dirname
[base
++ - filename
] = '.';
3221 dirname
[base
- filename
] = '\0';