1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_assert.h"
25 #include "gdb_string.h"
26 #include "event-top.h"
27 #include "exceptions.h"
30 #include "tui/tui.h" /* For tui_get_command_dimension. */
37 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
48 #include "expression.h"
52 #include "filenames.h"
54 #include "gdb_obstack.h"
58 #include "inferior.h" /* for signed_pointer_to_address */
60 #include <sys/param.h> /* For MAXPATHLEN */
62 #include "gdb_curses.h"
64 #include "readline/readline.h"
70 extern PTR
malloc (); /* OK: PTR */
72 #if !HAVE_DECL_REALLOC
73 extern PTR
realloc (); /* OK: PTR */
79 /* readline defines this. */
82 void (*deprecated_error_begin_hook
) (void);
84 /* Prototypes for local functions */
86 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
87 va_list, int) ATTR_FORMAT (printf
, 2, 0);
89 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
91 static void do_my_cleanups (struct cleanup
**, struct cleanup
*);
93 static void prompt_for_continue (void);
95 static void set_screen_size (void);
96 static void set_width (void);
98 /* A flag indicating whether to timestamp debugging messages. */
100 static int debug_timestamp
= 0;
102 /* Chain of cleanup actions established with make_cleanup,
103 to be executed if an error happens. */
105 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
106 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
108 /* Pointer to what is left to do for an execution command after the
109 target stops. Used only in asynchronous mode, by targets that
110 support async execution. The finish and until commands use it. So
111 does the target extended-remote command. */
112 struct continuation
*cmd_continuation
;
113 struct continuation
*intermediate_continuation
;
115 /* Nonzero if we have job control. */
119 /* Nonzero means a quit has been requested. */
123 /* Nonzero means quit immediately if Control-C is typed now, rather
124 than waiting until QUIT is executed. Be careful in setting this;
125 code which executes with immediate_quit set has to be very careful
126 about being able to deal with being interrupted at any time. It is
127 almost always better to use QUIT; the only exception I can think of
128 is being able to quit out of a system call (using EINTR loses if
129 the SIGINT happens between the previous QUIT and the system call).
130 To immediately quit in the case in which a SIGINT happens between
131 the previous QUIT and setting immediate_quit (desirable anytime we
132 expect to block), call QUIT after setting immediate_quit. */
136 /* Nonzero means that encoded C++/ObjC names should be printed out in their
137 C++/ObjC form rather than raw. */
141 show_demangle (struct ui_file
*file
, int from_tty
,
142 struct cmd_list_element
*c
, const char *value
)
144 fprintf_filtered (file
, _("\
145 Demangling of encoded C++/ObjC names when displaying symbols is %s.\n"),
149 /* Nonzero means that encoded C++/ObjC names should be printed out in their
150 C++/ObjC form even in assembler language displays. If this is set, but
151 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
153 int asm_demangle
= 0;
155 show_asm_demangle (struct ui_file
*file
, int from_tty
,
156 struct cmd_list_element
*c
, const char *value
)
158 fprintf_filtered (file
, _("\
159 Demangling of C++/ObjC names in disassembly listings is %s.\n"),
163 /* Nonzero means that strings with character values >0x7F should be printed
164 as octal escapes. Zero means just print the value (e.g. it's an
165 international character, and the terminal or window can cope.) */
167 int sevenbit_strings
= 0;
169 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
170 struct cmd_list_element
*c
, const char *value
)
172 fprintf_filtered (file
, _("\
173 Printing of 8-bit characters in strings as \\nnn is %s.\n"),
177 /* String to be printed before error messages, if any. */
179 char *error_pre_print
;
181 /* String to be printed before quit messages, if any. */
183 char *quit_pre_print
;
185 /* String to be printed before warning messages, if any. */
187 char *warning_pre_print
= "\nwarning: ";
189 int pagination_enabled
= 1;
191 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
192 struct cmd_list_element
*c
, const char *value
)
194 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
199 /* Add a new cleanup to the cleanup_chain,
200 and return the previous chain pointer
201 to be passed later to do_cleanups or discard_cleanups.
202 Args are FUNCTION to clean up with, and ARG to pass to it. */
205 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
207 return make_my_cleanup (&cleanup_chain
, function
, arg
);
211 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
213 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
217 do_freeargv (void *arg
)
219 freeargv ((char **) arg
);
223 make_cleanup_freeargv (char **arg
)
225 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
229 do_bfd_close_cleanup (void *arg
)
235 make_cleanup_bfd_close (bfd
*abfd
)
237 return make_cleanup (do_bfd_close_cleanup
, abfd
);
241 do_close_cleanup (void *arg
)
249 make_cleanup_close (int fd
)
251 int *saved_fd
= xmalloc (sizeof (fd
));
253 return make_cleanup (do_close_cleanup
, saved_fd
);
257 do_ui_file_delete (void *arg
)
259 ui_file_delete (arg
);
263 make_cleanup_ui_file_delete (struct ui_file
*arg
)
265 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
269 do_free_section_addr_info (void *arg
)
271 free_section_addr_info (arg
);
275 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
277 return make_my_cleanup (&cleanup_chain
, do_free_section_addr_info
, addrs
);
282 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
286 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
287 struct cleanup
*old_chain
= *pmy_chain
;
289 new->next
= *pmy_chain
;
290 new->function
= function
;
297 /* Discard cleanups and do the actions they describe
298 until we get back to the point OLD_CHAIN in the cleanup_chain. */
301 do_cleanups (struct cleanup
*old_chain
)
303 do_my_cleanups (&cleanup_chain
, old_chain
);
307 do_final_cleanups (struct cleanup
*old_chain
)
309 do_my_cleanups (&final_cleanup_chain
, old_chain
);
313 do_my_cleanups (struct cleanup
**pmy_chain
,
314 struct cleanup
*old_chain
)
317 while ((ptr
= *pmy_chain
) != old_chain
)
319 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
320 (*ptr
->function
) (ptr
->arg
);
325 /* Discard cleanups, not doing the actions they describe,
326 until we get back to the point OLD_CHAIN in the cleanup_chain. */
329 discard_cleanups (struct cleanup
*old_chain
)
331 discard_my_cleanups (&cleanup_chain
, old_chain
);
335 discard_final_cleanups (struct cleanup
*old_chain
)
337 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
341 discard_my_cleanups (struct cleanup
**pmy_chain
,
342 struct cleanup
*old_chain
)
345 while ((ptr
= *pmy_chain
) != old_chain
)
347 *pmy_chain
= ptr
->next
;
352 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
356 return save_my_cleanups (&cleanup_chain
);
360 save_final_cleanups (void)
362 return save_my_cleanups (&final_cleanup_chain
);
366 save_my_cleanups (struct cleanup
**pmy_chain
)
368 struct cleanup
*old_chain
= *pmy_chain
;
374 /* Restore the cleanup chain from a previously saved chain. */
376 restore_cleanups (struct cleanup
*chain
)
378 restore_my_cleanups (&cleanup_chain
, chain
);
382 restore_final_cleanups (struct cleanup
*chain
)
384 restore_my_cleanups (&final_cleanup_chain
, chain
);
388 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
393 /* This function is useful for cleanups.
397 old_chain = make_cleanup (free_current_contents, &foo);
399 to arrange to free the object thus allocated. */
402 free_current_contents (void *ptr
)
404 void **location
= ptr
;
405 if (location
== NULL
)
406 internal_error (__FILE__
, __LINE__
,
407 _("free_current_contents: NULL pointer"));
408 if (*location
!= NULL
)
415 /* Provide a known function that does nothing, to use as a base for
416 for a possibly long chain of cleanups. This is useful where we
417 use the cleanup chain for handling normal cleanups as well as dealing
418 with cleanups that need to be done as a result of a call to error().
419 In such cases, we may not be certain where the first cleanup is, unless
420 we have a do-nothing one to always use as the base. */
423 null_cleanup (void *arg
)
427 /* Add a continuation to the continuation list, the global list
428 cmd_continuation. The new continuation will be added at the front.*/
430 add_continuation (void (*continuation_hook
) (struct continuation_arg
*, int),
431 struct continuation_arg
*arg_list
)
433 struct continuation
*continuation_ptr
;
436 (struct continuation
*) xmalloc (sizeof (struct continuation
));
437 continuation_ptr
->continuation_hook
= continuation_hook
;
438 continuation_ptr
->arg_list
= arg_list
;
439 continuation_ptr
->next
= cmd_continuation
;
440 cmd_continuation
= continuation_ptr
;
443 /* Walk down the cmd_continuation list, and execute all the
444 continuations. There is a problem though. In some cases new
445 continuations may be added while we are in the middle of this
446 loop. If this happens they will be added in the front, and done
447 before we have a chance of exhausting those that were already
448 there. We need to then save the beginning of the list in a pointer
449 and do the continuations from there on, instead of using the
450 global beginning of list as our iteration pointer. */
452 do_all_continuations (int error
)
454 struct continuation
*continuation_ptr
;
455 struct continuation
*saved_continuation
;
457 /* Copy the list header into another pointer, and set the global
458 list header to null, so that the global list can change as a side
459 effect of invoking the continuations and the processing of
460 the preexisting continuations will not be affected. */
461 continuation_ptr
= cmd_continuation
;
462 cmd_continuation
= NULL
;
464 /* Work now on the list we have set aside. */
465 while (continuation_ptr
)
467 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
, error
);
468 saved_continuation
= continuation_ptr
;
469 continuation_ptr
= continuation_ptr
->next
;
470 xfree (saved_continuation
);
474 /* Walk down the cmd_continuation list, and get rid of all the
477 discard_all_continuations (void)
479 struct continuation
*continuation_ptr
;
481 while (cmd_continuation
)
483 continuation_ptr
= cmd_continuation
;
484 cmd_continuation
= continuation_ptr
->next
;
485 xfree (continuation_ptr
);
489 /* Add a continuation to the continuation list, the global list
490 intermediate_continuation. The new continuation will be added at
493 add_intermediate_continuation (void (*continuation_hook
)
494 (struct continuation_arg
*, int),
495 struct continuation_arg
*arg_list
)
497 struct continuation
*continuation_ptr
;
500 (struct continuation
*) xmalloc (sizeof (struct continuation
));
501 continuation_ptr
->continuation_hook
= continuation_hook
;
502 continuation_ptr
->arg_list
= arg_list
;
503 continuation_ptr
->next
= intermediate_continuation
;
504 intermediate_continuation
= continuation_ptr
;
507 /* Walk down the cmd_continuation list, and execute all the
508 continuations. There is a problem though. In some cases new
509 continuations may be added while we are in the middle of this
510 loop. If this happens they will be added in the front, and done
511 before we have a chance of exhausting those that were already
512 there. We need to then save the beginning of the list in a pointer
513 and do the continuations from there on, instead of using the
514 global beginning of list as our iteration pointer.*/
516 do_all_intermediate_continuations (int error
)
518 struct continuation
*continuation_ptr
;
519 struct continuation
*saved_continuation
;
521 /* Copy the list header into another pointer, and set the global
522 list header to null, so that the global list can change as a side
523 effect of invoking the continuations and the processing of
524 the preexisting continuations will not be affected. */
525 continuation_ptr
= intermediate_continuation
;
526 intermediate_continuation
= NULL
;
528 /* Work now on the list we have set aside. */
529 while (continuation_ptr
)
531 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
, error
);
532 saved_continuation
= continuation_ptr
;
533 continuation_ptr
= continuation_ptr
->next
;
534 xfree (saved_continuation
);
538 /* Walk down the cmd_continuation list, and get rid of all the
541 discard_all_intermediate_continuations (void)
543 struct continuation
*continuation_ptr
;
545 while (intermediate_continuation
)
547 continuation_ptr
= intermediate_continuation
;
548 intermediate_continuation
= continuation_ptr
->next
;
549 xfree (continuation_ptr
);
555 /* Print a warning message. The first argument STRING is the warning
556 message, used as an fprintf format string, the second is the
557 va_list of arguments for that string. A warning is unfiltered (not
558 paginated) so that the user does not need to page through each
559 screen full of warnings when there are lots of them. */
562 vwarning (const char *string
, va_list args
)
564 if (deprecated_warning_hook
)
565 (*deprecated_warning_hook
) (string
, args
);
568 target_terminal_ours ();
569 wrap_here (""); /* Force out any buffered output */
570 gdb_flush (gdb_stdout
);
571 if (warning_pre_print
)
572 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
573 vfprintf_unfiltered (gdb_stderr
, string
, args
);
574 fprintf_unfiltered (gdb_stderr
, "\n");
579 /* Print a warning message.
580 The first argument STRING is the warning message, used as a fprintf string,
581 and the remaining args are passed as arguments to it.
582 The primary difference between warnings and errors is that a warning
583 does not force the return to command level. */
586 warning (const char *string
, ...)
589 va_start (args
, string
);
590 vwarning (string
, args
);
594 /* Print an error message and return to command level.
595 The first argument STRING is the error message, used as a fprintf string,
596 and the remaining args are passed as arguments to it. */
599 verror (const char *string
, va_list args
)
601 throw_verror (GENERIC_ERROR
, string
, args
);
605 error (const char *string
, ...)
608 va_start (args
, string
);
609 throw_verror (GENERIC_ERROR
, string
, args
);
613 /* Print an error message and quit.
614 The first argument STRING is the error message, used as a fprintf string,
615 and the remaining args are passed as arguments to it. */
618 vfatal (const char *string
, va_list args
)
620 throw_vfatal (string
, args
);
624 fatal (const char *string
, ...)
627 va_start (args
, string
);
628 throw_vfatal (string
, args
);
633 error_stream (struct ui_file
*stream
)
636 char *message
= ui_file_xstrdup (stream
, &len
);
637 make_cleanup (xfree
, message
);
638 error (("%s"), message
);
641 /* Print a message reporting an internal error/warning. Ask the user
642 if they want to continue, dump core, or just exit. Return
643 something to indicate a quit. */
645 struct internal_problem
648 /* FIXME: cagney/2002-08-15: There should be ``maint set/show''
649 commands available for controlling these variables. */
650 enum auto_boolean should_quit
;
651 enum auto_boolean should_dump_core
;
654 /* Report a problem, internal to GDB, to the user. Once the problem
655 has been reported, and assuming GDB didn't quit, the caller can
656 either allow execution to resume or throw an error. */
658 static void ATTR_FORMAT (printf
, 4, 0)
659 internal_vproblem (struct internal_problem
*problem
,
660 const char *file
, int line
, const char *fmt
, va_list ap
)
667 /* Don't allow infinite error/warning recursion. */
669 static char msg
[] = "Recursive internal problem.\n";
677 fputs_unfiltered (msg
, gdb_stderr
);
678 abort (); /* NOTE: GDB has only three calls to abort(). */
681 write (STDERR_FILENO
, msg
, sizeof (msg
));
686 /* Try to get the message out and at the start of a new line. */
687 target_terminal_ours ();
690 /* Create a string containing the full error/warning message. Need
691 to call query with this full string, as otherwize the reason
692 (error/warning) and question become separated. Format using a
693 style similar to a compiler error message. Include extra detail
694 so that the user knows that they are living on the edge. */
697 msg
= xstrvprintf (fmt
, ap
);
698 reason
= xstrprintf ("\
700 A problem internal to GDB has been detected,\n\
701 further debugging may prove unreliable.", file
, line
, problem
->name
, msg
);
703 make_cleanup (xfree
, reason
);
706 switch (problem
->should_quit
)
708 case AUTO_BOOLEAN_AUTO
:
709 /* Default (yes/batch case) is to quit GDB. When in batch mode
710 this lessens the likelhood of GDB going into an infinate
712 quit_p
= query (_("%s\nQuit this debugging session? "), reason
);
714 case AUTO_BOOLEAN_TRUE
:
717 case AUTO_BOOLEAN_FALSE
:
721 internal_error (__FILE__
, __LINE__
, _("bad switch"));
724 switch (problem
->should_dump_core
)
726 case AUTO_BOOLEAN_AUTO
:
727 /* Default (yes/batch case) is to dump core. This leaves a GDB
728 `dropping' so that it is easier to see that something went
730 dump_core_p
= query (_("%s\nCreate a core file of GDB? "), reason
);
733 case AUTO_BOOLEAN_TRUE
:
736 case AUTO_BOOLEAN_FALSE
:
740 internal_error (__FILE__
, __LINE__
, _("bad switch"));
746 abort (); /* NOTE: GDB has only three calls to abort(). */
754 #ifdef HAVE_WORKING_FORK
756 abort (); /* NOTE: GDB has only three calls to abort(). */
764 static struct internal_problem internal_error_problem
= {
765 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
769 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
771 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
772 deprecated_throw_reason (RETURN_ERROR
);
776 internal_error (const char *file
, int line
, const char *string
, ...)
779 va_start (ap
, string
);
780 internal_verror (file
, line
, string
, ap
);
784 static struct internal_problem internal_warning_problem
= {
785 "internal-warning", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
789 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
791 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
795 internal_warning (const char *file
, int line
, const char *string
, ...)
798 va_start (ap
, string
);
799 internal_vwarning (file
, line
, string
, ap
);
803 /* Print the system error message for errno, and also mention STRING
804 as the file name for which the error was encountered.
805 Then return to command level. */
808 perror_with_name (const char *string
)
813 err
= safe_strerror (errno
);
814 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
815 strcpy (combined
, string
);
816 strcat (combined
, ": ");
817 strcat (combined
, err
);
819 /* I understand setting these is a matter of taste. Still, some people
820 may clear errno but not know about bfd_error. Doing this here is not
822 bfd_set_error (bfd_error_no_error
);
825 error (_("%s."), combined
);
828 /* Print the system error message for ERRCODE, and also mention STRING
829 as the file name for which the error was encountered. */
832 print_sys_errmsg (const char *string
, int errcode
)
837 err
= safe_strerror (errcode
);
838 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
839 strcpy (combined
, string
);
840 strcat (combined
, ": ");
841 strcat (combined
, err
);
843 /* We want anything which was printed on stdout to come out first, before
845 gdb_flush (gdb_stdout
);
846 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
849 /* Control C eventually causes this to be called, at a convenient time. */
855 /* No steenking SIGINT will ever be coming our way when the
856 program is resumed. Don't lie. */
860 /* If there is no terminal switching for this target, then we can't
861 possibly get screwed by the lack of job control. */
862 || current_target
.to_terminal_ours
== NULL
)
865 fatal ("Quit (expect signal SIGINT when the program is resumed)");
870 /* Called when a memory allocation fails, with the number of bytes of
871 memory requested in SIZE. */
878 internal_error (__FILE__
, __LINE__
,
879 _("virtual memory exhausted: can't allocate %ld bytes."),
884 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
888 /* The xmalloc() (libiberty.h) family of memory management routines.
890 These are like the ISO-C malloc() family except that they implement
891 consistent semantics and guard against typical memory management
894 /* NOTE: These are declared using PTR to ensure consistency with
895 "libiberty.h". xfree() is GDB local. */
898 xmalloc (size_t size
)
902 /* See libiberty/xmalloc.c. This function need's to match that's
903 semantics. It never returns NULL. */
907 val
= malloc (size
); /* OK: malloc */
915 xzalloc (size_t size
)
917 return xcalloc (1, size
);
921 xrealloc (PTR ptr
, size_t size
) /* OK: PTR */
925 /* See libiberty/xmalloc.c. This function need's to match that's
926 semantics. It never returns NULL. */
931 val
= realloc (ptr
, size
); /* OK: realloc */
933 val
= malloc (size
); /* OK: malloc */
941 xcalloc (size_t number
, size_t size
)
945 /* See libiberty/xmalloc.c. This function need's to match that's
946 semantics. It never returns NULL. */
947 if (number
== 0 || size
== 0)
953 mem
= calloc (number
, size
); /* OK: xcalloc */
955 nomem (number
* size
);
964 free (ptr
); /* OK: free */
968 /* Like asprintf/vasprintf but get an internal_error if the call
972 xstrprintf (const char *format
, ...)
976 va_start (args
, format
);
977 ret
= xstrvprintf (format
, args
);
983 xasprintf (char **ret
, const char *format
, ...)
986 va_start (args
, format
);
987 (*ret
) = xstrvprintf (format
, args
);
992 xvasprintf (char **ret
, const char *format
, va_list ap
)
994 (*ret
) = xstrvprintf (format
, ap
);
998 xstrvprintf (const char *format
, va_list ap
)
1001 int status
= vasprintf (&ret
, format
, ap
);
1002 /* NULL is returned when there was a memory allocation problem, or
1003 any other error (for instance, a bad format string). A negative
1004 status (the printed length) with a non-NULL buffer should never
1005 happen, but just to be sure. */
1006 if (ret
== NULL
|| status
< 0)
1007 internal_error (__FILE__
, __LINE__
, _("vasprintf call failed"));
1012 xsnprintf (char *str
, size_t size
, const char *format
, ...)
1017 va_start (args
, format
);
1018 ret
= vsnprintf (str
, size
, format
, args
);
1019 gdb_assert (ret
< size
);
1025 /* My replacement for the read system call.
1026 Used like `read' but keeps going if `read' returns too soon. */
1029 myread (int desc
, char *addr
, int len
)
1036 val
= read (desc
, addr
, len
);
1040 return orglen
- len
;
1047 /* Make a copy of the string at PTR with SIZE characters
1048 (and add a null character at the end in the copy).
1049 Uses malloc to get the space. Returns the address of the copy. */
1052 savestring (const char *ptr
, size_t size
)
1054 char *p
= (char *) xmalloc (size
+ 1);
1055 memcpy (p
, ptr
, size
);
1061 print_spaces (int n
, struct ui_file
*file
)
1063 fputs_unfiltered (n_spaces (n
), file
);
1066 /* Print a host address. */
1069 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1072 /* We could use the %p conversion specifier to fprintf if we had any
1073 way of knowing whether this host supports it. But the following
1074 should work on the Alpha and on 32 bit machines. */
1076 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1080 /* This function supports the query, nquery, and yquery functions.
1081 Ask user a y-or-n question and return 0 if answer is no, 1 if
1082 answer is yes, or default the answer to the specified default
1083 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1084 default answer, or '\0' for no default.
1085 CTLSTR is the control string and should end in "? ". It should
1086 not say how to answer, because we do that.
1087 ARGS are the arguments passed along with the CTLSTR argument to
1090 static int ATTR_FORMAT (printf
, 1, 0)
1091 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1097 char def_answer
, not_def_answer
;
1098 char *y_string
, *n_string
, *question
;
1100 /* Set up according to which answer is the default. */
1101 if (defchar
== '\0')
1105 not_def_answer
= 'N';
1109 else if (defchar
== 'y')
1113 not_def_answer
= 'N';
1121 not_def_answer
= 'Y';
1126 /* Automatically answer the default value if the user did not want
1131 /* If input isn't coming from the user directly, just say what
1132 question we're asking, and then answer "yes" automatically. This
1133 way, important error messages don't get lost when talking to GDB
1135 if (! input_from_terminal_p ())
1138 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1140 printf_filtered (_("(%s or %s) [answered %c; input not from terminal]\n"),
1141 y_string
, n_string
, def_answer
);
1142 gdb_flush (gdb_stdout
);
1147 /* Automatically answer the default value if input is not from the user
1148 directly, or if the user did not want prompts. */
1149 if (!input_from_terminal_p () || !caution
)
1152 if (deprecated_query_hook
)
1154 return deprecated_query_hook (ctlstr
, args
);
1157 /* Format the question outside of the loop, to avoid reusing args. */
1158 question
= xstrvprintf (ctlstr
, args
);
1162 wrap_here (""); /* Flush any buffered output */
1163 gdb_flush (gdb_stdout
);
1165 if (annotation_level
> 1)
1166 printf_filtered (("\n\032\032pre-query\n"));
1168 fputs_filtered (question
, gdb_stdout
);
1169 printf_filtered (_("(%s or %s) "), y_string
, n_string
);
1171 if (annotation_level
> 1)
1172 printf_filtered (("\n\032\032query\n"));
1175 gdb_flush (gdb_stdout
);
1177 answer
= fgetc (stdin
);
1178 clearerr (stdin
); /* in case of C-d */
1179 if (answer
== EOF
) /* C-d */
1181 printf_filtered ("EOF [assumed %c]\n", def_answer
);
1185 /* Eat rest of input line, to EOF or newline */
1189 ans2
= fgetc (stdin
);
1192 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1196 /* Check answer. For the non-default, the user must specify
1197 the non-default explicitly. */
1198 if (answer
== not_def_answer
)
1200 retval
= !def_value
;
1203 /* Otherwise, if a default was specified, the user may either
1204 specify the required input or have it default by entering
1206 if (answer
== def_answer
1207 || (defchar
!= '\0' &&
1208 (answer
== '\n' || answer
== '\r' || answer
== EOF
)))
1213 /* Invalid entries are not defaulted and require another selection. */
1214 printf_filtered (_("Please answer %s or %s.\n"),
1215 y_string
, n_string
);
1219 if (annotation_level
> 1)
1220 printf_filtered (("\n\032\032post-query\n"));
1225 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1226 answer is yes, or 0 if answer is defaulted.
1227 Takes three args which are given to printf to print the question.
1228 The first, a control string, should end in "? ".
1229 It should not say how to answer, because we do that. */
1232 nquery (const char *ctlstr
, ...)
1236 va_start (args
, ctlstr
);
1237 return defaulted_query (ctlstr
, 'n', args
);
1241 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1242 answer is yes, or 1 if answer is defaulted.
1243 Takes three args which are given to printf to print the question.
1244 The first, a control string, should end in "? ".
1245 It should not say how to answer, because we do that. */
1248 yquery (const char *ctlstr
, ...)
1252 va_start (args
, ctlstr
);
1253 return defaulted_query (ctlstr
, 'y', args
);
1257 /* Ask user a y-or-n question and return 1 iff answer is yes.
1258 Takes three args which are given to printf to print the question.
1259 The first, a control string, should end in "? ".
1260 It should not say how to answer, because we do that. */
1263 query (const char *ctlstr
, ...)
1267 va_start (args
, ctlstr
);
1268 return defaulted_query (ctlstr
, '\0', args
);
1272 /* Print an error message saying that we couldn't make sense of a
1273 \^mumble sequence in a string or character constant. START and END
1274 indicate a substring of some larger string that contains the
1275 erroneous backslash sequence, missing the initial backslash. */
1277 no_control_char_error (const char *start
, const char *end
)
1279 int len
= end
- start
;
1280 char *copy
= alloca (end
- start
+ 1);
1282 memcpy (copy
, start
, len
);
1285 error (_("There is no control character `\\%s' in the `%s' character set."),
1286 copy
, target_charset ());
1289 /* Parse a C escape sequence. STRING_PTR points to a variable
1290 containing a pointer to the string to parse. That pointer
1291 should point to the character after the \. That pointer
1292 is updated past the characters we use. The value of the
1293 escape sequence is returned.
1295 A negative value means the sequence \ newline was seen,
1296 which is supposed to be equivalent to nothing at all.
1298 If \ is followed by a null character, we return a negative
1299 value and leave the string pointer pointing at the null character.
1301 If \ is followed by 000, we return 0 and leave the string pointer
1302 after the zeros. A value of 0 does not mean end of string. */
1305 parse_escape (char **string_ptr
)
1308 int c
= *(*string_ptr
)++;
1309 if (c_parse_backslash (c
, &target_char
))
1321 /* Remember where this escape sequence started, for reporting
1323 char *sequence_start_pos
= *string_ptr
- 1;
1325 c
= *(*string_ptr
)++;
1329 /* XXXCHARSET: What is `delete' in the host character set? */
1332 if (!host_char_to_target (c
, &target_char
))
1333 error (_("There is no character corresponding to `Delete' "
1334 "in the target character set `%s'."), host_charset ());
1339 target_char
= parse_escape (string_ptr
);
1342 if (!host_char_to_target (c
, &target_char
))
1343 no_control_char_error (sequence_start_pos
, *string_ptr
);
1346 /* Now target_char is something like `c', and we want to find
1347 its control-character equivalent. */
1348 if (!target_char_to_control_char (target_char
, &target_char
))
1349 no_control_char_error (sequence_start_pos
, *string_ptr
);
1354 /* XXXCHARSET: we need to use isdigit and value-of-digit
1355 methods of the host character set here. */
1371 if (c
>= '0' && c
<= '7')
1385 if (!host_char_to_target (c
, &target_char
))
1387 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1388 " has no equivalent\n" "in the `%s' character set.", c
, c
,
1394 /* Print the character C on STREAM as part of the contents of a literal
1395 string whose delimiter is QUOTER. Note that this routine should only
1396 be call for printing things which are independent of the language
1397 of the program being debugged. */
1400 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1401 void (*do_fprintf
) (struct ui_file
*, const char *, ...)
1402 ATTRIBUTE_FPTR_PRINTF_2
, struct ui_file
*stream
, int quoter
)
1405 c
&= 0xFF; /* Avoid sign bit follies */
1407 if (c
< 0x20 || /* Low control chars */
1408 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1409 (sevenbit_strings
&& c
>= 0x80))
1410 { /* high order bit set */
1414 do_fputs ("\\n", stream
);
1417 do_fputs ("\\b", stream
);
1420 do_fputs ("\\t", stream
);
1423 do_fputs ("\\f", stream
);
1426 do_fputs ("\\r", stream
);
1429 do_fputs ("\\e", stream
);
1432 do_fputs ("\\a", stream
);
1435 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1441 if (c
== '\\' || c
== quoter
)
1442 do_fputs ("\\", stream
);
1443 do_fprintf (stream
, "%c", c
);
1447 /* Print the character C on STREAM as part of the contents of a
1448 literal string whose delimiter is QUOTER. Note that these routines
1449 should only be call for printing things which are independent of
1450 the language of the program being debugged. */
1453 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1456 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1460 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1463 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1467 fputstrn_filtered (const char *str
, int n
, int quoter
,
1468 struct ui_file
*stream
)
1471 for (i
= 0; i
< n
; i
++)
1472 printchar (str
[i
], fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1476 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1477 struct ui_file
*stream
)
1480 for (i
= 0; i
< n
; i
++)
1481 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1485 /* Number of lines per page or UINT_MAX if paging is disabled. */
1486 static unsigned int lines_per_page
;
1488 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1489 struct cmd_list_element
*c
, const char *value
)
1491 fprintf_filtered (file
, _("\
1492 Number of lines gdb thinks are in a page is %s.\n"),
1496 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1497 static unsigned int chars_per_line
;
1499 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1500 struct cmd_list_element
*c
, const char *value
)
1502 fprintf_filtered (file
, _("\
1503 Number of characters gdb thinks are in a line is %s.\n"),
1507 /* Current count of lines printed on this page, chars on this line. */
1508 static unsigned int lines_printed
, chars_printed
;
1510 /* Buffer and start column of buffered text, for doing smarter word-
1511 wrapping. When someone calls wrap_here(), we start buffering output
1512 that comes through fputs_filtered(). If we see a newline, we just
1513 spit it out and forget about the wrap_here(). If we see another
1514 wrap_here(), we spit it out and remember the newer one. If we see
1515 the end of the line, we spit out a newline, the indent, and then
1516 the buffered output. */
1518 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1519 are waiting to be output (they have already been counted in chars_printed).
1520 When wrap_buffer[0] is null, the buffer is empty. */
1521 static char *wrap_buffer
;
1523 /* Pointer in wrap_buffer to the next character to fill. */
1524 static char *wrap_pointer
;
1526 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1528 static char *wrap_indent
;
1530 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1531 is not in effect. */
1532 static int wrap_column
;
1535 /* Inialize the number of lines per page and chars per line. */
1538 init_page_info (void)
1541 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1546 #if defined(__GO32__)
1547 rows
= ScreenRows ();
1548 cols
= ScreenCols ();
1549 lines_per_page
= rows
;
1550 chars_per_line
= cols
;
1552 /* Make sure Readline has initialized its terminal settings. */
1553 rl_reset_terminal (NULL
);
1555 /* Get the screen size from Readline. */
1556 rl_get_screen_size (&rows
, &cols
);
1557 lines_per_page
= rows
;
1558 chars_per_line
= cols
;
1560 /* Readline should have fetched the termcap entry for us. */
1561 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1563 /* The number of lines per page is not mentioned in the
1564 terminal description. This probably means that paging is
1565 not useful (e.g. emacs shell window), so disable paging. */
1566 lines_per_page
= UINT_MAX
;
1569 /* FIXME: Get rid of this junk. */
1570 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1571 SIGWINCH_HANDLER (SIGWINCH
);
1574 /* If the output is not a terminal, don't paginate it. */
1575 if (!ui_file_isatty (gdb_stdout
))
1576 lines_per_page
= UINT_MAX
;
1584 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1587 set_screen_size (void)
1589 int rows
= lines_per_page
;
1590 int cols
= chars_per_line
;
1598 /* Update Readline's idea of the terminal size. */
1599 rl_set_screen_size (rows
, cols
);
1602 /* Reinitialize WRAP_BUFFER according to the current value of
1608 if (chars_per_line
== 0)
1613 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1614 wrap_buffer
[0] = '\0';
1617 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1618 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1622 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1629 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1634 /* Wait, so the user can read what's on the screen. Prompt the user
1635 to continue by pressing RETURN. */
1638 prompt_for_continue (void)
1641 char cont_prompt
[120];
1643 if (annotation_level
> 1)
1644 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1646 strcpy (cont_prompt
,
1647 "---Type <return> to continue, or q <return> to quit---");
1648 if (annotation_level
> 1)
1649 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1651 /* We must do this *before* we call gdb_readline, else it will eventually
1652 call us -- thinking that we're trying to print beyond the end of the
1654 reinitialize_more_filter ();
1657 /* On a real operating system, the user can quit with SIGINT.
1660 'q' is provided on all systems so users don't have to change habits
1661 from system to system, and because telling them what to do in
1662 the prompt is more user-friendly than expecting them to think of
1664 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1665 whereas control-C to gdb_readline will cause the user to get dumped
1667 ignore
= gdb_readline_wrapper (cont_prompt
);
1669 if (annotation_level
> 1)
1670 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1675 while (*p
== ' ' || *p
== '\t')
1678 async_request_quit (0);
1683 /* Now we have to do this again, so that GDB will know that it doesn't
1684 need to save the ---Type <return>--- line at the top of the screen. */
1685 reinitialize_more_filter ();
1687 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1690 /* Reinitialize filter; ie. tell it to reset to original values. */
1693 reinitialize_more_filter (void)
1699 /* Indicate that if the next sequence of characters overflows the line,
1700 a newline should be inserted here rather than when it hits the end.
1701 If INDENT is non-null, it is a string to be printed to indent the
1702 wrapped part on the next line. INDENT must remain accessible until
1703 the next call to wrap_here() or until a newline is printed through
1706 If the line is already overfull, we immediately print a newline and
1707 the indentation, and disable further wrapping.
1709 If we don't know the width of lines, but we know the page height,
1710 we must not wrap words, but should still keep track of newlines
1711 that were explicitly printed.
1713 INDENT should not contain tabs, as that will mess up the char count
1714 on the next line. FIXME.
1716 This routine is guaranteed to force out any output which has been
1717 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1718 used to force out output from the wrap_buffer. */
1721 wrap_here (char *indent
)
1723 /* This should have been allocated, but be paranoid anyway. */
1725 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
1729 *wrap_pointer
= '\0';
1730 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1732 wrap_pointer
= wrap_buffer
;
1733 wrap_buffer
[0] = '\0';
1734 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1738 else if (chars_printed
>= chars_per_line
)
1740 puts_filtered ("\n");
1742 puts_filtered (indent
);
1747 wrap_column
= chars_printed
;
1751 wrap_indent
= indent
;
1755 /* Print input string to gdb_stdout, filtered, with wrap,
1756 arranging strings in columns of n chars. String can be
1757 right or left justified in the column. Never prints
1758 trailing spaces. String should never be longer than
1759 width. FIXME: this could be useful for the EXAMINE
1760 command, which currently doesn't tabulate very well */
1763 puts_filtered_tabular (char *string
, int width
, int right
)
1769 gdb_assert (chars_per_line
> 0);
1770 if (chars_per_line
== UINT_MAX
)
1772 fputs_filtered (string
, gdb_stdout
);
1773 fputs_filtered ("\n", gdb_stdout
);
1777 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1778 fputs_filtered ("\n", gdb_stdout
);
1780 if (width
>= chars_per_line
)
1781 width
= chars_per_line
- 1;
1783 stringlen
= strlen (string
);
1785 if (chars_printed
> 0)
1786 spaces
= width
- (chars_printed
- 1) % width
- 1;
1788 spaces
+= width
- stringlen
;
1790 spacebuf
= alloca (spaces
+ 1);
1791 spacebuf
[spaces
] = '\0';
1793 spacebuf
[spaces
] = ' ';
1795 fputs_filtered (spacebuf
, gdb_stdout
);
1796 fputs_filtered (string
, gdb_stdout
);
1800 /* Ensure that whatever gets printed next, using the filtered output
1801 commands, starts at the beginning of the line. I.E. if there is
1802 any pending output for the current line, flush it and start a new
1803 line. Otherwise do nothing. */
1808 if (chars_printed
> 0)
1810 puts_filtered ("\n");
1815 /* Like fputs but if FILTER is true, pause after every screenful.
1817 Regardless of FILTER can wrap at points other than the final
1818 character of a line.
1820 Unlike fputs, fputs_maybe_filtered does not return a value.
1821 It is OK for LINEBUFFER to be NULL, in which case just don't print
1824 Note that a longjmp to top level may occur in this routine (only if
1825 FILTER is true) (since prompt_for_continue may do so) so this
1826 routine should not be called when cleanups are not in place. */
1829 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1832 const char *lineptr
;
1834 if (linebuffer
== 0)
1837 /* Don't do any filtering if it is disabled. */
1838 if ((stream
!= gdb_stdout
) || !pagination_enabled
1839 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1841 fputs_unfiltered (linebuffer
, stream
);
1845 /* Go through and output each character. Show line extension
1846 when this is necessary; prompt user for new page when this is
1849 lineptr
= linebuffer
;
1852 /* Possible new page. */
1853 if (filter
&& (lines_printed
>= lines_per_page
- 1))
1854 prompt_for_continue ();
1856 while (*lineptr
&& *lineptr
!= '\n')
1858 /* Print a single line. */
1859 if (*lineptr
== '\t')
1862 *wrap_pointer
++ = '\t';
1864 fputc_unfiltered ('\t', stream
);
1865 /* Shifting right by 3 produces the number of tab stops
1866 we have already passed, and then adding one and
1867 shifting left 3 advances to the next tab stop. */
1868 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1874 *wrap_pointer
++ = *lineptr
;
1876 fputc_unfiltered (*lineptr
, stream
);
1881 if (chars_printed
>= chars_per_line
)
1883 unsigned int save_chars
= chars_printed
;
1887 /* If we aren't actually wrapping, don't output newline --
1888 if chars_per_line is right, we probably just overflowed
1889 anyway; if it's wrong, let us keep going. */
1891 fputc_unfiltered ('\n', stream
);
1893 /* Possible new page. */
1894 if (lines_printed
>= lines_per_page
- 1)
1895 prompt_for_continue ();
1897 /* Now output indentation and wrapped string */
1900 fputs_unfiltered (wrap_indent
, stream
);
1901 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1902 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1903 /* FIXME, this strlen is what prevents wrap_indent from
1904 containing tabs. However, if we recurse to print it
1905 and count its chars, we risk trouble if wrap_indent is
1906 longer than (the user settable) chars_per_line.
1907 Note also that this can set chars_printed > chars_per_line
1908 if we are printing a long string. */
1909 chars_printed
= strlen (wrap_indent
)
1910 + (save_chars
- wrap_column
);
1911 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1912 wrap_buffer
[0] = '\0';
1913 wrap_column
= 0; /* And disable fancy wrap */
1918 if (*lineptr
== '\n')
1921 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
1923 fputc_unfiltered ('\n', stream
);
1930 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1932 fputs_maybe_filtered (linebuffer
, stream
, 1);
1936 putchar_unfiltered (int c
)
1939 ui_file_write (gdb_stdout
, &buf
, 1);
1943 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1944 May return nonlocally. */
1947 putchar_filtered (int c
)
1949 return fputc_filtered (c
, gdb_stdout
);
1953 fputc_unfiltered (int c
, struct ui_file
*stream
)
1956 ui_file_write (stream
, &buf
, 1);
1961 fputc_filtered (int c
, struct ui_file
*stream
)
1967 fputs_filtered (buf
, stream
);
1971 /* puts_debug is like fputs_unfiltered, except it prints special
1972 characters in printable fashion. */
1975 puts_debug (char *prefix
, char *string
, char *suffix
)
1979 /* Print prefix and suffix after each line. */
1980 static int new_line
= 1;
1981 static int return_p
= 0;
1982 static char *prev_prefix
= "";
1983 static char *prev_suffix
= "";
1985 if (*string
== '\n')
1988 /* If the prefix is changing, print the previous suffix, a new line,
1989 and the new prefix. */
1990 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
1992 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
1993 fputs_unfiltered ("\n", gdb_stdlog
);
1994 fputs_unfiltered (prefix
, gdb_stdlog
);
1997 /* Print prefix if we printed a newline during the previous call. */
2001 fputs_unfiltered (prefix
, gdb_stdlog
);
2004 prev_prefix
= prefix
;
2005 prev_suffix
= suffix
;
2007 /* Output characters in a printable format. */
2008 while ((ch
= *string
++) != '\0')
2014 fputc_unfiltered (ch
, gdb_stdlog
);
2017 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2021 fputs_unfiltered ("\\\\", gdb_stdlog
);
2024 fputs_unfiltered ("\\b", gdb_stdlog
);
2027 fputs_unfiltered ("\\f", gdb_stdlog
);
2031 fputs_unfiltered ("\\n", gdb_stdlog
);
2034 fputs_unfiltered ("\\r", gdb_stdlog
);
2037 fputs_unfiltered ("\\t", gdb_stdlog
);
2040 fputs_unfiltered ("\\v", gdb_stdlog
);
2044 return_p
= ch
== '\r';
2047 /* Print suffix if we printed a newline. */
2050 fputs_unfiltered (suffix
, gdb_stdlog
);
2051 fputs_unfiltered ("\n", gdb_stdlog
);
2056 /* Print a variable number of ARGS using format FORMAT. If this
2057 information is going to put the amount written (since the last call
2058 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2059 call prompt_for_continue to get the users permision to continue.
2061 Unlike fprintf, this function does not return a value.
2063 We implement three variants, vfprintf (takes a vararg list and stream),
2064 fprintf (takes a stream to write on), and printf (the usual).
2066 Note also that a longjmp to top level may occur in this routine
2067 (since prompt_for_continue may do so) so this routine should not be
2068 called when cleanups are not in place. */
2071 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2072 va_list args
, int filter
)
2075 struct cleanup
*old_cleanups
;
2077 linebuffer
= xstrvprintf (format
, args
);
2078 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2079 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2080 do_cleanups (old_cleanups
);
2085 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2087 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2091 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2094 struct cleanup
*old_cleanups
;
2096 linebuffer
= xstrvprintf (format
, args
);
2097 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2098 if (debug_timestamp
&& stream
== gdb_stdlog
)
2103 gettimeofday (&tm
, NULL
);
2104 timestamp
= xstrprintf ("%ld:%ld ", (long) tm
.tv_sec
, (long) tm
.tv_usec
);
2105 make_cleanup (xfree
, timestamp
);
2106 fputs_unfiltered (timestamp
, stream
);
2108 fputs_unfiltered (linebuffer
, stream
);
2109 do_cleanups (old_cleanups
);
2113 vprintf_filtered (const char *format
, va_list args
)
2115 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2119 vprintf_unfiltered (const char *format
, va_list args
)
2121 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2125 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2128 va_start (args
, format
);
2129 vfprintf_filtered (stream
, format
, args
);
2134 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2137 va_start (args
, format
);
2138 vfprintf_unfiltered (stream
, format
, args
);
2142 /* Like fprintf_filtered, but prints its result indented.
2143 Called as fprintfi_filtered (spaces, stream, format, ...); */
2146 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2150 va_start (args
, format
);
2151 print_spaces_filtered (spaces
, stream
);
2153 vfprintf_filtered (stream
, format
, args
);
2159 printf_filtered (const char *format
, ...)
2162 va_start (args
, format
);
2163 vfprintf_filtered (gdb_stdout
, format
, args
);
2169 printf_unfiltered (const char *format
, ...)
2172 va_start (args
, format
);
2173 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2177 /* Like printf_filtered, but prints it's result indented.
2178 Called as printfi_filtered (spaces, format, ...); */
2181 printfi_filtered (int spaces
, const char *format
, ...)
2184 va_start (args
, format
);
2185 print_spaces_filtered (spaces
, gdb_stdout
);
2186 vfprintf_filtered (gdb_stdout
, format
, args
);
2190 /* Easy -- but watch out!
2192 This routine is *not* a replacement for puts()! puts() appends a newline.
2193 This one doesn't, and had better not! */
2196 puts_filtered (const char *string
)
2198 fputs_filtered (string
, gdb_stdout
);
2202 puts_unfiltered (const char *string
)
2204 fputs_unfiltered (string
, gdb_stdout
);
2207 /* Return a pointer to N spaces and a null. The pointer is good
2208 until the next call to here. */
2213 static char *spaces
= 0;
2214 static int max_spaces
= -1;
2220 spaces
= (char *) xmalloc (n
+ 1);
2221 for (t
= spaces
+ n
; t
!= spaces
;)
2227 return spaces
+ max_spaces
- n
;
2230 /* Print N spaces. */
2232 print_spaces_filtered (int n
, struct ui_file
*stream
)
2234 fputs_filtered (n_spaces (n
), stream
);
2237 /* C++/ObjC demangler stuff. */
2239 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2240 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2241 If the name is not mangled, or the language for the name is unknown, or
2242 demangling is off, the name is printed in its "raw" form. */
2245 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2246 enum language lang
, int arg_mode
)
2252 /* If user wants to see raw output, no problem. */
2255 fputs_filtered (name
, stream
);
2259 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2260 fputs_filtered (demangled
? demangled
: name
, stream
);
2261 if (demangled
!= NULL
)
2269 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2270 differences in whitespace. Returns 0 if they match, non-zero if they
2271 don't (slightly different than strcmp()'s range of return values).
2273 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2274 This "feature" is useful when searching for matching C++ function names
2275 (such as if the user types 'break FOO', where FOO is a mangled C++
2279 strcmp_iw (const char *string1
, const char *string2
)
2281 while ((*string1
!= '\0') && (*string2
!= '\0'))
2283 while (isspace (*string1
))
2287 while (isspace (*string2
))
2291 if (*string1
!= *string2
)
2295 if (*string1
!= '\0')
2301 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2304 /* This is like strcmp except that it ignores whitespace and treats
2305 '(' as the first non-NULL character in terms of ordering. Like
2306 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2307 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2308 according to that ordering.
2310 If a list is sorted according to this function and if you want to
2311 find names in the list that match some fixed NAME according to
2312 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2313 where this function would put NAME.
2315 Here are some examples of why using strcmp to sort is a bad idea:
2319 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2320 we try to do a search for "foo<char*>", strcmp will locate this
2321 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2322 will start looking at strings beginning with "goo", and will never
2323 see the correct match of "foo<char *>".
2325 Parenthesis example:
2327 In practice, this is less like to be an issue, but I'll give it a
2328 shot. Let's assume that '$' is a legitimate character to occur in
2329 symbols. (Which may well even be the case on some systems.) Then
2330 say that the partial symbol table contains "foo$" and "foo(int)".
2331 strcmp will put them in this order, since '$' < '('. Now, if the
2332 user searches for "foo", then strcmp will sort "foo" before "foo$".
2333 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2334 "foo") is false, so it won't proceed to the actual match of
2335 "foo(int)" with "foo". */
2338 strcmp_iw_ordered (const char *string1
, const char *string2
)
2340 while ((*string1
!= '\0') && (*string2
!= '\0'))
2342 while (isspace (*string1
))
2346 while (isspace (*string2
))
2350 if (*string1
!= *string2
)
2354 if (*string1
!= '\0')
2363 /* Characters are non-equal unless they're both '\0'; we want to
2364 make sure we get the comparison right according to our
2365 comparison in the cases where one of them is '\0' or '('. */
2367 if (*string2
== '\0')
2372 if (*string2
== '\0')
2377 if (*string2
== '(')
2380 return *string1
- *string2
;
2384 /* A simple comparison function with opposite semantics to strcmp. */
2387 streq (const char *lhs
, const char *rhs
)
2389 return !strcmp (lhs
, rhs
);
2395 ** Answer whether string_to_compare is a full or partial match to
2396 ** template_string. The partial match must be in sequence starting
2400 subset_compare (char *string_to_compare
, char *template_string
)
2403 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2404 && strlen (string_to_compare
) <= strlen (template_string
))
2407 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2414 pagination_on_command (char *arg
, int from_tty
)
2416 pagination_enabled
= 1;
2420 pagination_off_command (char *arg
, int from_tty
)
2422 pagination_enabled
= 0;
2426 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2427 struct cmd_list_element
*c
, const char *value
)
2429 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"), value
);
2434 initialize_utils (void)
2436 struct cmd_list_element
*c
;
2438 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2439 Set number of characters gdb thinks are in a line."), _("\
2440 Show number of characters gdb thinks are in a line."), NULL
,
2442 show_chars_per_line
,
2443 &setlist
, &showlist
);
2445 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2446 Set number of lines gdb thinks are in a page."), _("\
2447 Show number of lines gdb thinks are in a page."), NULL
,
2449 show_lines_per_page
,
2450 &setlist
, &showlist
);
2454 add_setshow_boolean_cmd ("demangle", class_support
, &demangle
, _("\
2455 Set demangling of encoded C++/ObjC names when displaying symbols."), _("\
2456 Show demangling of encoded C++/ObjC names when displaying symbols."), NULL
,
2459 &setprintlist
, &showprintlist
);
2461 add_setshow_boolean_cmd ("pagination", class_support
,
2462 &pagination_enabled
, _("\
2463 Set state of pagination."), _("\
2464 Show state of pagination."), NULL
,
2466 show_pagination_enabled
,
2467 &setlist
, &showlist
);
2471 add_com ("am", class_support
, pagination_on_command
,
2472 _("Enable pagination"));
2473 add_com ("sm", class_support
, pagination_off_command
,
2474 _("Disable pagination"));
2477 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2478 &sevenbit_strings
, _("\
2479 Set printing of 8-bit characters in strings as \\nnn."), _("\
2480 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2482 show_sevenbit_strings
,
2483 &setprintlist
, &showprintlist
);
2485 add_setshow_boolean_cmd ("asm-demangle", class_support
, &asm_demangle
, _("\
2486 Set demangling of C++/ObjC names in disassembly listings."), _("\
2487 Show demangling of C++/ObjC names in disassembly listings."), NULL
,
2490 &setprintlist
, &showprintlist
);
2492 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
2493 &debug_timestamp
, _("\
2494 Set timestamping of debugging messages."), _("\
2495 Show timestamping of debugging messages."), _("\
2496 When set, debugging messages will be marked with seconds and microseconds."),
2498 show_debug_timestamp
,
2499 &setdebuglist
, &showdebuglist
);
2502 /* Machine specific function to handle SIGWINCH signal. */
2504 #ifdef SIGWINCH_HANDLER_BODY
2505 SIGWINCH_HANDLER_BODY
2507 /* print routines to handle variable size regs, etc. */
2508 /* temporary storage using circular buffer */
2514 static char buf
[NUMCELLS
][CELLSIZE
];
2515 static int cell
= 0;
2516 if (++cell
>= NUMCELLS
)
2524 return (gdbarch_addr_bit (current_gdbarch
) / 8 * 2);
2528 paddr (CORE_ADDR addr
)
2530 return phex (addr
, gdbarch_addr_bit (current_gdbarch
) / 8);
2534 paddr_nz (CORE_ADDR addr
)
2536 return phex_nz (addr
, gdbarch_addr_bit (current_gdbarch
) / 8);
2540 paddress (CORE_ADDR addr
)
2542 /* Truncate address to the size of a target address, avoiding shifts
2543 larger or equal than the width of a CORE_ADDR. The local
2544 variable ADDR_BIT stops the compiler reporting a shift overflow
2545 when it won't occur. */
2546 /* NOTE: This assumes that the significant address information is
2547 kept in the least significant bits of ADDR - the upper bits were
2548 either zero or sign extended. Should gdbarch_address_to_pointer or
2549 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2551 int addr_bit
= gdbarch_addr_bit (current_gdbarch
);
2553 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2554 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2555 return hex_string (addr
);
2559 decimal2str (char *sign
, ULONGEST addr
, int width
)
2561 /* Steal code from valprint.c:print_decimal(). Should this worry
2562 about the real size of addr as the above does? */
2563 unsigned long temp
[3];
2564 char *str
= get_cell ();
2569 temp
[i
] = addr
% (1000 * 1000 * 1000);
2570 addr
/= (1000 * 1000 * 1000);
2574 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2583 xsnprintf (str
, CELLSIZE
, "%s%0*lu", sign
, width
, temp
[0]);
2586 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu", sign
, width
,
2590 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu%09lu", sign
, width
,
2591 temp
[2], temp
[1], temp
[0]);
2594 internal_error (__FILE__
, __LINE__
,
2595 _("failed internal consistency check"));
2602 octal2str (ULONGEST addr
, int width
)
2604 unsigned long temp
[3];
2605 char *str
= get_cell ();
2610 temp
[i
] = addr
% (0100000 * 0100000);
2611 addr
/= (0100000 * 0100000);
2615 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2625 xsnprintf (str
, CELLSIZE
, "%*o", width
, 0);
2627 xsnprintf (str
, CELLSIZE
, "0%0*lo", width
, temp
[0]);
2630 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo", width
, temp
[1], temp
[0]);
2633 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo%010lo", width
,
2634 temp
[2], temp
[1], temp
[0]);
2637 internal_error (__FILE__
, __LINE__
,
2638 _("failed internal consistency check"));
2645 paddr_u (CORE_ADDR addr
)
2647 return decimal2str ("", addr
, 0);
2651 paddr_d (LONGEST addr
)
2654 return decimal2str ("-", -addr
, 0);
2656 return decimal2str ("", addr
, 0);
2659 /* Eliminate warning from compiler on 32-bit systems. */
2660 static int thirty_two
= 32;
2663 phex (ULONGEST l
, int sizeof_l
)
2671 xsnprintf (str
, CELLSIZE
, "%08lx%08lx",
2672 (unsigned long) (l
>> thirty_two
),
2673 (unsigned long) (l
& 0xffffffff));
2677 xsnprintf (str
, CELLSIZE
, "%08lx", (unsigned long) l
);
2681 xsnprintf (str
, CELLSIZE
, "%04x", (unsigned short) (l
& 0xffff));
2684 str
= phex (l
, sizeof (l
));
2692 phex_nz (ULONGEST l
, int sizeof_l
)
2700 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2703 xsnprintf (str
, CELLSIZE
, "%lx",
2704 (unsigned long) (l
& 0xffffffff));
2706 xsnprintf (str
, CELLSIZE
, "%lx%08lx", high
,
2707 (unsigned long) (l
& 0xffffffff));
2712 xsnprintf (str
, CELLSIZE
, "%lx", (unsigned long) l
);
2716 xsnprintf (str
, CELLSIZE
, "%x", (unsigned short) (l
& 0xffff));
2719 str
= phex_nz (l
, sizeof (l
));
2726 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
2727 in a static string. Returns a pointer to this string. */
2729 hex_string (LONGEST num
)
2731 char *result
= get_cell ();
2732 xsnprintf (result
, CELLSIZE
, "0x%s", phex_nz (num
, sizeof (num
)));
2736 /* Converts a LONGEST number to a C-format hexadecimal literal and
2737 stores it in a static string. Returns a pointer to this string
2738 that is valid until the next call. The number is padded on the
2739 left with 0s to at least WIDTH characters. */
2741 hex_string_custom (LONGEST num
, int width
)
2743 char *result
= get_cell ();
2744 char *result_end
= result
+ CELLSIZE
- 1;
2745 const char *hex
= phex_nz (num
, sizeof (num
));
2746 int hex_len
= strlen (hex
);
2748 if (hex_len
> width
)
2750 if (width
+ 2 >= CELLSIZE
)
2751 internal_error (__FILE__
, __LINE__
,
2752 _("hex_string_custom: insufficient space to store result"));
2754 strcpy (result_end
- width
- 2, "0x");
2755 memset (result_end
- width
, '0', width
);
2756 strcpy (result_end
- hex_len
, hex
);
2757 return result_end
- width
- 2;
2760 /* Convert VAL to a numeral in the given radix. For
2761 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
2762 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
2763 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
2764 * to use C format in all cases. If it is false, then 'x'
2765 * and 'o' formats do not include a prefix (0x or leading 0). */
2768 int_string (LONGEST val
, int radix
, int is_signed
, int width
,
2777 result
= hex_string (val
);
2779 result
= hex_string_custom (val
, width
);
2786 if (is_signed
&& val
< 0)
2787 return decimal2str ("-", -val
, width
);
2789 return decimal2str ("", val
, width
);
2793 char *result
= octal2str (val
, width
);
2794 if (use_c_format
|| val
== 0)
2800 internal_error (__FILE__
, __LINE__
,
2801 _("failed internal consistency check"));
2805 /* Convert a CORE_ADDR into a string. */
2807 core_addr_to_string (const CORE_ADDR addr
)
2809 char *str
= get_cell ();
2811 strcat (str
, phex (addr
, sizeof (addr
)));
2816 core_addr_to_string_nz (const CORE_ADDR addr
)
2818 char *str
= get_cell ();
2820 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2824 /* Convert a string back into a CORE_ADDR. */
2826 string_to_core_addr (const char *my_string
)
2828 int addr_bit
= gdbarch_addr_bit (current_gdbarch
);
2831 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2833 /* Assume that it is in hex. */
2835 for (i
= 2; my_string
[i
] != '\0'; i
++)
2837 if (isdigit (my_string
[i
]))
2838 addr
= (my_string
[i
] - '0') + (addr
* 16);
2839 else if (isxdigit (my_string
[i
]))
2840 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2842 error (_("invalid hex \"%s\""), my_string
);
2845 /* Not very modular, but if the executable format expects
2846 addresses to be sign-extended, then do so if the address was
2847 specified with only 32 significant bits. Really this should
2848 be determined by the target architecture, not by the object
2850 if (i
- 2 == addr_bit
/ 4
2852 && bfd_get_sign_extend_vma (exec_bfd
))
2853 addr
= (addr
^ ((CORE_ADDR
) 1 << (addr_bit
- 1)))
2854 - ((CORE_ADDR
) 1 << (addr_bit
- 1));
2858 /* Assume that it is in decimal. */
2860 for (i
= 0; my_string
[i
] != '\0'; i
++)
2862 if (isdigit (my_string
[i
]))
2863 addr
= (my_string
[i
] - '0') + (addr
* 10);
2865 error (_("invalid decimal \"%s\""), my_string
);
2873 host_address_to_string (const void *addr
)
2875 char *str
= get_cell ();
2876 sprintf (str
, "0x%lx", (unsigned long) addr
);
2881 gdb_realpath (const char *filename
)
2883 /* Method 1: The system has a compile time upper bound on a filename
2884 path. Use that and realpath() to canonicalize the name. This is
2885 the most common case. Note that, if there isn't a compile time
2886 upper bound, you want to avoid realpath() at all costs. */
2887 #if defined(HAVE_REALPATH)
2889 # if defined (PATH_MAX)
2891 # define USE_REALPATH
2892 # elif defined (MAXPATHLEN)
2893 char buf
[MAXPATHLEN
];
2894 # define USE_REALPATH
2896 # if defined (USE_REALPATH)
2897 const char *rp
= realpath (filename
, buf
);
2900 return xstrdup (rp
);
2903 #endif /* HAVE_REALPATH */
2905 /* Method 2: The host system (i.e., GNU) has the function
2906 canonicalize_file_name() which malloc's a chunk of memory and
2907 returns that, use that. */
2908 #if defined(HAVE_CANONICALIZE_FILE_NAME)
2910 char *rp
= canonicalize_file_name (filename
);
2912 return xstrdup (filename
);
2918 /* FIXME: cagney/2002-11-13:
2920 Method 2a: Use realpath() with a NULL buffer. Some systems, due
2921 to the problems described in in method 3, have modified their
2922 realpath() implementation so that it will allocate a buffer when
2923 NULL is passed in. Before this can be used, though, some sort of
2924 configure time test would need to be added. Otherwize the code
2925 will likely core dump. */
2927 /* Method 3: Now we're getting desperate! The system doesn't have a
2928 compile time buffer size and no alternative function. Query the
2929 OS, using pathconf(), for the buffer limit. Care is needed
2930 though, some systems do not limit PATH_MAX (return -1 for
2931 pathconf()) making it impossible to pass a correctly sized buffer
2932 to realpath() (it could always overflow). On those systems, we
2934 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2936 /* Find out the max path size. */
2937 long path_max
= pathconf ("/", _PC_PATH_MAX
);
2940 /* PATH_MAX is bounded. */
2941 char *buf
= alloca (path_max
);
2942 char *rp
= realpath (filename
, buf
);
2943 return xstrdup (rp
? rp
: filename
);
2948 /* This system is a lost cause, just dup the buffer. */
2949 return xstrdup (filename
);
2952 /* Return a copy of FILENAME, with its directory prefix canonicalized
2956 xfullpath (const char *filename
)
2958 const char *base_name
= lbasename (filename
);
2963 /* Extract the basename of filename, and return immediately
2964 a copy of filename if it does not contain any directory prefix. */
2965 if (base_name
== filename
)
2966 return xstrdup (filename
);
2968 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
2969 /* Allocate enough space to store the dir_name + plus one extra
2970 character sometimes needed under Windows (see below), and
2971 then the closing \000 character */
2972 strncpy (dir_name
, filename
, base_name
- filename
);
2973 dir_name
[base_name
- filename
] = '\000';
2975 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2976 /* We need to be careful when filename is of the form 'd:foo', which
2977 is equivalent of d:./foo, which is totally different from d:/foo. */
2978 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
2981 dir_name
[3] = '\000';
2985 /* Canonicalize the directory prefix, and build the resulting
2986 filename. If the dirname realpath already contains an ending
2987 directory separator, avoid doubling it. */
2988 real_path
= gdb_realpath (dir_name
);
2989 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
2990 result
= concat (real_path
, base_name
, (char *)NULL
);
2992 result
= concat (real_path
, SLASH_STRING
, base_name
, (char *)NULL
);
2999 /* This is the 32-bit CRC function used by the GNU separate debug
3000 facility. An executable may contain a section named
3001 .gnu_debuglink, which holds the name of a separate executable file
3002 containing its debug info, and a checksum of that file's contents,
3003 computed using this function. */
3005 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
3007 static const unsigned long crc32_table
[256] = {
3008 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3009 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3010 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3011 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3012 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3013 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3014 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3015 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3016 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3017 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3018 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3019 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3020 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3021 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3022 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3023 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3024 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3025 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3026 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3027 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3028 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3029 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3030 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3031 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3032 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3033 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3034 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3035 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3036 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3037 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3038 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3039 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3040 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3041 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3042 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3043 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3044 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3045 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3046 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3047 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3048 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3049 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3050 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3051 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3052 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3053 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3054 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3055 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3056 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3057 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3058 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3063 crc
= ~crc
& 0xffffffff;
3064 for (end
= buf
+ len
; buf
< end
; ++buf
)
3065 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
3066 return ~crc
& 0xffffffff;;
3070 align_up (ULONGEST v
, int n
)
3072 /* Check that N is really a power of two. */
3073 gdb_assert (n
&& (n
& (n
-1)) == 0);
3074 return (v
+ n
- 1) & -n
;
3078 align_down (ULONGEST v
, int n
)
3080 /* Check that N is really a power of two. */
3081 gdb_assert (n
&& (n
& (n
-1)) == 0);
3085 /* Allocation function for the libiberty hash table which uses an
3086 obstack. The obstack is passed as DATA. */
3089 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
3091 unsigned int total
= size
* count
;
3092 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
3093 memset (ptr
, 0, total
);
3097 /* Trivial deallocation function for the libiberty splay tree and hash
3098 table - don't deallocate anything. Rely on later deletion of the
3099 obstack. DATA will be the obstack, although it is not needed
3103 dummy_obstack_deallocate (void *object
, void *data
)
3108 /* The bit offset of the highest byte in a ULONGEST, for overflow
3111 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3113 /* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3114 where 2 <= BASE <= 36. */
3117 is_digit_in_base (unsigned char digit
, int base
)
3119 if (!isalnum (digit
))
3122 return (isdigit (digit
) && digit
< base
+ '0');
3124 return (isdigit (digit
) || tolower (digit
) < base
- 10 + 'a');
3128 digit_to_int (unsigned char c
)
3133 return tolower (c
) - 'a' + 10;
3136 /* As for strtoul, but for ULONGEST results. */
3139 strtoulst (const char *num
, const char **trailer
, int base
)
3141 unsigned int high_part
;
3146 /* Skip leading whitespace. */
3147 while (isspace (num
[i
]))
3150 /* Handle prefixes. */
3153 else if (num
[i
] == '-')
3159 if (base
== 0 || base
== 16)
3161 if (num
[i
] == '0' && (num
[i
+ 1] == 'x' || num
[i
+ 1] == 'X'))
3169 if (base
== 0 && num
[i
] == '0')
3175 if (base
< 2 || base
> 36)
3181 result
= high_part
= 0;
3182 for (; is_digit_in_base (num
[i
], base
); i
+= 1)
3184 result
= result
* base
+ digit_to_int (num
[i
]);
3185 high_part
= high_part
* base
+ (unsigned int) (result
>> HIGH_BYTE_POSN
);
3186 result
&= ((ULONGEST
) 1 << HIGH_BYTE_POSN
) - 1;
3187 if (high_part
> 0xff)
3190 result
= ~ (ULONGEST
) 0;
3197 if (trailer
!= NULL
)
3200 result
= result
+ ((ULONGEST
) high_part
<< HIGH_BYTE_POSN
);
3207 /* Simple, portable version of dirname that does not modify its
3211 ldirname (const char *filename
)
3213 const char *base
= lbasename (filename
);
3216 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
3219 if (base
== filename
)
3222 dirname
= xmalloc (base
- filename
+ 2);
3223 memcpy (dirname
, filename
, base
- filename
);
3225 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3226 create "d:./bar" later instead of the (different) "d:/bar". */
3227 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
3228 && !IS_DIR_SEPARATOR (filename
[0]))
3229 dirname
[base
++ - filename
] = '.';
3231 dirname
[base
- filename
] = '\0';