1 /* General utility routines for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_assert.h"
27 #include "gdb_string.h"
28 #include "event-top.h"
34 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
45 #include "expression.h"
49 #include "filenames.h"
51 #include "inferior.h" /* for signed_pointer_to_address */
53 #include <sys/param.h> /* For MAXPATHLEN */
62 #include <readline/readline.h>
68 #ifdef NEED_DECLARATION_MALLOC
69 extern PTR
malloc (); /* OK: PTR */
71 #ifdef NEED_DECLARATION_REALLOC
72 extern PTR
realloc (); /* OK: PTR */
74 #ifdef NEED_DECLARATION_FREE
77 /* Actually, we'll never have the decl, since we don't define _GNU_SOURCE. */
78 #if defined(HAVE_CANONICALIZE_FILE_NAME) \
79 && defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
80 extern char *canonicalize_file_name (const char *);
83 /* readline defines this. */
86 void (*error_begin_hook
) (void);
88 /* Holds the last error message issued by gdb */
90 static struct ui_file
*gdb_lasterr
;
92 /* Prototypes for local functions */
94 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
97 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
99 #if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
100 static void malloc_botch (void);
103 static void prompt_for_continue (void);
105 static void set_screen_size (void);
106 static void set_width (void);
108 /* Chain of cleanup actions established with make_cleanup,
109 to be executed if an error happens. */
111 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
112 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
113 static struct cleanup
*run_cleanup_chain
; /* cleaned up on each 'run' */
114 static struct cleanup
*exec_cleanup_chain
; /* cleaned up on each execution command */
115 /* cleaned up on each error from within an execution command */
116 static struct cleanup
*exec_error_cleanup_chain
;
118 /* Pointer to what is left to do for an execution command after the
119 target stops. Used only in asynchronous mode, by targets that
120 support async execution. The finish and until commands use it. So
121 does the target extended-remote command. */
122 struct continuation
*cmd_continuation
;
123 struct continuation
*intermediate_continuation
;
125 /* Nonzero if we have job control. */
129 /* Nonzero means a quit has been requested. */
133 /* Nonzero means quit immediately if Control-C is typed now, rather
134 than waiting until QUIT is executed. Be careful in setting this;
135 code which executes with immediate_quit set has to be very careful
136 about being able to deal with being interrupted at any time. It is
137 almost always better to use QUIT; the only exception I can think of
138 is being able to quit out of a system call (using EINTR loses if
139 the SIGINT happens between the previous QUIT and the system call).
140 To immediately quit in the case in which a SIGINT happens between
141 the previous QUIT and setting immediate_quit (desirable anytime we
142 expect to block), call QUIT after setting immediate_quit. */
146 /* Nonzero means that encoded C++/ObjC names should be printed out in their
147 C++/ObjC form rather than raw. */
151 /* Nonzero means that encoded C++/ObjC names should be printed out in their
152 C++/ObjC form even in assembler language displays. If this is set, but
153 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
155 int asm_demangle
= 0;
157 /* Nonzero means that strings with character values >0x7F should be printed
158 as octal escapes. Zero means just print the value (e.g. it's an
159 international character, and the terminal or window can cope.) */
161 int sevenbit_strings
= 0;
163 /* String to be printed before error messages, if any. */
165 char *error_pre_print
;
167 /* String to be printed before quit messages, if any. */
169 char *quit_pre_print
;
171 /* String to be printed before warning messages, if any. */
173 char *warning_pre_print
= "\nwarning: ";
175 int pagination_enabled
= 1;
178 /* Add a new cleanup to the cleanup_chain,
179 and return the previous chain pointer
180 to be passed later to do_cleanups or discard_cleanups.
181 Args are FUNCTION to clean up with, and ARG to pass to it. */
184 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
186 return make_my_cleanup (&cleanup_chain
, function
, arg
);
190 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
192 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
196 make_run_cleanup (make_cleanup_ftype
*function
, void *arg
)
198 return make_my_cleanup (&run_cleanup_chain
, function
, arg
);
202 make_exec_cleanup (make_cleanup_ftype
*function
, void *arg
)
204 return make_my_cleanup (&exec_cleanup_chain
, function
, arg
);
208 make_exec_error_cleanup (make_cleanup_ftype
*function
, void *arg
)
210 return make_my_cleanup (&exec_error_cleanup_chain
, function
, arg
);
214 do_freeargv (void *arg
)
216 freeargv ((char **) arg
);
220 make_cleanup_freeargv (char **arg
)
222 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
226 do_bfd_close_cleanup (void *arg
)
232 make_cleanup_bfd_close (bfd
*abfd
)
234 return make_cleanup (do_bfd_close_cleanup
, abfd
);
238 do_close_cleanup (void *arg
)
246 make_cleanup_close (int fd
)
248 int *saved_fd
= xmalloc (sizeof (fd
));
250 return make_cleanup (do_close_cleanup
, saved_fd
);
254 do_ui_file_delete (void *arg
)
256 ui_file_delete (arg
);
260 make_cleanup_ui_file_delete (struct ui_file
*arg
)
262 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
266 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
269 register struct cleanup
*new
270 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
271 register struct cleanup
*old_chain
= *pmy_chain
;
273 new->next
= *pmy_chain
;
274 new->function
= function
;
281 /* Discard cleanups and do the actions they describe
282 until we get back to the point OLD_CHAIN in the cleanup_chain. */
285 do_cleanups (register struct cleanup
*old_chain
)
287 do_my_cleanups (&cleanup_chain
, old_chain
);
291 do_final_cleanups (register struct cleanup
*old_chain
)
293 do_my_cleanups (&final_cleanup_chain
, old_chain
);
297 do_run_cleanups (register struct cleanup
*old_chain
)
299 do_my_cleanups (&run_cleanup_chain
, old_chain
);
303 do_exec_cleanups (register struct cleanup
*old_chain
)
305 do_my_cleanups (&exec_cleanup_chain
, old_chain
);
309 do_exec_error_cleanups (register struct cleanup
*old_chain
)
311 do_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
315 do_my_cleanups (register struct cleanup
**pmy_chain
,
316 register struct cleanup
*old_chain
)
318 register struct cleanup
*ptr
;
319 while ((ptr
= *pmy_chain
) != old_chain
)
321 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
322 (*ptr
->function
) (ptr
->arg
);
327 /* Discard cleanups, not doing the actions they describe,
328 until we get back to the point OLD_CHAIN in the cleanup_chain. */
331 discard_cleanups (register struct cleanup
*old_chain
)
333 discard_my_cleanups (&cleanup_chain
, old_chain
);
337 discard_final_cleanups (register struct cleanup
*old_chain
)
339 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
343 discard_exec_error_cleanups (register struct cleanup
*old_chain
)
345 discard_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
349 discard_my_cleanups (register struct cleanup
**pmy_chain
,
350 register struct cleanup
*old_chain
)
352 register struct cleanup
*ptr
;
353 while ((ptr
= *pmy_chain
) != old_chain
)
355 *pmy_chain
= ptr
->next
;
360 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
364 return save_my_cleanups (&cleanup_chain
);
368 save_final_cleanups (void)
370 return save_my_cleanups (&final_cleanup_chain
);
374 save_my_cleanups (struct cleanup
**pmy_chain
)
376 struct cleanup
*old_chain
= *pmy_chain
;
382 /* Restore the cleanup chain from a previously saved chain. */
384 restore_cleanups (struct cleanup
*chain
)
386 restore_my_cleanups (&cleanup_chain
, chain
);
390 restore_final_cleanups (struct cleanup
*chain
)
392 restore_my_cleanups (&final_cleanup_chain
, chain
);
396 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
401 /* This function is useful for cleanups.
405 old_chain = make_cleanup (free_current_contents, &foo);
407 to arrange to free the object thus allocated. */
410 free_current_contents (void *ptr
)
412 void **location
= ptr
;
413 if (location
== NULL
)
414 internal_error (__FILE__
, __LINE__
,
415 "free_current_contents: NULL pointer");
416 if (*location
!= NULL
)
423 /* Provide a known function that does nothing, to use as a base for
424 for a possibly long chain of cleanups. This is useful where we
425 use the cleanup chain for handling normal cleanups as well as dealing
426 with cleanups that need to be done as a result of a call to error().
427 In such cases, we may not be certain where the first cleanup is, unless
428 we have a do-nothing one to always use as the base. */
432 null_cleanup (void *arg
)
436 /* Add a continuation to the continuation list, the global list
437 cmd_continuation. The new continuation will be added at the front.*/
439 add_continuation (void (*continuation_hook
) (struct continuation_arg
*),
440 struct continuation_arg
*arg_list
)
442 struct continuation
*continuation_ptr
;
445 (struct continuation
*) xmalloc (sizeof (struct continuation
));
446 continuation_ptr
->continuation_hook
= continuation_hook
;
447 continuation_ptr
->arg_list
= arg_list
;
448 continuation_ptr
->next
= cmd_continuation
;
449 cmd_continuation
= continuation_ptr
;
452 /* Walk down the cmd_continuation list, and execute all the
453 continuations. There is a problem though. In some cases new
454 continuations may be added while we are in the middle of this
455 loop. If this happens they will be added in the front, and done
456 before we have a chance of exhausting those that were already
457 there. We need to then save the beginning of the list in a pointer
458 and do the continuations from there on, instead of using the
459 global beginning of list as our iteration pointer.*/
461 do_all_continuations (void)
463 struct continuation
*continuation_ptr
;
464 struct continuation
*saved_continuation
;
466 /* Copy the list header into another pointer, and set the global
467 list header to null, so that the global list can change as a side
468 effect of invoking the continuations and the processing of
469 the preexisting continuations will not be affected. */
470 continuation_ptr
= cmd_continuation
;
471 cmd_continuation
= NULL
;
473 /* Work now on the list we have set aside. */
474 while (continuation_ptr
)
476 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
477 saved_continuation
= continuation_ptr
;
478 continuation_ptr
= continuation_ptr
->next
;
479 xfree (saved_continuation
);
483 /* Walk down the cmd_continuation list, and get rid of all the
486 discard_all_continuations (void)
488 struct continuation
*continuation_ptr
;
490 while (cmd_continuation
)
492 continuation_ptr
= cmd_continuation
;
493 cmd_continuation
= continuation_ptr
->next
;
494 xfree (continuation_ptr
);
498 /* Add a continuation to the continuation list, the global list
499 intermediate_continuation. The new continuation will be added at the front.*/
501 add_intermediate_continuation (void (*continuation_hook
)
502 (struct continuation_arg
*),
503 struct continuation_arg
*arg_list
)
505 struct continuation
*continuation_ptr
;
508 (struct continuation
*) xmalloc (sizeof (struct continuation
));
509 continuation_ptr
->continuation_hook
= continuation_hook
;
510 continuation_ptr
->arg_list
= arg_list
;
511 continuation_ptr
->next
= intermediate_continuation
;
512 intermediate_continuation
= continuation_ptr
;
515 /* Walk down the cmd_continuation list, and execute all the
516 continuations. There is a problem though. In some cases new
517 continuations may be added while we are in the middle of this
518 loop. If this happens they will be added in the front, and done
519 before we have a chance of exhausting those that were already
520 there. We need to then save the beginning of the list in a pointer
521 and do the continuations from there on, instead of using the
522 global beginning of list as our iteration pointer.*/
524 do_all_intermediate_continuations (void)
526 struct continuation
*continuation_ptr
;
527 struct continuation
*saved_continuation
;
529 /* Copy the list header into another pointer, and set the global
530 list header to null, so that the global list can change as a side
531 effect of invoking the continuations and the processing of
532 the preexisting continuations will not be affected. */
533 continuation_ptr
= intermediate_continuation
;
534 intermediate_continuation
= NULL
;
536 /* Work now on the list we have set aside. */
537 while (continuation_ptr
)
539 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
540 saved_continuation
= continuation_ptr
;
541 continuation_ptr
= continuation_ptr
->next
;
542 xfree (saved_continuation
);
546 /* Walk down the cmd_continuation list, and get rid of all the
549 discard_all_intermediate_continuations (void)
551 struct continuation
*continuation_ptr
;
553 while (intermediate_continuation
)
555 continuation_ptr
= intermediate_continuation
;
556 intermediate_continuation
= continuation_ptr
->next
;
557 xfree (continuation_ptr
);
563 /* Print a warning message. The first argument STRING is the warning
564 message, used as an fprintf format string, the second is the
565 va_list of arguments for that string. A warning is unfiltered (not
566 paginated) so that the user does not need to page through each
567 screen full of warnings when there are lots of them. */
570 vwarning (const char *string
, va_list args
)
573 (*warning_hook
) (string
, args
);
576 target_terminal_ours ();
577 wrap_here (""); /* Force out any buffered output */
578 gdb_flush (gdb_stdout
);
579 if (warning_pre_print
)
580 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
581 vfprintf_unfiltered (gdb_stderr
, string
, args
);
582 fprintf_unfiltered (gdb_stderr
, "\n");
587 /* Print a warning message.
588 The first argument STRING is the warning message, used as a fprintf string,
589 and the remaining args are passed as arguments to it.
590 The primary difference between warnings and errors is that a warning
591 does not force the return to command level. */
594 warning (const char *string
, ...)
597 va_start (args
, string
);
598 vwarning (string
, args
);
602 /* Print an error message and return to command level.
603 The first argument STRING is the error message, used as a fprintf string,
604 and the remaining args are passed as arguments to it. */
607 verror (const char *string
, va_list args
)
609 struct ui_file
*tmp_stream
= mem_fileopen ();
610 make_cleanup_ui_file_delete (tmp_stream
);
611 vfprintf_unfiltered (tmp_stream
, string
, args
);
612 error_stream (tmp_stream
);
616 error (const char *string
, ...)
619 va_start (args
, string
);
620 verror (string
, args
);
625 do_write (void *data
, const char *buffer
, long length_buffer
)
627 ui_file_write (data
, buffer
, length_buffer
);
631 error_stream (struct ui_file
*stream
)
633 if (error_begin_hook
)
636 /* Copy the stream into the GDB_LASTERR buffer. */
637 ui_file_rewind (gdb_lasterr
);
638 ui_file_put (stream
, do_write
, gdb_lasterr
);
640 /* Write the message plus any error_pre_print to gdb_stderr. */
641 target_terminal_ours ();
642 wrap_here (""); /* Force out any buffered output */
643 gdb_flush (gdb_stdout
);
644 annotate_error_begin ();
646 fputs_filtered (error_pre_print
, gdb_stderr
);
647 ui_file_put (stream
, do_write
, gdb_stderr
);
648 fprintf_filtered (gdb_stderr
, "\n");
650 throw_exception (RETURN_ERROR
);
653 /* Get the last error message issued by gdb */
656 error_last_message (void)
659 return ui_file_xstrdup (gdb_lasterr
, &len
);
662 /* This is to be called by main() at the very beginning */
667 gdb_lasterr
= mem_fileopen ();
670 /* Print a message reporting an internal error/warning. Ask the user
671 if they want to continue, dump core, or just exit. Return
672 something to indicate a quit. */
674 struct internal_problem
677 /* FIXME: cagney/2002-08-15: There should be ``maint set/show''
678 commands available for controlling these variables. */
679 enum auto_boolean should_quit
;
680 enum auto_boolean should_dump_core
;
683 /* Report a problem, internal to GDB, to the user. Once the problem
684 has been reported, and assuming GDB didn't quit, the caller can
685 either allow execution to resume or throw an error. */
688 internal_vproblem (struct internal_problem
*problem
,
689 const char *file
, int line
, const char *fmt
, va_list ap
)
696 /* Don't allow infinite error/warning recursion. */
698 static char msg
[] = "Recursive internal problem.\n";
706 fputs_unfiltered (msg
, gdb_stderr
);
707 abort (); /* NOTE: GDB has only three calls to abort(). */
710 write (STDERR_FILENO
, msg
, sizeof (msg
));
715 /* Try to get the message out and at the start of a new line. */
716 target_terminal_ours ();
719 /* Create a string containing the full error/warning message. Need
720 to call query with this full string, as otherwize the reason
721 (error/warning) and question become separated. Format using a
722 style similar to a compiler error message. Include extra detail
723 so that the user knows that they are living on the edge. */
726 xvasprintf (&msg
, fmt
, ap
);
727 xasprintf (&reason
, "\
729 A problem internal to GDB has been detected,\n\
730 further debugging may prove unreliable.", file
, line
, problem
->name
, msg
);
732 make_cleanup (xfree
, reason
);
735 switch (problem
->should_quit
)
737 case AUTO_BOOLEAN_AUTO
:
738 /* Default (yes/batch case) is to quit GDB. When in batch mode
739 this lessens the likelhood of GDB going into an infinate
741 quit_p
= query ("%s\nQuit this debugging session? ", reason
);
743 case AUTO_BOOLEAN_TRUE
:
746 case AUTO_BOOLEAN_FALSE
:
750 internal_error (__FILE__
, __LINE__
, "bad switch");
753 switch (problem
->should_dump_core
)
755 case AUTO_BOOLEAN_AUTO
:
756 /* Default (yes/batch case) is to dump core. This leaves a GDB
757 `dropping' so that it is easier to see that something went
759 dump_core_p
= query ("%s\nCreate a core file of GDB? ", reason
);
762 case AUTO_BOOLEAN_TRUE
:
765 case AUTO_BOOLEAN_FALSE
:
769 internal_error (__FILE__
, __LINE__
, "bad switch");
775 abort (); /* NOTE: GDB has only three calls to abort(). */
784 abort (); /* NOTE: GDB has only three calls to abort(). */
791 static struct internal_problem internal_error_problem
= {
792 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
796 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
798 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
799 throw_exception (RETURN_ERROR
);
803 internal_error (const char *file
, int line
, const char *string
, ...)
806 va_start (ap
, string
);
807 internal_verror (file
, line
, string
, ap
);
811 static struct internal_problem internal_warning_problem
= {
812 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
816 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
818 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
822 internal_warning (const char *file
, int line
, const char *string
, ...)
825 va_start (ap
, string
);
826 internal_vwarning (file
, line
, string
, ap
);
830 /* The strerror() function can return NULL for errno values that are
831 out of range. Provide a "safe" version that always returns a
835 safe_strerror (int errnum
)
840 msg
= strerror (errnum
);
843 sprintf (buf
, "(undocumented errno %d)", errnum
);
849 /* Print the system error message for errno, and also mention STRING
850 as the file name for which the error was encountered.
851 Then return to command level. */
854 perror_with_name (const char *string
)
859 err
= safe_strerror (errno
);
860 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
861 strcpy (combined
, string
);
862 strcat (combined
, ": ");
863 strcat (combined
, err
);
865 /* I understand setting these is a matter of taste. Still, some people
866 may clear errno but not know about bfd_error. Doing this here is not
868 bfd_set_error (bfd_error_no_error
);
871 error ("%s.", combined
);
874 /* Print the system error message for ERRCODE, and also mention STRING
875 as the file name for which the error was encountered. */
878 print_sys_errmsg (const char *string
, int errcode
)
883 err
= safe_strerror (errcode
);
884 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
885 strcpy (combined
, string
);
886 strcat (combined
, ": ");
887 strcat (combined
, err
);
889 /* We want anything which was printed on stdout to come out first, before
891 gdb_flush (gdb_stdout
);
892 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
895 /* Control C eventually causes this to be called, at a convenient time. */
900 struct serial
*gdb_stdout_serial
= serial_fdopen (1);
902 target_terminal_ours ();
904 /* We want all output to appear now, before we print "Quit". We
905 have 3 levels of buffering we have to flush (it's possible that
906 some of these should be changed to flush the lower-level ones
909 /* 1. The _filtered buffer. */
910 wrap_here ((char *) 0);
912 /* 2. The stdio buffer. */
913 gdb_flush (gdb_stdout
);
914 gdb_flush (gdb_stderr
);
916 /* 3. The system-level buffer. */
917 serial_drain_output (gdb_stdout_serial
);
918 serial_un_fdopen (gdb_stdout_serial
);
920 annotate_error_begin ();
922 /* Don't use *_filtered; we don't want to prompt the user to continue. */
924 fputs_unfiltered (quit_pre_print
, gdb_stderr
);
927 /* No steenking SIGINT will ever be coming our way when the
928 program is resumed. Don't lie. */
929 fprintf_unfiltered (gdb_stderr
, "Quit\n");
932 /* If there is no terminal switching for this target, then we can't
933 possibly get screwed by the lack of job control. */
934 || current_target
.to_terminal_ours
== NULL
)
935 fprintf_unfiltered (gdb_stderr
, "Quit\n");
937 fprintf_unfiltered (gdb_stderr
,
938 "Quit (expect signal SIGINT when the program is resumed)\n");
940 throw_exception (RETURN_QUIT
);
943 /* Control C comes here */
945 request_quit (int signo
)
948 /* Restore the signal handler. Harmless with BSD-style signals, needed
949 for System V-style signals. So just always do it, rather than worrying
950 about USG defines and stuff like that. */
951 signal (signo
, request_quit
);
961 /* Memory management stuff (malloc friends). */
963 #if !defined (USE_MMALLOC)
966 mmalloc (void *md
, size_t size
)
968 return malloc (size
); /* NOTE: GDB's only call to malloc() */
972 mrealloc (void *md
, void *ptr
, size_t size
)
974 if (ptr
== 0) /* Guard against old realloc's */
975 return mmalloc (md
, size
);
977 return realloc (ptr
, size
); /* NOTE: GDB's only call to ralloc() */
981 mcalloc (void *md
, size_t number
, size_t size
)
983 return calloc (number
, size
); /* NOTE: GDB's only call to calloc() */
987 mfree (void *md
, void *ptr
)
989 free (ptr
); /* NOTE: GDB's only call to free() */
992 #endif /* USE_MMALLOC */
994 #if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
997 init_malloc (void *md
)
1001 #else /* Have mmalloc and want corruption checking */
1006 fprintf_unfiltered (gdb_stderr
, "Memory corruption\n");
1007 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1010 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
1011 by MD, to detect memory corruption. Note that MD may be NULL to specify
1012 the default heap that grows via sbrk.
1014 Note that for freshly created regions, we must call mmcheckf prior to any
1015 mallocs in the region. Otherwise, any region which was allocated prior to
1016 installing the checking hooks, which is later reallocated or freed, will
1017 fail the checks! The mmcheck function only allows initial hooks to be
1018 installed before the first mmalloc. However, anytime after we have called
1019 mmcheck the first time to install the checking hooks, we can call it again
1020 to update the function pointer to the memory corruption handler.
1022 Returns zero on failure, non-zero on success. */
1024 #ifndef MMCHECK_FORCE
1025 #define MMCHECK_FORCE 0
1029 init_malloc (void *md
)
1031 if (!mmcheckf (md
, malloc_botch
, MMCHECK_FORCE
))
1033 /* Don't use warning(), which relies on current_target being set
1034 to something other than dummy_target, until after
1035 initialize_all_files(). */
1039 "warning: failed to install memory consistency checks; ");
1040 fprintf_unfiltered (gdb_stderr
,
1041 "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
1047 #endif /* Have mmalloc and want corruption checking */
1049 /* Called when a memory allocation fails, with the number of bytes of
1050 memory requested in SIZE. */
1057 internal_error (__FILE__
, __LINE__
,
1058 "virtual memory exhausted: can't allocate %ld bytes.",
1063 internal_error (__FILE__
, __LINE__
, "virtual memory exhausted.");
1067 /* The xmmalloc() family of memory management routines.
1069 These are are like the mmalloc() family except that they implement
1070 consistent semantics and guard against typical memory management
1071 problems: if a malloc fails, an internal error is thrown; if
1072 free(NULL) is called, it is ignored; if *alloc(0) is called, NULL
1075 All these routines are implemented using the mmalloc() family. */
1078 xmmalloc (void *md
, size_t size
)
1082 /* See libiberty/xmalloc.c. This function need's to match that's
1083 semantics. It never returns NULL. */
1087 val
= mmalloc (md
, size
);
1095 xmrealloc (void *md
, void *ptr
, size_t size
)
1099 /* See libiberty/xmalloc.c. This function need's to match that's
1100 semantics. It never returns NULL. */
1105 val
= mrealloc (md
, ptr
, size
);
1107 val
= mmalloc (md
, size
);
1115 xmcalloc (void *md
, size_t number
, size_t size
)
1119 /* See libiberty/xmalloc.c. This function need's to match that's
1120 semantics. It never returns NULL. */
1121 if (number
== 0 || size
== 0)
1127 mem
= mcalloc (md
, number
, size
);
1129 nomem (number
* size
);
1135 xmfree (void *md
, void *ptr
)
1141 /* The xmalloc() (libiberty.h) family of memory management routines.
1143 These are like the ISO-C malloc() family except that they implement
1144 consistent semantics and guard against typical memory management
1145 problems. See xmmalloc() above for further information.
1147 All these routines are wrappers to the xmmalloc() family. */
1149 /* NOTE: These are declared using PTR to ensure consistency with
1150 "libiberty.h". xfree() is GDB local. */
1153 xmalloc (size_t size
)
1155 return xmmalloc (NULL
, size
);
1159 xrealloc (PTR ptr
, size_t size
) /* OK: PTR */
1161 return xmrealloc (NULL
, ptr
, size
);
1165 xcalloc (size_t number
, size_t size
)
1167 return xmcalloc (NULL
, number
, size
);
1177 /* Like asprintf/vasprintf but get an internal_error if the call
1181 xstrprintf (const char *format
, ...)
1185 va_start (args
, format
);
1186 xvasprintf (&ret
, format
, args
);
1192 xasprintf (char **ret
, const char *format
, ...)
1195 va_start (args
, format
);
1196 xvasprintf (ret
, format
, args
);
1201 xvasprintf (char **ret
, const char *format
, va_list ap
)
1203 int status
= vasprintf (ret
, format
, ap
);
1204 /* NULL could be returned due to a memory allocation problem; a
1205 badly format string; or something else. */
1207 internal_error (__FILE__
, __LINE__
,
1208 "vasprintf returned NULL buffer (errno %d)", errno
);
1209 /* A negative status with a non-NULL buffer shouldn't never
1210 happen. But to be sure. */
1212 internal_error (__FILE__
, __LINE__
,
1213 "vasprintf call failed (errno %d)", errno
);
1217 /* My replacement for the read system call.
1218 Used like `read' but keeps going if `read' returns too soon. */
1221 myread (int desc
, char *addr
, int len
)
1228 val
= read (desc
, addr
, len
);
1232 return orglen
- len
;
1239 /* Make a copy of the string at PTR with SIZE characters
1240 (and add a null character at the end in the copy).
1241 Uses malloc to get the space. Returns the address of the copy. */
1244 savestring (const char *ptr
, size_t size
)
1246 register char *p
= (char *) xmalloc (size
+ 1);
1247 memcpy (p
, ptr
, size
);
1253 msavestring (void *md
, const char *ptr
, size_t size
)
1255 register char *p
= (char *) xmmalloc (md
, size
+ 1);
1256 memcpy (p
, ptr
, size
);
1262 mstrsave (void *md
, const char *ptr
)
1264 return (msavestring (md
, ptr
, strlen (ptr
)));
1268 print_spaces (register int n
, register struct ui_file
*file
)
1270 fputs_unfiltered (n_spaces (n
), file
);
1273 /* Print a host address. */
1276 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1279 /* We could use the %p conversion specifier to fprintf if we had any
1280 way of knowing whether this host supports it. But the following
1281 should work on the Alpha and on 32 bit machines. */
1283 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1286 /* Ask user a y-or-n question and return 1 iff answer is yes.
1287 Takes three args which are given to printf to print the question.
1288 The first, a control string, should end in "? ".
1289 It should not say how to answer, because we do that. */
1293 query (const char *ctlstr
, ...)
1296 register int answer
;
1300 va_start (args
, ctlstr
);
1304 return query_hook (ctlstr
, args
);
1307 /* Automatically answer "yes" if input is not from a terminal. */
1308 if (!input_from_terminal_p ())
1313 wrap_here (""); /* Flush any buffered output */
1314 gdb_flush (gdb_stdout
);
1316 if (annotation_level
> 1)
1317 printf_filtered ("\n\032\032pre-query\n");
1319 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1320 printf_filtered ("(y or n) ");
1322 if (annotation_level
> 1)
1323 printf_filtered ("\n\032\032query\n");
1326 gdb_flush (gdb_stdout
);
1328 answer
= fgetc (stdin
);
1329 clearerr (stdin
); /* in case of C-d */
1330 if (answer
== EOF
) /* C-d */
1335 /* Eat rest of input line, to EOF or newline */
1339 ans2
= fgetc (stdin
);
1342 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1356 printf_filtered ("Please answer y or n.\n");
1359 if (annotation_level
> 1)
1360 printf_filtered ("\n\032\032post-query\n");
1365 /* Print an error message saying that we couldn't make sense of a
1366 \^mumble sequence in a string or character constant. START and END
1367 indicate a substring of some larger string that contains the
1368 erroneous backslash sequence, missing the initial backslash. */
1370 no_control_char_error (const char *start
, const char *end
)
1372 int len
= end
- start
;
1373 char *copy
= alloca (end
- start
+ 1);
1375 memcpy (copy
, start
, len
);
1378 error ("There is no control character `\\%s' in the `%s' character set.",
1379 copy
, target_charset ());
1382 /* Parse a C escape sequence. STRING_PTR points to a variable
1383 containing a pointer to the string to parse. That pointer
1384 should point to the character after the \. That pointer
1385 is updated past the characters we use. The value of the
1386 escape sequence is returned.
1388 A negative value means the sequence \ newline was seen,
1389 which is supposed to be equivalent to nothing at all.
1391 If \ is followed by a null character, we return a negative
1392 value and leave the string pointer pointing at the null character.
1394 If \ is followed by 000, we return 0 and leave the string pointer
1395 after the zeros. A value of 0 does not mean end of string. */
1398 parse_escape (char **string_ptr
)
1401 register int c
= *(*string_ptr
)++;
1402 if (c_parse_backslash (c
, &target_char
))
1414 /* Remember where this escape sequence started, for reporting
1416 char *sequence_start_pos
= *string_ptr
- 1;
1418 c
= *(*string_ptr
)++;
1422 /* XXXCHARSET: What is `delete' in the host character set? */
1425 if (!host_char_to_target (c
, &target_char
))
1426 error ("There is no character corresponding to `Delete' "
1427 "in the target character set `%s'.", host_charset ());
1432 target_char
= parse_escape (string_ptr
);
1435 if (!host_char_to_target (c
, &target_char
))
1436 no_control_char_error (sequence_start_pos
, *string_ptr
);
1439 /* Now target_char is something like `c', and we want to find
1440 its control-character equivalent. */
1441 if (!target_char_to_control_char (target_char
, &target_char
))
1442 no_control_char_error (sequence_start_pos
, *string_ptr
);
1447 /* XXXCHARSET: we need to use isdigit and value-of-digit
1448 methods of the host character set here. */
1459 register int i
= c
- '0';
1460 register int count
= 0;
1464 if (c
>= '0' && c
<= '7')
1478 if (!host_char_to_target (c
, &target_char
))
1480 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1481 " has no equivalent\n" "in the `%s' character set.", c
, c
,
1487 /* Print the character C on STREAM as part of the contents of a literal
1488 string whose delimiter is QUOTER. Note that this routine should only
1489 be call for printing things which are independent of the language
1490 of the program being debugged. */
1493 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1494 void (*do_fprintf
) (struct ui_file
*, const char *, ...),
1495 struct ui_file
*stream
, int quoter
)
1498 c
&= 0xFF; /* Avoid sign bit follies */
1500 if (c
< 0x20 || /* Low control chars */
1501 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1502 (sevenbit_strings
&& c
>= 0x80))
1503 { /* high order bit set */
1507 do_fputs ("\\n", stream
);
1510 do_fputs ("\\b", stream
);
1513 do_fputs ("\\t", stream
);
1516 do_fputs ("\\f", stream
);
1519 do_fputs ("\\r", stream
);
1522 do_fputs ("\\e", stream
);
1525 do_fputs ("\\a", stream
);
1528 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1534 if (c
== '\\' || c
== quoter
)
1535 do_fputs ("\\", stream
);
1536 do_fprintf (stream
, "%c", c
);
1540 /* Print the character C on STREAM as part of the contents of a
1541 literal string whose delimiter is QUOTER. Note that these routines
1542 should only be call for printing things which are independent of
1543 the language of the program being debugged. */
1546 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1549 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1553 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1556 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1560 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1561 struct ui_file
*stream
)
1564 for (i
= 0; i
< n
; i
++)
1565 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1569 /* Number of lines per page or UINT_MAX if paging is disabled. */
1570 static unsigned int lines_per_page
;
1572 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1573 static unsigned int chars_per_line
;
1575 /* Current count of lines printed on this page, chars on this line. */
1576 static unsigned int lines_printed
, chars_printed
;
1578 /* Buffer and start column of buffered text, for doing smarter word-
1579 wrapping. When someone calls wrap_here(), we start buffering output
1580 that comes through fputs_filtered(). If we see a newline, we just
1581 spit it out and forget about the wrap_here(). If we see another
1582 wrap_here(), we spit it out and remember the newer one. If we see
1583 the end of the line, we spit out a newline, the indent, and then
1584 the buffered output. */
1586 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1587 are waiting to be output (they have already been counted in chars_printed).
1588 When wrap_buffer[0] is null, the buffer is empty. */
1589 static char *wrap_buffer
;
1591 /* Pointer in wrap_buffer to the next character to fill. */
1592 static char *wrap_pointer
;
1594 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1596 static char *wrap_indent
;
1598 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1599 is not in effect. */
1600 static int wrap_column
;
1603 /* Inialize the number of lines per page and chars per line. */
1606 init_page_info (void)
1609 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1612 #if defined(__GO32__)
1613 lines_per_page
= ScreenRows ();
1614 chars_per_line
= ScreenCols ();
1618 /* Make sure Readline has initialized its terminal settings. */
1619 rl_reset_terminal (NULL
);
1621 /* Get the screen size from Readline. */
1622 rl_get_screen_size (&rows
, &cols
);
1623 lines_per_page
= rows
;
1624 chars_per_line
= cols
;
1626 /* Readline should have fetched the termcap entry for us. */
1627 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1629 /* The number of lines per page is not mentioned in the
1630 terminal description. This probably means that paging is
1631 not useful (e.g. emacs shell window), so disable paging. */
1632 lines_per_page
= UINT_MAX
;
1635 /* FIXME: Get rid of this junk. */
1636 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1637 SIGWINCH_HANDLER (SIGWINCH
);
1640 /* If the output is not a terminal, don't paginate it. */
1641 if (!ui_file_isatty (gdb_stdout
))
1642 lines_per_page
= UINT_MAX
;
1650 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1653 set_screen_size (void)
1655 int rows
= lines_per_page
;
1656 int cols
= chars_per_line
;
1662 rl_get_screen_size (NULL
, &cols
);
1664 /* Update Readline's idea of the terminal size. */
1665 rl_set_screen_size (rows
, cols
);
1668 /* Reinitialize WRAP_BUFFER according to the current value of
1674 if (chars_per_line
== 0)
1679 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1680 wrap_buffer
[0] = '\0';
1683 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1684 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1689 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1697 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1702 /* Wait, so the user can read what's on the screen. Prompt the user
1703 to continue by pressing RETURN. */
1706 prompt_for_continue (void)
1709 char cont_prompt
[120];
1711 if (annotation_level
> 1)
1712 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1714 strcpy (cont_prompt
,
1715 "---Type <return> to continue, or q <return> to quit---");
1716 if (annotation_level
> 1)
1717 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1719 /* We must do this *before* we call gdb_readline, else it will eventually
1720 call us -- thinking that we're trying to print beyond the end of the
1722 reinitialize_more_filter ();
1725 /* On a real operating system, the user can quit with SIGINT.
1728 'q' is provided on all systems so users don't have to change habits
1729 from system to system, and because telling them what to do in
1730 the prompt is more user-friendly than expecting them to think of
1732 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1733 whereas control-C to gdb_readline will cause the user to get dumped
1735 ignore
= gdb_readline_wrapper (cont_prompt
);
1737 if (annotation_level
> 1)
1738 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1743 while (*p
== ' ' || *p
== '\t')
1748 request_quit (SIGINT
);
1750 async_request_quit (0);
1756 /* Now we have to do this again, so that GDB will know that it doesn't
1757 need to save the ---Type <return>--- line at the top of the screen. */
1758 reinitialize_more_filter ();
1760 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1763 /* Reinitialize filter; ie. tell it to reset to original values. */
1766 reinitialize_more_filter (void)
1772 /* Indicate that if the next sequence of characters overflows the line,
1773 a newline should be inserted here rather than when it hits the end.
1774 If INDENT is non-null, it is a string to be printed to indent the
1775 wrapped part on the next line. INDENT must remain accessible until
1776 the next call to wrap_here() or until a newline is printed through
1779 If the line is already overfull, we immediately print a newline and
1780 the indentation, and disable further wrapping.
1782 If we don't know the width of lines, but we know the page height,
1783 we must not wrap words, but should still keep track of newlines
1784 that were explicitly printed.
1786 INDENT should not contain tabs, as that will mess up the char count
1787 on the next line. FIXME.
1789 This routine is guaranteed to force out any output which has been
1790 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1791 used to force out output from the wrap_buffer. */
1794 wrap_here (char *indent
)
1796 /* This should have been allocated, but be paranoid anyway. */
1798 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1802 *wrap_pointer
= '\0';
1803 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1805 wrap_pointer
= wrap_buffer
;
1806 wrap_buffer
[0] = '\0';
1807 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1811 else if (chars_printed
>= chars_per_line
)
1813 puts_filtered ("\n");
1815 puts_filtered (indent
);
1820 wrap_column
= chars_printed
;
1824 wrap_indent
= indent
;
1828 /* Print input string to gdb_stdout, filtered, with wrap,
1829 arranging strings in columns of n chars. String can be
1830 right or left justified in the column. Never prints
1831 trailing spaces. String should never be longer than
1832 width. FIXME: this could be useful for the EXAMINE
1833 command, which currently doesn't tabulate very well */
1836 puts_filtered_tabular (char *string
, int width
, int right
)
1842 gdb_assert (chars_per_line
> 0);
1843 if (chars_per_line
== UINT_MAX
)
1845 fputs_filtered (string
, gdb_stdout
);
1846 fputs_filtered ("\n", gdb_stdout
);
1850 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1851 fputs_filtered ("\n", gdb_stdout
);
1853 if (width
>= chars_per_line
)
1854 width
= chars_per_line
- 1;
1856 stringlen
= strlen (string
);
1858 if (chars_printed
> 0)
1859 spaces
= width
- (chars_printed
- 1) % width
- 1;
1861 spaces
+= width
- stringlen
;
1863 spacebuf
= alloca (spaces
+ 1);
1864 spacebuf
[spaces
] = '\0';
1866 spacebuf
[spaces
] = ' ';
1868 fputs_filtered (spacebuf
, gdb_stdout
);
1869 fputs_filtered (string
, gdb_stdout
);
1873 /* Ensure that whatever gets printed next, using the filtered output
1874 commands, starts at the beginning of the line. I.E. if there is
1875 any pending output for the current line, flush it and start a new
1876 line. Otherwise do nothing. */
1881 if (chars_printed
> 0)
1883 puts_filtered ("\n");
1888 /* Like fputs but if FILTER is true, pause after every screenful.
1890 Regardless of FILTER can wrap at points other than the final
1891 character of a line.
1893 Unlike fputs, fputs_maybe_filtered does not return a value.
1894 It is OK for LINEBUFFER to be NULL, in which case just don't print
1897 Note that a longjmp to top level may occur in this routine (only if
1898 FILTER is true) (since prompt_for_continue may do so) so this
1899 routine should not be called when cleanups are not in place. */
1902 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1905 const char *lineptr
;
1907 if (linebuffer
== 0)
1910 /* Don't do any filtering if it is disabled. */
1911 if ((stream
!= gdb_stdout
) || !pagination_enabled
1912 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1914 fputs_unfiltered (linebuffer
, stream
);
1918 /* Go through and output each character. Show line extension
1919 when this is necessary; prompt user for new page when this is
1922 lineptr
= linebuffer
;
1925 /* Possible new page. */
1926 if (filter
&& (lines_printed
>= lines_per_page
- 1))
1927 prompt_for_continue ();
1929 while (*lineptr
&& *lineptr
!= '\n')
1931 /* Print a single line. */
1932 if (*lineptr
== '\t')
1935 *wrap_pointer
++ = '\t';
1937 fputc_unfiltered ('\t', stream
);
1938 /* Shifting right by 3 produces the number of tab stops
1939 we have already passed, and then adding one and
1940 shifting left 3 advances to the next tab stop. */
1941 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1947 *wrap_pointer
++ = *lineptr
;
1949 fputc_unfiltered (*lineptr
, stream
);
1954 if (chars_printed
>= chars_per_line
)
1956 unsigned int save_chars
= chars_printed
;
1960 /* If we aren't actually wrapping, don't output newline --
1961 if chars_per_line is right, we probably just overflowed
1962 anyway; if it's wrong, let us keep going. */
1964 fputc_unfiltered ('\n', stream
);
1966 /* Possible new page. */
1967 if (lines_printed
>= lines_per_page
- 1)
1968 prompt_for_continue ();
1970 /* Now output indentation and wrapped string */
1973 fputs_unfiltered (wrap_indent
, stream
);
1974 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1975 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1976 /* FIXME, this strlen is what prevents wrap_indent from
1977 containing tabs. However, if we recurse to print it
1978 and count its chars, we risk trouble if wrap_indent is
1979 longer than (the user settable) chars_per_line.
1980 Note also that this can set chars_printed > chars_per_line
1981 if we are printing a long string. */
1982 chars_printed
= strlen (wrap_indent
)
1983 + (save_chars
- wrap_column
);
1984 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1985 wrap_buffer
[0] = '\0';
1986 wrap_column
= 0; /* And disable fancy wrap */
1991 if (*lineptr
== '\n')
1994 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
1996 fputc_unfiltered ('\n', stream
);
2003 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
2005 fputs_maybe_filtered (linebuffer
, stream
, 1);
2009 putchar_unfiltered (int c
)
2012 ui_file_write (gdb_stdout
, &buf
, 1);
2016 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2017 May return nonlocally. */
2020 putchar_filtered (int c
)
2022 return fputc_filtered (c
, gdb_stdout
);
2026 fputc_unfiltered (int c
, struct ui_file
*stream
)
2029 ui_file_write (stream
, &buf
, 1);
2034 fputc_filtered (int c
, struct ui_file
*stream
)
2040 fputs_filtered (buf
, stream
);
2044 /* puts_debug is like fputs_unfiltered, except it prints special
2045 characters in printable fashion. */
2048 puts_debug (char *prefix
, char *string
, char *suffix
)
2052 /* Print prefix and suffix after each line. */
2053 static int new_line
= 1;
2054 static int return_p
= 0;
2055 static char *prev_prefix
= "";
2056 static char *prev_suffix
= "";
2058 if (*string
== '\n')
2061 /* If the prefix is changing, print the previous suffix, a new line,
2062 and the new prefix. */
2063 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2065 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2066 fputs_unfiltered ("\n", gdb_stdlog
);
2067 fputs_unfiltered (prefix
, gdb_stdlog
);
2070 /* Print prefix if we printed a newline during the previous call. */
2074 fputs_unfiltered (prefix
, gdb_stdlog
);
2077 prev_prefix
= prefix
;
2078 prev_suffix
= suffix
;
2080 /* Output characters in a printable format. */
2081 while ((ch
= *string
++) != '\0')
2087 fputc_unfiltered (ch
, gdb_stdlog
);
2090 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2094 fputs_unfiltered ("\\\\", gdb_stdlog
);
2097 fputs_unfiltered ("\\b", gdb_stdlog
);
2100 fputs_unfiltered ("\\f", gdb_stdlog
);
2104 fputs_unfiltered ("\\n", gdb_stdlog
);
2107 fputs_unfiltered ("\\r", gdb_stdlog
);
2110 fputs_unfiltered ("\\t", gdb_stdlog
);
2113 fputs_unfiltered ("\\v", gdb_stdlog
);
2117 return_p
= ch
== '\r';
2120 /* Print suffix if we printed a newline. */
2123 fputs_unfiltered (suffix
, gdb_stdlog
);
2124 fputs_unfiltered ("\n", gdb_stdlog
);
2129 /* Print a variable number of ARGS using format FORMAT. If this
2130 information is going to put the amount written (since the last call
2131 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2132 call prompt_for_continue to get the users permision to continue.
2134 Unlike fprintf, this function does not return a value.
2136 We implement three variants, vfprintf (takes a vararg list and stream),
2137 fprintf (takes a stream to write on), and printf (the usual).
2139 Note also that a longjmp to top level may occur in this routine
2140 (since prompt_for_continue may do so) so this routine should not be
2141 called when cleanups are not in place. */
2144 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2145 va_list args
, int filter
)
2148 struct cleanup
*old_cleanups
;
2150 xvasprintf (&linebuffer
, format
, args
);
2151 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2152 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2153 do_cleanups (old_cleanups
);
2158 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2160 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2164 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2167 struct cleanup
*old_cleanups
;
2169 xvasprintf (&linebuffer
, format
, args
);
2170 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2171 fputs_unfiltered (linebuffer
, stream
);
2172 do_cleanups (old_cleanups
);
2176 vprintf_filtered (const char *format
, va_list args
)
2178 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2182 vprintf_unfiltered (const char *format
, va_list args
)
2184 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2188 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2191 va_start (args
, format
);
2192 vfprintf_filtered (stream
, format
, args
);
2197 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2200 va_start (args
, format
);
2201 vfprintf_unfiltered (stream
, format
, args
);
2205 /* Like fprintf_filtered, but prints its result indented.
2206 Called as fprintfi_filtered (spaces, stream, format, ...); */
2209 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2213 va_start (args
, format
);
2214 print_spaces_filtered (spaces
, stream
);
2216 vfprintf_filtered (stream
, format
, args
);
2222 printf_filtered (const char *format
, ...)
2225 va_start (args
, format
);
2226 vfprintf_filtered (gdb_stdout
, format
, args
);
2232 printf_unfiltered (const char *format
, ...)
2235 va_start (args
, format
);
2236 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2240 /* Like printf_filtered, but prints it's result indented.
2241 Called as printfi_filtered (spaces, format, ...); */
2244 printfi_filtered (int spaces
, const char *format
, ...)
2247 va_start (args
, format
);
2248 print_spaces_filtered (spaces
, gdb_stdout
);
2249 vfprintf_filtered (gdb_stdout
, format
, args
);
2253 /* Easy -- but watch out!
2255 This routine is *not* a replacement for puts()! puts() appends a newline.
2256 This one doesn't, and had better not! */
2259 puts_filtered (const char *string
)
2261 fputs_filtered (string
, gdb_stdout
);
2265 puts_unfiltered (const char *string
)
2267 fputs_unfiltered (string
, gdb_stdout
);
2270 /* Return a pointer to N spaces and a null. The pointer is good
2271 until the next call to here. */
2276 static char *spaces
= 0;
2277 static int max_spaces
= -1;
2283 spaces
= (char *) xmalloc (n
+ 1);
2284 for (t
= spaces
+ n
; t
!= spaces
;)
2290 return spaces
+ max_spaces
- n
;
2293 /* Print N spaces. */
2295 print_spaces_filtered (int n
, struct ui_file
*stream
)
2297 fputs_filtered (n_spaces (n
), stream
);
2300 /* C++/ObjC demangler stuff. */
2302 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2303 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2304 If the name is not mangled, or the language for the name is unknown, or
2305 demangling is off, the name is printed in its "raw" form. */
2308 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2309 enum language lang
, int arg_mode
)
2315 /* If user wants to see raw output, no problem. */
2318 fputs_filtered (name
, stream
);
2322 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2323 fputs_filtered (demangled
? demangled
: name
, stream
);
2324 if (demangled
!= NULL
)
2332 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2333 differences in whitespace. Returns 0 if they match, non-zero if they
2334 don't (slightly different than strcmp()'s range of return values).
2336 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2337 This "feature" is useful when searching for matching C++ function names
2338 (such as if the user types 'break FOO', where FOO is a mangled C++
2342 strcmp_iw (const char *string1
, const char *string2
)
2344 while ((*string1
!= '\0') && (*string2
!= '\0'))
2346 while (isspace (*string1
))
2350 while (isspace (*string2
))
2354 if (*string1
!= *string2
)
2358 if (*string1
!= '\0')
2364 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2367 /* This is like strcmp except that it ignores whitespace and treats
2368 '(' as the first non-NULL character in terms of ordering. Like
2369 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2370 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2371 according to that ordering.
2373 If a list is sorted according to this function and if you want to
2374 find names in the list that match some fixed NAME according to
2375 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2376 where this function would put NAME.
2378 Here are some examples of why using strcmp to sort is a bad idea:
2382 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2383 we try to do a search for "foo<char*>", strcmp will locate this
2384 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2385 will start looking at strings beginning with "goo", and will never
2386 see the correct match of "foo<char *>".
2388 Parenthesis example:
2390 In practice, this is less like to be an issue, but I'll give it a
2391 shot. Let's assume that '$' is a legitimate character to occur in
2392 symbols. (Which may well even be the case on some systems.) Then
2393 say that the partial symbol table contains "foo$" and "foo(int)".
2394 strcmp will put them in this order, since '$' < '('. Now, if the
2395 user searches for "foo", then strcmp will sort "foo" before "foo$".
2396 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2397 "foo") is false, so it won't proceed to the actual match of
2398 "foo(int)" with "foo". */
2401 strcmp_iw_ordered (const char *string1
, const char *string2
)
2403 while ((*string1
!= '\0') && (*string2
!= '\0'))
2405 while (isspace (*string1
))
2409 while (isspace (*string2
))
2413 if (*string1
!= *string2
)
2417 if (*string1
!= '\0')
2426 /* Characters are non-equal unless they're both '\0'; we want to
2427 make sure we get the comparison right according to our
2428 comparison in the cases where one of them is '\0' or '('. */
2430 if (*string2
== '\0')
2435 if (*string2
== '\0')
2440 if (*string2
== '(')
2443 return *string1
- *string2
;
2447 /* A simple comparison function with opposite semantics to strcmp. */
2450 streq (const char *lhs
, const char *rhs
)
2452 return !strcmp (lhs
, rhs
);
2458 ** Answer whether string_to_compare is a full or partial match to
2459 ** template_string. The partial match must be in sequence starting
2463 subset_compare (char *string_to_compare
, char *template_string
)
2466 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2467 && strlen (string_to_compare
) <= strlen (template_string
))
2470 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2477 static void pagination_on_command (char *arg
, int from_tty
);
2479 pagination_on_command (char *arg
, int from_tty
)
2481 pagination_enabled
= 1;
2484 static void pagination_on_command (char *arg
, int from_tty
);
2486 pagination_off_command (char *arg
, int from_tty
)
2488 pagination_enabled
= 0;
2493 initialize_utils (void)
2495 struct cmd_list_element
*c
;
2497 c
= add_set_cmd ("width", class_support
, var_uinteger
, &chars_per_line
,
2498 "Set number of characters gdb thinks are in a line.",
2500 add_show_from_set (c
, &showlist
);
2501 set_cmd_sfunc (c
, set_width_command
);
2503 c
= add_set_cmd ("height", class_support
, var_uinteger
, &lines_per_page
,
2504 "Set number of lines gdb thinks are in a page.", &setlist
);
2505 add_show_from_set (c
, &showlist
);
2506 set_cmd_sfunc (c
, set_height_command
);
2511 (add_set_cmd ("demangle", class_support
, var_boolean
,
2513 "Set demangling of encoded C++/ObjC names when displaying symbols.",
2514 &setprintlist
), &showprintlist
);
2517 (add_set_cmd ("pagination", class_support
,
2518 var_boolean
, (char *) &pagination_enabled
,
2519 "Set state of pagination.", &setlist
), &showlist
);
2523 add_com ("am", class_support
, pagination_on_command
,
2524 "Enable pagination");
2525 add_com ("sm", class_support
, pagination_off_command
,
2526 "Disable pagination");
2530 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2531 (char *) &sevenbit_strings
,
2532 "Set printing of 8-bit characters in strings as \\nnn.",
2533 &setprintlist
), &showprintlist
);
2536 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2537 (char *) &asm_demangle
,
2538 "Set demangling of C++/ObjC names in disassembly listings.",
2539 &setprintlist
), &showprintlist
);
2542 /* Machine specific function to handle SIGWINCH signal. */
2544 #ifdef SIGWINCH_HANDLER_BODY
2545 SIGWINCH_HANDLER_BODY
2547 /* print routines to handle variable size regs, etc. */
2548 /* temporary storage using circular buffer */
2554 static char buf
[NUMCELLS
][CELLSIZE
];
2555 static int cell
= 0;
2556 if (++cell
>= NUMCELLS
)
2564 return (TARGET_ADDR_BIT
/ 8 * 2);
2568 paddr (CORE_ADDR addr
)
2570 return phex (addr
, TARGET_ADDR_BIT
/ 8);
2574 paddr_nz (CORE_ADDR addr
)
2576 return phex_nz (addr
, TARGET_ADDR_BIT
/ 8);
2580 decimal2str (char *paddr_str
, char *sign
, ULONGEST addr
)
2582 /* steal code from valprint.c:print_decimal(). Should this worry
2583 about the real size of addr as the above does? */
2584 unsigned long temp
[3];
2588 temp
[i
] = addr
% (1000 * 1000 * 1000);
2589 addr
/= (1000 * 1000 * 1000);
2592 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2596 sprintf (paddr_str
, "%s%lu", sign
, temp
[0]);
2599 sprintf (paddr_str
, "%s%lu%09lu", sign
, temp
[1], temp
[0]);
2602 sprintf (paddr_str
, "%s%lu%09lu%09lu", sign
, temp
[2], temp
[1], temp
[0]);
2605 internal_error (__FILE__
, __LINE__
,
2606 "failed internal consistency check");
2611 paddr_u (CORE_ADDR addr
)
2613 char *paddr_str
= get_cell ();
2614 decimal2str (paddr_str
, "", addr
);
2619 paddr_d (LONGEST addr
)
2621 char *paddr_str
= get_cell ();
2623 decimal2str (paddr_str
, "-", -addr
);
2625 decimal2str (paddr_str
, "", addr
);
2629 /* eliminate warning from compiler on 32-bit systems */
2630 static int thirty_two
= 32;
2633 phex (ULONGEST l
, int sizeof_l
)
2640 sprintf (str
, "%08lx%08lx",
2641 (unsigned long) (l
>> thirty_two
),
2642 (unsigned long) (l
& 0xffffffff));
2646 sprintf (str
, "%08lx", (unsigned long) l
);
2650 sprintf (str
, "%04x", (unsigned short) (l
& 0xffff));
2653 str
= phex (l
, sizeof (l
));
2660 phex_nz (ULONGEST l
, int sizeof_l
)
2667 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2670 sprintf (str
, "%lx", (unsigned long) (l
& 0xffffffff));
2672 sprintf (str
, "%lx%08lx", high
, (unsigned long) (l
& 0xffffffff));
2677 sprintf (str
, "%lx", (unsigned long) l
);
2681 sprintf (str
, "%x", (unsigned short) (l
& 0xffff));
2684 str
= phex_nz (l
, sizeof (l
));
2691 /* Convert a CORE_ADDR into a string. */
2693 core_addr_to_string (const CORE_ADDR addr
)
2695 char *str
= get_cell ();
2697 strcat (str
, phex (addr
, sizeof (addr
)));
2702 core_addr_to_string_nz (const CORE_ADDR addr
)
2704 char *str
= get_cell ();
2706 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2710 /* Convert a string back into a CORE_ADDR. */
2712 string_to_core_addr (const char *my_string
)
2715 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2717 /* Assume that it is in decimal. */
2719 for (i
= 2; my_string
[i
] != '\0'; i
++)
2721 if (isdigit (my_string
[i
]))
2722 addr
= (my_string
[i
] - '0') + (addr
* 16);
2723 else if (isxdigit (my_string
[i
]))
2724 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2726 internal_error (__FILE__
, __LINE__
, "invalid hex");
2731 /* Assume that it is in decimal. */
2733 for (i
= 0; my_string
[i
] != '\0'; i
++)
2735 if (isdigit (my_string
[i
]))
2736 addr
= (my_string
[i
] - '0') + (addr
* 10);
2738 internal_error (__FILE__
, __LINE__
, "invalid decimal");
2745 gdb_realpath (const char *filename
)
2747 /* Method 1: The system has a compile time upper bound on a filename
2748 path. Use that and realpath() to canonicalize the name. This is
2749 the most common case. Note that, if there isn't a compile time
2750 upper bound, you want to avoid realpath() at all costs. */
2751 #if defined(HAVE_REALPATH)
2753 # if defined (PATH_MAX)
2755 # define USE_REALPATH
2756 # elif defined (MAXPATHLEN)
2757 char buf
[MAXPATHLEN
];
2758 # define USE_REALPATH
2760 # if defined (USE_REALPATH)
2761 const char *rp
= realpath (filename
, buf
);
2764 return xstrdup (rp
);
2767 #endif /* HAVE_REALPATH */
2769 /* Method 2: The host system (i.e., GNU) has the function
2770 canonicalize_file_name() which malloc's a chunk of memory and
2771 returns that, use that. */
2772 #if defined(HAVE_CANONICALIZE_FILE_NAME)
2774 char *rp
= canonicalize_file_name (filename
);
2776 return xstrdup (filename
);
2782 /* FIXME: cagney/2002-11-13:
2784 Method 2a: Use realpath() with a NULL buffer. Some systems, due
2785 to the problems described in in method 3, have modified their
2786 realpath() implementation so that it will allocate a buffer when
2787 NULL is passed in. Before this can be used, though, some sort of
2788 configure time test would need to be added. Otherwize the code
2789 will likely core dump. */
2791 /* Method 3: Now we're getting desperate! The system doesn't have a
2792 compile time buffer size and no alternative function. Query the
2793 OS, using pathconf(), for the buffer limit. Care is needed
2794 though, some systems do not limit PATH_MAX (return -1 for
2795 pathconf()) making it impossible to pass a correctly sized buffer
2796 to realpath() (it could always overflow). On those systems, we
2798 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2800 /* Find out the max path size. */
2801 long path_max
= pathconf ("/", _PC_PATH_MAX
);
2804 /* PATH_MAX is bounded. */
2805 char *buf
= alloca (path_max
);
2806 char *rp
= realpath (filename
, buf
);
2807 return xstrdup (rp
? rp
: filename
);
2812 /* This system is a lost cause, just dup the buffer. */
2813 return xstrdup (filename
);
2816 /* Return a copy of FILENAME, with its directory prefix canonicalized
2820 xfullpath (const char *filename
)
2822 const char *base_name
= lbasename (filename
);
2827 /* Extract the basename of filename, and return immediately
2828 a copy of filename if it does not contain any directory prefix. */
2829 if (base_name
== filename
)
2830 return xstrdup (filename
);
2832 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
2833 /* Allocate enough space to store the dir_name + plus one extra
2834 character sometimes needed under Windows (see below), and
2835 then the closing \000 character */
2836 strncpy (dir_name
, filename
, base_name
- filename
);
2837 dir_name
[base_name
- filename
] = '\000';
2839 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2840 /* We need to be careful when filename is of the form 'd:foo', which
2841 is equivalent of d:./foo, which is totally different from d:/foo. */
2842 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
2845 dir_name
[3] = '\000';
2849 /* Canonicalize the directory prefix, and build the resulting
2850 filename. If the dirname realpath already contains an ending
2851 directory separator, avoid doubling it. */
2852 real_path
= gdb_realpath (dir_name
);
2853 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
2854 result
= concat (real_path
, base_name
, NULL
);
2856 result
= concat (real_path
, SLASH_STRING
, base_name
, NULL
);
2863 /* This is the 32-bit CRC function used by the GNU separate debug
2864 facility. An executable may contain a section named
2865 .gnu_debuglink, which holds the name of a separate executable file
2866 containing its debug info, and a checksum of that file's contents,
2867 computed using this function. */
2869 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
2871 static const unsigned long crc32_table
[256] = {
2872 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
2873 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
2874 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
2875 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
2876 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
2877 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
2878 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
2879 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
2880 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
2881 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
2882 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
2883 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
2884 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
2885 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
2886 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
2887 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
2888 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
2889 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
2890 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
2891 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
2892 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
2893 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
2894 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
2895 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
2896 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
2897 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
2898 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
2899 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
2900 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
2901 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
2902 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
2903 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
2904 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
2905 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
2906 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
2907 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
2908 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
2909 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
2910 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
2911 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
2912 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
2913 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
2914 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
2915 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
2916 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
2917 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
2918 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
2919 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
2920 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
2921 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
2922 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
2927 crc
= ~crc
& 0xffffffff;
2928 for (end
= buf
+ len
; buf
< end
; ++buf
)
2929 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
2930 return ~crc
& 0xffffffff;;