Import gdb 7.3 into vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / utils.c
CommitLineData
5796c8dc
SS
1/* General utility routines for GDB, the GNU debugger.
2
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,
c50c785c 5 2009, 2010, 2011 Free Software Foundation, Inc.
5796c8dc
SS
6
7 This file is part of GDB.
8
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.
13
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.
18
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/>. */
21
22#include "defs.h"
23#include "gdb_assert.h"
24#include <ctype.h>
25#include "gdb_string.h"
26#include "event-top.h"
27#include "exceptions.h"
28#include "gdbthread.h"
cf7f2e2d
JM
29#ifdef HAVE_SYS_RESOURCE_H
30#include <sys/resource.h>
31#endif /* HAVE_SYS_RESOURCE_H */
5796c8dc
SS
32
33#ifdef TUI
34#include "tui/tui.h" /* For tui_get_command_dimension. */
35#endif
36
37#ifdef __GO32__
38#include <pc.h>
39#endif
40
c50c785c 41/* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
5796c8dc
SS
42#ifdef reg
43#undef reg
44#endif
45
46#include <signal.h>
47#include "gdbcmd.h"
48#include "serial.h"
49#include "bfd.h"
50#include "target.h"
51#include "demangle.h"
52#include "expression.h"
53#include "language.h"
54#include "charset.h"
55#include "annotate.h"
56#include "filenames.h"
57#include "symfile.h"
58#include "gdb_obstack.h"
59#include "gdbcore.h"
60#include "top.h"
cf7f2e2d 61#include "main.h"
5796c8dc
SS
62
63#include "inferior.h" /* for signed_pointer_to_address */
64
65#include <sys/param.h> /* For MAXPATHLEN */
66
67#include "gdb_curses.h"
68
69#include "readline/readline.h"
70
71#include <sys/time.h>
72#include <time.h>
73
74#include "gdb_usleep.h"
cf7f2e2d 75#include "interps.h"
c50c785c 76#include "gdb_regex.h"
5796c8dc
SS
77
78#if !HAVE_DECL_MALLOC
79extern PTR malloc (); /* ARI: PTR */
80#endif
81#if !HAVE_DECL_REALLOC
82extern PTR realloc (); /* ARI: PTR */
83#endif
84#if !HAVE_DECL_FREE
85extern void free ();
86#endif
87
88/* readline defines this. */
89#undef savestring
90
91void (*deprecated_error_begin_hook) (void);
92
93/* Prototypes for local functions */
94
95static void vfprintf_maybe_filtered (struct ui_file *, const char *,
cf7f2e2d 96 va_list, int) ATTRIBUTE_PRINTF (2, 0);
5796c8dc
SS
97
98static void fputs_maybe_filtered (const char *, struct ui_file *, int);
99
100static void do_my_cleanups (struct cleanup **, struct cleanup *);
101
102static void prompt_for_continue (void);
103
104static void set_screen_size (void);
105static void set_width (void);
106
107/* A flag indicating whether to timestamp debugging messages. */
108
109static int debug_timestamp = 0;
110
111/* Chain of cleanup actions established with make_cleanup,
112 to be executed if an error happens. */
113
114static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
115static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
116
c50c785c 117/* Nonzero if we have job control. */
5796c8dc
SS
118
119int job_control;
120
121/* Nonzero means a quit has been requested. */
122
123int quit_flag;
124
125/* Nonzero means quit immediately if Control-C is typed now, rather
126 than waiting until QUIT is executed. Be careful in setting this;
127 code which executes with immediate_quit set has to be very careful
128 about being able to deal with being interrupted at any time. It is
129 almost always better to use QUIT; the only exception I can think of
130 is being able to quit out of a system call (using EINTR loses if
131 the SIGINT happens between the previous QUIT and the system call).
132 To immediately quit in the case in which a SIGINT happens between
133 the previous QUIT and setting immediate_quit (desirable anytime we
134 expect to block), call QUIT after setting immediate_quit. */
135
136int immediate_quit;
137
138/* Nonzero means that encoded C++/ObjC names should be printed out in their
139 C++/ObjC form rather than raw. */
140
141int demangle = 1;
142static void
143show_demangle (struct ui_file *file, int from_tty,
144 struct cmd_list_element *c, const char *value)
145{
c50c785c
JM
146 fprintf_filtered (file,
147 _("Demangling of encoded C++/ObjC names "
148 "when displaying symbols is %s.\n"),
5796c8dc
SS
149 value);
150}
151
152/* Nonzero means that encoded C++/ObjC names should be printed out in their
153 C++/ObjC form even in assembler language displays. If this is set, but
154 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
155
156int asm_demangle = 0;
157static void
158show_asm_demangle (struct ui_file *file, int from_tty,
159 struct cmd_list_element *c, const char *value)
160{
c50c785c
JM
161 fprintf_filtered (file,
162 _("Demangling of C++/ObjC names in "
163 "disassembly listings is %s.\n"),
5796c8dc
SS
164 value);
165}
166
167/* Nonzero means that strings with character values >0x7F should be printed
168 as octal escapes. Zero means just print the value (e.g. it's an
169 international character, and the terminal or window can cope.) */
170
171int sevenbit_strings = 0;
172static void
173show_sevenbit_strings (struct ui_file *file, int from_tty,
174 struct cmd_list_element *c, const char *value)
175{
c50c785c
JM
176 fprintf_filtered (file, _("Printing of 8-bit characters "
177 "in strings as \\nnn is %s.\n"),
5796c8dc
SS
178 value);
179}
180
181/* String to be printed before error messages, if any. */
182
183char *error_pre_print;
184
185/* String to be printed before quit messages, if any. */
186
187char *quit_pre_print;
188
189/* String to be printed before warning messages, if any. */
190
191char *warning_pre_print = "\nwarning: ";
192
193int pagination_enabled = 1;
194static void
195show_pagination_enabled (struct ui_file *file, int from_tty,
196 struct cmd_list_element *c, const char *value)
197{
198 fprintf_filtered (file, _("State of pagination is %s.\n"), value);
199}
200
201\f
202
203/* Add a new cleanup to the cleanup_chain,
204 and return the previous chain pointer
205 to be passed later to do_cleanups or discard_cleanups.
206 Args are FUNCTION to clean up with, and ARG to pass to it. */
207
208struct cleanup *
209make_cleanup (make_cleanup_ftype *function, void *arg)
210{
211 return make_my_cleanup (&cleanup_chain, function, arg);
212}
213
214struct cleanup *
215make_cleanup_dtor (make_cleanup_ftype *function, void *arg,
216 void (*dtor) (void *))
217{
218 return make_my_cleanup2 (&cleanup_chain,
219 function, arg, dtor);
220}
221
222struct cleanup *
223make_final_cleanup (make_cleanup_ftype *function, void *arg)
224{
225 return make_my_cleanup (&final_cleanup_chain, function, arg);
226}
227
228static void
229do_freeargv (void *arg)
230{
231 freeargv ((char **) arg);
232}
233
234struct cleanup *
235make_cleanup_freeargv (char **arg)
236{
237 return make_my_cleanup (&cleanup_chain, do_freeargv, arg);
238}
239
240static void
241do_bfd_close_cleanup (void *arg)
242{
243 bfd_close (arg);
244}
245
246struct cleanup *
247make_cleanup_bfd_close (bfd *abfd)
248{
249 return make_cleanup (do_bfd_close_cleanup, abfd);
250}
251
252static void
253do_close_cleanup (void *arg)
254{
255 int *fd = arg;
cf7f2e2d 256
5796c8dc
SS
257 close (*fd);
258}
259
260struct cleanup *
261make_cleanup_close (int fd)
262{
263 int *saved_fd = xmalloc (sizeof (fd));
cf7f2e2d 264
5796c8dc
SS
265 *saved_fd = fd;
266 return make_cleanup_dtor (do_close_cleanup, saved_fd, xfree);
267}
268
269/* Helper function which does the work for make_cleanup_fclose. */
270
271static void
272do_fclose_cleanup (void *arg)
273{
274 FILE *file = arg;
cf7f2e2d
JM
275
276 fclose (file);
5796c8dc
SS
277}
278
279/* Return a new cleanup that closes FILE. */
280
281struct cleanup *
282make_cleanup_fclose (FILE *file)
283{
284 return make_cleanup (do_fclose_cleanup, file);
285}
286
287/* Helper function which does the work for make_cleanup_obstack_free. */
288
289static void
290do_obstack_free (void *arg)
291{
292 struct obstack *ob = arg;
cf7f2e2d 293
5796c8dc
SS
294 obstack_free (ob, NULL);
295}
296
297/* Return a new cleanup that frees OBSTACK. */
298
299struct cleanup *
300make_cleanup_obstack_free (struct obstack *obstack)
301{
302 return make_cleanup (do_obstack_free, obstack);
303}
304
305static void
306do_ui_file_delete (void *arg)
307{
308 ui_file_delete (arg);
309}
310
311struct cleanup *
312make_cleanup_ui_file_delete (struct ui_file *arg)
313{
314 return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg);
315}
316
c50c785c
JM
317/* Helper function for make_cleanup_ui_out_redirect_pop. */
318
319static void
320do_ui_out_redirect_pop (void *arg)
321{
322 struct ui_out *uiout = arg;
323
324 if (ui_out_redirect (uiout, NULL) < 0)
325 warning (_("Cannot restore redirection of the current output protocol"));
326}
327
328/* Return a new cleanup that pops the last redirection by ui_out_redirect
329 with NULL parameter. */
330
331struct cleanup *
332make_cleanup_ui_out_redirect_pop (struct ui_out *uiout)
333{
334 return make_my_cleanup (&cleanup_chain, do_ui_out_redirect_pop, uiout);
335}
336
5796c8dc
SS
337static void
338do_free_section_addr_info (void *arg)
339{
340 free_section_addr_info (arg);
341}
342
343struct cleanup *
344make_cleanup_free_section_addr_info (struct section_addr_info *addrs)
345{
346 return make_my_cleanup (&cleanup_chain, do_free_section_addr_info, addrs);
347}
348
349struct restore_integer_closure
350{
351 int *variable;
352 int value;
353};
354
355static void
356restore_integer (void *p)
357{
358 struct restore_integer_closure *closure = p;
cf7f2e2d 359
5796c8dc
SS
360 *(closure->variable) = closure->value;
361}
362
c50c785c
JM
363/* Remember the current value of *VARIABLE and make it restored when
364 the cleanup is run. */
cf7f2e2d 365
5796c8dc
SS
366struct cleanup *
367make_cleanup_restore_integer (int *variable)
368{
369 struct restore_integer_closure *c =
370 xmalloc (sizeof (struct restore_integer_closure));
cf7f2e2d 371
5796c8dc
SS
372 c->variable = variable;
373 c->value = *variable;
374
375 return make_my_cleanup2 (&cleanup_chain, restore_integer, (void *)c,
376 xfree);
377}
378
c50c785c
JM
379/* Remember the current value of *VARIABLE and make it restored when
380 the cleanup is run. */
cf7f2e2d
JM
381
382struct cleanup *
383make_cleanup_restore_uinteger (unsigned int *variable)
384{
385 return make_cleanup_restore_integer ((int *) variable);
386}
387
c50c785c
JM
388/* Helper for make_cleanup_unpush_target. */
389
390static void
391do_unpush_target (void *arg)
392{
393 struct target_ops *ops = arg;
394
395 unpush_target (ops);
396}
397
398/* Return a new cleanup that unpushes OPS. */
399
400struct cleanup *
401make_cleanup_unpush_target (struct target_ops *ops)
402{
403 return make_my_cleanup (&cleanup_chain, do_unpush_target, ops);
404}
405
cf7f2e2d
JM
406struct restore_ui_file_closure
407{
408 struct ui_file **variable;
409 struct ui_file *value;
410};
411
412static void
413do_restore_ui_file (void *p)
414{
415 struct restore_ui_file_closure *closure = p;
416
417 *(closure->variable) = closure->value;
418}
419
420/* Remember the current value of *VARIABLE and make it restored when
421 the cleanup is run. */
422
423struct cleanup *
424make_cleanup_restore_ui_file (struct ui_file **variable)
425{
426 struct restore_ui_file_closure *c = XNEW (struct restore_ui_file_closure);
427
428 c->variable = variable;
429 c->value = *variable;
430
431 return make_cleanup_dtor (do_restore_ui_file, (void *) c, xfree);
432}
433
5796c8dc
SS
434struct cleanup *
435make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function,
436 void *arg, void (*free_arg) (void *))
437{
438 struct cleanup *new
439 = (struct cleanup *) xmalloc (sizeof (struct cleanup));
440 struct cleanup *old_chain = *pmy_chain;
441
442 new->next = *pmy_chain;
443 new->function = function;
444 new->free_arg = free_arg;
445 new->arg = arg;
446 *pmy_chain = new;
447
448 return old_chain;
449}
450
451struct cleanup *
452make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
453 void *arg)
454{
455 return make_my_cleanup2 (pmy_chain, function, arg, NULL);
456}
457
458/* Discard cleanups and do the actions they describe
459 until we get back to the point OLD_CHAIN in the cleanup_chain. */
460
461void
462do_cleanups (struct cleanup *old_chain)
463{
464 do_my_cleanups (&cleanup_chain, old_chain);
465}
466
467void
468do_final_cleanups (struct cleanup *old_chain)
469{
470 do_my_cleanups (&final_cleanup_chain, old_chain);
471}
472
473static void
474do_my_cleanups (struct cleanup **pmy_chain,
475 struct cleanup *old_chain)
476{
477 struct cleanup *ptr;
cf7f2e2d 478
5796c8dc
SS
479 while ((ptr = *pmy_chain) != old_chain)
480 {
c50c785c 481 *pmy_chain = ptr->next; /* Do this first in case of recursion. */
5796c8dc
SS
482 (*ptr->function) (ptr->arg);
483 if (ptr->free_arg)
484 (*ptr->free_arg) (ptr->arg);
485 xfree (ptr);
486 }
487}
488
489/* Discard cleanups, not doing the actions they describe,
490 until we get back to the point OLD_CHAIN in the cleanup_chain. */
491
492void
493discard_cleanups (struct cleanup *old_chain)
494{
495 discard_my_cleanups (&cleanup_chain, old_chain);
496}
497
498void
499discard_final_cleanups (struct cleanup *old_chain)
500{
501 discard_my_cleanups (&final_cleanup_chain, old_chain);
502}
503
504void
505discard_my_cleanups (struct cleanup **pmy_chain,
506 struct cleanup *old_chain)
507{
508 struct cleanup *ptr;
cf7f2e2d 509
5796c8dc
SS
510 while ((ptr = *pmy_chain) != old_chain)
511 {
512 *pmy_chain = ptr->next;
513 if (ptr->free_arg)
514 (*ptr->free_arg) (ptr->arg);
515 xfree (ptr);
516 }
517}
518
519/* Set the cleanup_chain to 0, and return the old cleanup chain. */
520struct cleanup *
521save_cleanups (void)
522{
523 return save_my_cleanups (&cleanup_chain);
524}
525
526struct cleanup *
527save_final_cleanups (void)
528{
529 return save_my_cleanups (&final_cleanup_chain);
530}
531
532struct cleanup *
533save_my_cleanups (struct cleanup **pmy_chain)
534{
535 struct cleanup *old_chain = *pmy_chain;
536
537 *pmy_chain = 0;
538 return old_chain;
539}
540
541/* Restore the cleanup chain from a previously saved chain. */
542void
543restore_cleanups (struct cleanup *chain)
544{
545 restore_my_cleanups (&cleanup_chain, chain);
546}
547
548void
549restore_final_cleanups (struct cleanup *chain)
550{
551 restore_my_cleanups (&final_cleanup_chain, chain);
552}
553
554void
555restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain)
556{
557 *pmy_chain = chain;
558}
559
560/* This function is useful for cleanups.
561 Do
562
563 foo = xmalloc (...);
564 old_chain = make_cleanup (free_current_contents, &foo);
565
566 to arrange to free the object thus allocated. */
567
568void
569free_current_contents (void *ptr)
570{
571 void **location = ptr;
cf7f2e2d 572
5796c8dc
SS
573 if (location == NULL)
574 internal_error (__FILE__, __LINE__,
575 _("free_current_contents: NULL pointer"));
576 if (*location != NULL)
577 {
578 xfree (*location);
579 *location = NULL;
580 }
581}
582
583/* Provide a known function that does nothing, to use as a base for
584 for a possibly long chain of cleanups. This is useful where we
585 use the cleanup chain for handling normal cleanups as well as dealing
586 with cleanups that need to be done as a result of a call to error().
587 In such cases, we may not be certain where the first cleanup is, unless
c50c785c 588 we have a do-nothing one to always use as the base. */
5796c8dc
SS
589
590void
591null_cleanup (void *arg)
592{
593}
594
cf7f2e2d
JM
595/* If nonzero, display time usage both at startup and for each command. */
596
597static int display_time;
598
599/* If nonzero, display space usage both at startup and for each command. */
600
601static int display_space;
602
603/* Records a run time and space usage to be used as a base for
604 reporting elapsed time or change in space. In addition,
605 the msg_type field indicates whether the saved time is from the
606 beginning of GDB execution (0) or the beginning of an individual
607 command execution (1). */
608struct cmd_stats
609{
610 int msg_type;
611 long start_time;
612 long start_space;
613};
614
615/* Set whether to display time statistics to NEW_VALUE (non-zero
616 means true). */
617void
618set_display_time (int new_value)
619{
620 display_time = new_value;
621}
622
623/* Set whether to display space statistics to NEW_VALUE (non-zero
624 means true). */
625void
626set_display_space (int new_value)
627{
628 display_space = new_value;
629}
630
631/* As indicated by display_time and display_space, report GDB's elapsed time
632 and space usage from the base time and space provided in ARG, which
c50c785c
JM
633 must be a pointer to a struct cmd_stat. This function is intended
634 to be called as a cleanup. */
cf7f2e2d
JM
635static void
636report_command_stats (void *arg)
637{
638 struct cmd_stats *start_stats = (struct cmd_stats *) arg;
639 int msg_type = start_stats->msg_type;
640
641 if (display_time)
642 {
643 long cmd_time = get_run_time () - start_stats->start_time;
644
645 printf_unfiltered (msg_type == 0
646 ? _("Startup time: %ld.%06ld\n")
647 : _("Command execution time: %ld.%06ld\n"),
648 cmd_time / 1000000, cmd_time % 1000000);
649 }
650
651 if (display_space)
652 {
653#ifdef HAVE_SBRK
654 char *lim = (char *) sbrk (0);
655
656 long space_now = lim - lim_at_start;
657 long space_diff = space_now - start_stats->start_space;
658
659 printf_unfiltered (msg_type == 0
c50c785c
JM
660 ? _("Space used: %ld (%s%ld during startup)\n")
661 : _("Space used: %ld (%s%ld for this command)\n"),
cf7f2e2d 662 space_now,
c50c785c 663 (space_diff >= 0 ? "+" : ""),
cf7f2e2d
JM
664 space_diff);
665#endif
666 }
667}
668
669/* Create a cleanup that reports time and space used since its
670 creation. Precise messages depend on MSG_TYPE:
671 0: Initial time/space
672 1: Individual command time/space. */
673struct cleanup *
674make_command_stats_cleanup (int msg_type)
675{
676 struct cmd_stats *new_stat = XMALLOC (struct cmd_stats);
677
678#ifdef HAVE_SBRK
679 char *lim = (char *) sbrk (0);
680 new_stat->start_space = lim - lim_at_start;
681#endif
682
683 new_stat->msg_type = msg_type;
684 new_stat->start_time = get_run_time ();
685
686 return make_cleanup_dtor (report_command_stats, new_stat, xfree);
687}
688
5796c8dc
SS
689/* Continuations are implemented as cleanups internally. Inherit from
690 cleanups. */
691struct continuation
692{
693 struct cleanup base;
694};
695
696/* Add a continuation to the continuation list of THREAD. The new
697 continuation will be added at the front. */
698void
699add_continuation (struct thread_info *thread,
700 void (*continuation_hook) (void *), void *args,
701 void (*continuation_free_args) (void *))
702{
703 struct cleanup *as_cleanup = &thread->continuations->base;
704 make_cleanup_ftype *continuation_hook_fn = continuation_hook;
705
706 make_my_cleanup2 (&as_cleanup,
707 continuation_hook_fn,
708 args,
709 continuation_free_args);
710
711 thread->continuations = (struct continuation *) as_cleanup;
712}
713
714/* Add a continuation to the continuation list of INFERIOR. The new
715 continuation will be added at the front. */
716
717void
718add_inferior_continuation (void (*continuation_hook) (void *), void *args,
719 void (*continuation_free_args) (void *))
720{
721 struct inferior *inf = current_inferior ();
722 struct cleanup *as_cleanup = &inf->continuations->base;
723 make_cleanup_ftype *continuation_hook_fn = continuation_hook;
724
725 make_my_cleanup2 (&as_cleanup,
726 continuation_hook_fn,
727 args,
728 continuation_free_args);
729
730 inf->continuations = (struct continuation *) as_cleanup;
731}
732
733/* Do all continuations of the current inferior. */
734
735void
736do_all_inferior_continuations (void)
737{
5796c8dc
SS
738 struct cleanup *as_cleanup;
739 struct inferior *inf = current_inferior ();
740
741 if (inf->continuations == NULL)
742 return;
743
744 /* Copy the list header into another pointer, and set the global
745 list header to null, so that the global list can change as a side
746 effect of invoking the continuations and the processing of the
747 preexisting continuations will not be affected. */
748
749 as_cleanup = &inf->continuations->base;
750 inf->continuations = NULL;
751
752 /* Work now on the list we have set aside. */
753 do_my_cleanups (&as_cleanup, NULL);
754}
755
756/* Get rid of all the inferior-wide continuations of INF. */
757
758void
759discard_all_inferior_continuations (struct inferior *inf)
760{
761 struct cleanup *continuation_ptr = &inf->continuations->base;
cf7f2e2d 762
5796c8dc
SS
763 discard_my_cleanups (&continuation_ptr, NULL);
764 inf->continuations = NULL;
765}
766
767static void
768restore_thread_cleanup (void *arg)
769{
770 ptid_t *ptid_p = arg;
cf7f2e2d 771
5796c8dc
SS
772 switch_to_thread (*ptid_p);
773}
774
775/* Walk down the continuation list of PTID, and execute all the
776 continuations. There is a problem though. In some cases new
777 continuations may be added while we are in the middle of this loop.
778 If this happens they will be added in the front, and done before we
779 have a chance of exhausting those that were already there. We need
780 to then save the beginning of the list in a pointer and do the
781 continuations from there on, instead of using the global beginning
782 of list as our iteration pointer. */
783static void
784do_all_continuations_ptid (ptid_t ptid,
785 struct continuation **continuations_p)
786{
787 struct cleanup *old_chain;
788 ptid_t current_thread;
789 struct cleanup *as_cleanup;
790
791 if (*continuations_p == NULL)
792 return;
793
794 current_thread = inferior_ptid;
795
796 /* Restore selected thread on exit. Don't try to restore the frame
797 as well, because:
798
799 - When running continuations, the selected frame is always #0.
800
801 - The continuations may trigger symbol file loads, which may
802 change the frame layout (frame ids change), which would trigger
803 a warning if we used make_cleanup_restore_current_thread. */
804
805 old_chain = make_cleanup (restore_thread_cleanup, &current_thread);
806
807 /* Let the continuation see this thread as selected. */
808 switch_to_thread (ptid);
809
810 /* Copy the list header into another pointer, and set the global
811 list header to null, so that the global list can change as a side
812 effect of invoking the continuations and the processing of the
813 preexisting continuations will not be affected. */
814
815 as_cleanup = &(*continuations_p)->base;
816 *continuations_p = NULL;
817
818 /* Work now on the list we have set aside. */
819 do_my_cleanups (&as_cleanup, NULL);
820
821 do_cleanups (old_chain);
822}
823
824/* Callback for iterate over threads. */
825static int
826do_all_continuations_thread_callback (struct thread_info *thread, void *data)
827{
828 do_all_continuations_ptid (thread->ptid, &thread->continuations);
829 return 0;
830}
831
832/* Do all continuations of thread THREAD. */
833void
834do_all_continuations_thread (struct thread_info *thread)
835{
836 do_all_continuations_thread_callback (thread, NULL);
837}
838
839/* Do all continuations of all threads. */
840void
841do_all_continuations (void)
842{
843 iterate_over_threads (do_all_continuations_thread_callback, NULL);
844}
845
846/* Callback for iterate over threads. */
847static int
848discard_all_continuations_thread_callback (struct thread_info *thread,
849 void *data)
850{
851 struct cleanup *continuation_ptr = &thread->continuations->base;
cf7f2e2d 852
5796c8dc
SS
853 discard_my_cleanups (&continuation_ptr, NULL);
854 thread->continuations = NULL;
855 return 0;
856}
857
858/* Get rid of all the continuations of THREAD. */
859void
860discard_all_continuations_thread (struct thread_info *thread)
861{
862 discard_all_continuations_thread_callback (thread, NULL);
863}
864
865/* Get rid of all the continuations of all threads. */
866void
867discard_all_continuations (void)
868{
869 iterate_over_threads (discard_all_continuations_thread_callback, NULL);
870}
871
872
873/* Add a continuation to the intermediate continuation list of THREAD.
874 The new continuation will be added at the front. */
875void
876add_intermediate_continuation (struct thread_info *thread,
877 void (*continuation_hook)
878 (void *), void *args,
879 void (*continuation_free_args) (void *))
880{
881 struct cleanup *as_cleanup = &thread->intermediate_continuations->base;
882 make_cleanup_ftype *continuation_hook_fn = continuation_hook;
883
884 make_my_cleanup2 (&as_cleanup,
885 continuation_hook_fn,
886 args,
887 continuation_free_args);
888
889 thread->intermediate_continuations = (struct continuation *) as_cleanup;
890}
891
892/* Walk down the cmd_continuation list, and execute all the
c50c785c 893 continuations. There is a problem though. In some cases new
5796c8dc 894 continuations may be added while we are in the middle of this
c50c785c 895 loop. If this happens they will be added in the front, and done
5796c8dc 896 before we have a chance of exhausting those that were already
c50c785c 897 there. We need to then save the beginning of the list in a pointer
5796c8dc 898 and do the continuations from there on, instead of using the
c50c785c 899 global beginning of list as our iteration pointer. */
5796c8dc
SS
900static int
901do_all_intermediate_continuations_thread_callback (struct thread_info *thread,
902 void *data)
903{
904 do_all_continuations_ptid (thread->ptid,
905 &thread->intermediate_continuations);
906 return 0;
907}
908
909/* Do all intermediate continuations of thread THREAD. */
910void
911do_all_intermediate_continuations_thread (struct thread_info *thread)
912{
913 do_all_intermediate_continuations_thread_callback (thread, NULL);
914}
915
916/* Do all intermediate continuations of all threads. */
917void
918do_all_intermediate_continuations (void)
919{
c50c785c
JM
920 iterate_over_threads (do_all_intermediate_continuations_thread_callback,
921 NULL);
5796c8dc
SS
922}
923
924/* Callback for iterate over threads. */
925static int
926discard_all_intermediate_continuations_thread_callback (struct thread_info *thread,
927 void *data)
928{
929 struct cleanup *continuation_ptr = &thread->intermediate_continuations->base;
cf7f2e2d 930
5796c8dc
SS
931 discard_my_cleanups (&continuation_ptr, NULL);
932 thread->intermediate_continuations = NULL;
933 return 0;
934}
935
936/* Get rid of all the intermediate continuations of THREAD. */
937void
938discard_all_intermediate_continuations_thread (struct thread_info *thread)
939{
940 discard_all_intermediate_continuations_thread_callback (thread, NULL);
941}
942
943/* Get rid of all the intermediate continuations of all threads. */
944void
945discard_all_intermediate_continuations (void)
946{
c50c785c
JM
947 iterate_over_threads (discard_all_intermediate_continuations_thread_callback,
948 NULL);
5796c8dc
SS
949}
950\f
951
952
953/* Print a warning message. The first argument STRING is the warning
954 message, used as an fprintf format string, the second is the
955 va_list of arguments for that string. A warning is unfiltered (not
956 paginated) so that the user does not need to page through each
957 screen full of warnings when there are lots of them. */
958
959void
960vwarning (const char *string, va_list args)
961{
962 if (deprecated_warning_hook)
963 (*deprecated_warning_hook) (string, args);
964 else
965 {
966 target_terminal_ours ();
c50c785c 967 wrap_here (""); /* Force out any buffered output. */
5796c8dc
SS
968 gdb_flush (gdb_stdout);
969 if (warning_pre_print)
970 fputs_unfiltered (warning_pre_print, gdb_stderr);
971 vfprintf_unfiltered (gdb_stderr, string, args);
972 fprintf_unfiltered (gdb_stderr, "\n");
973 va_end (args);
974 }
975}
976
977/* Print a warning message.
978 The first argument STRING is the warning message, used as a fprintf string,
979 and the remaining args are passed as arguments to it.
980 The primary difference between warnings and errors is that a warning
981 does not force the return to command level. */
982
983void
984warning (const char *string, ...)
985{
986 va_list args;
cf7f2e2d 987
5796c8dc
SS
988 va_start (args, string);
989 vwarning (string, args);
990 va_end (args);
991}
992
993/* Print an error message and return to command level.
994 The first argument STRING is the error message, used as a fprintf string,
995 and the remaining args are passed as arguments to it. */
996
cf7f2e2d 997void
5796c8dc
SS
998verror (const char *string, va_list args)
999{
1000 throw_verror (GENERIC_ERROR, string, args);
1001}
1002
cf7f2e2d 1003void
5796c8dc
SS
1004error (const char *string, ...)
1005{
1006 va_list args;
cf7f2e2d 1007
5796c8dc
SS
1008 va_start (args, string);
1009 throw_verror (GENERIC_ERROR, string, args);
1010 va_end (args);
1011}
1012
1013/* Print an error message and quit.
1014 The first argument STRING is the error message, used as a fprintf string,
1015 and the remaining args are passed as arguments to it. */
1016
cf7f2e2d 1017void
5796c8dc
SS
1018vfatal (const char *string, va_list args)
1019{
1020 throw_vfatal (string, args);
1021}
1022
cf7f2e2d 1023void
5796c8dc
SS
1024fatal (const char *string, ...)
1025{
1026 va_list args;
cf7f2e2d 1027
5796c8dc
SS
1028 va_start (args, string);
1029 throw_vfatal (string, args);
1030 va_end (args);
1031}
1032
cf7f2e2d 1033void
5796c8dc
SS
1034error_stream (struct ui_file *stream)
1035{
1036 char *message = ui_file_xstrdup (stream, NULL);
cf7f2e2d 1037
5796c8dc
SS
1038 make_cleanup (xfree, message);
1039 error (("%s"), message);
1040}
1041
cf7f2e2d
JM
1042/* Dump core trying to increase the core soft limit to hard limit first. */
1043
1044static void
1045dump_core (void)
1046{
1047#ifdef HAVE_SETRLIMIT
1048 struct rlimit rlim = { RLIM_INFINITY, RLIM_INFINITY };
1049
1050 setrlimit (RLIMIT_CORE, &rlim);
1051#endif /* HAVE_SETRLIMIT */
1052
1053 abort (); /* NOTE: GDB has only three calls to abort(). */
1054}
1055
c50c785c
JM
1056/* Check whether GDB will be able to dump core using the dump_core
1057 function. */
cf7f2e2d
JM
1058
1059static int
1060can_dump_core (const char *reason)
1061{
1062#ifdef HAVE_GETRLIMIT
1063 struct rlimit rlim;
1064
1065 /* Be quiet and assume we can dump if an error is returned. */
1066 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
1067 return 1;
1068
1069 if (rlim.rlim_max == 0)
1070 {
1071 fprintf_unfiltered (gdb_stderr,
c50c785c
JM
1072 _("%s\nUnable to dump core, use `ulimit -c"
1073 " unlimited' before executing GDB next time.\n"),
1074 reason);
cf7f2e2d
JM
1075 return 0;
1076 }
1077#endif /* HAVE_GETRLIMIT */
1078
1079 return 1;
1080}
1081
5796c8dc
SS
1082/* Allow the user to configure the debugger behavior with respect to
1083 what to do when an internal problem is detected. */
1084
1085const char internal_problem_ask[] = "ask";
1086const char internal_problem_yes[] = "yes";
1087const char internal_problem_no[] = "no";
1088static const char *internal_problem_modes[] =
1089{
1090 internal_problem_ask,
1091 internal_problem_yes,
1092 internal_problem_no,
1093 NULL
1094};
5796c8dc 1095
c50c785c 1096/* Print a message reporting an internal error/warning. Ask the user
5796c8dc
SS
1097 if they want to continue, dump core, or just exit. Return
1098 something to indicate a quit. */
1099
1100struct internal_problem
1101{
1102 const char *name;
1103 const char *should_quit;
1104 const char *should_dump_core;
1105};
1106
1107/* Report a problem, internal to GDB, to the user. Once the problem
1108 has been reported, and assuming GDB didn't quit, the caller can
1109 either allow execution to resume or throw an error. */
1110
cf7f2e2d 1111static void ATTRIBUTE_PRINTF (4, 0)
5796c8dc
SS
1112internal_vproblem (struct internal_problem *problem,
1113 const char *file, int line, const char *fmt, va_list ap)
1114{
1115 static int dejavu;
1116 int quit_p;
1117 int dump_core_p;
1118 char *reason;
1119
1120 /* Don't allow infinite error/warning recursion. */
1121 {
1122 static char msg[] = "Recursive internal problem.\n";
cf7f2e2d 1123
5796c8dc
SS
1124 switch (dejavu)
1125 {
1126 case 0:
1127 dejavu = 1;
1128 break;
1129 case 1:
1130 dejavu = 2;
1131 fputs_unfiltered (msg, gdb_stderr);
cf7f2e2d 1132 abort (); /* NOTE: GDB has only three calls to abort(). */
5796c8dc
SS
1133 default:
1134 dejavu = 3;
1135 /* Newer GLIBC versions put the warn_unused_result attribute
1136 on write, but this is one of those rare cases where
1137 ignoring the return value is correct. Casting to (void)
1138 does not fix this problem. This is the solution suggested
1139 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
1140 if (write (STDERR_FILENO, msg, sizeof (msg)) != sizeof (msg))
cf7f2e2d 1141 abort (); /* NOTE: GDB has only three calls to abort(). */
5796c8dc
SS
1142 exit (1);
1143 }
1144 }
1145
1146 /* Try to get the message out and at the start of a new line. */
1147 target_terminal_ours ();
1148 begin_line ();
1149
1150 /* Create a string containing the full error/warning message. Need
1151 to call query with this full string, as otherwize the reason
1152 (error/warning) and question become separated. Format using a
1153 style similar to a compiler error message. Include extra detail
1154 so that the user knows that they are living on the edge. */
1155 {
1156 char *msg;
cf7f2e2d 1157
5796c8dc 1158 msg = xstrvprintf (fmt, ap);
c50c785c
JM
1159 reason = xstrprintf ("%s:%d: %s: %s\n"
1160 "A problem internal to GDB has been detected,\n"
1161 "further debugging may prove unreliable.",
1162 file, line, problem->name, msg);
5796c8dc
SS
1163 xfree (msg);
1164 make_cleanup (xfree, reason);
1165 }
1166
1167 if (problem->should_quit == internal_problem_ask)
1168 {
1169 /* Default (yes/batch case) is to quit GDB. When in batch mode
1170 this lessens the likelihood of GDB going into an infinite
1171 loop. */
1172 if (caution == 0)
1173 {
1174 /* Emit the message and quit. */
1175 fputs_unfiltered (reason, gdb_stderr);
1176 fputs_unfiltered ("\n", gdb_stderr);
1177 quit_p = 1;
1178 }
1179 else
1180 quit_p = query (_("%s\nQuit this debugging session? "), reason);
1181 }
1182 else if (problem->should_quit == internal_problem_yes)
1183 quit_p = 1;
1184 else if (problem->should_quit == internal_problem_no)
1185 quit_p = 0;
1186 else
1187 internal_error (__FILE__, __LINE__, _("bad switch"));
1188
1189 if (problem->should_dump_core == internal_problem_ask)
1190 {
cf7f2e2d
JM
1191 if (!can_dump_core (reason))
1192 dump_core_p = 0;
1193 else
1194 {
1195 /* Default (yes/batch case) is to dump core. This leaves a GDB
1196 `dropping' so that it is easier to see that something went
1197 wrong in GDB. */
1198 dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason);
1199 }
5796c8dc
SS
1200 }
1201 else if (problem->should_dump_core == internal_problem_yes)
cf7f2e2d 1202 dump_core_p = can_dump_core (reason);
5796c8dc
SS
1203 else if (problem->should_dump_core == internal_problem_no)
1204 dump_core_p = 0;
1205 else
1206 internal_error (__FILE__, __LINE__, _("bad switch"));
1207
1208 if (quit_p)
1209 {
1210 if (dump_core_p)
cf7f2e2d 1211 dump_core ();
5796c8dc
SS
1212 else
1213 exit (1);
1214 }
1215 else
1216 {
1217 if (dump_core_p)
1218 {
1219#ifdef HAVE_WORKING_FORK
1220 if (fork () == 0)
cf7f2e2d 1221 dump_core ();
5796c8dc
SS
1222#endif
1223 }
1224 }
1225
1226 dejavu = 0;
1227}
1228
1229static struct internal_problem internal_error_problem = {
1230 "internal-error", internal_problem_ask, internal_problem_ask
1231};
1232
cf7f2e2d 1233void
5796c8dc
SS
1234internal_verror (const char *file, int line, const char *fmt, va_list ap)
1235{
1236 internal_vproblem (&internal_error_problem, file, line, fmt, ap);
1237 deprecated_throw_reason (RETURN_ERROR);
1238}
1239
cf7f2e2d 1240void
5796c8dc
SS
1241internal_error (const char *file, int line, const char *string, ...)
1242{
1243 va_list ap;
cf7f2e2d 1244
5796c8dc
SS
1245 va_start (ap, string);
1246 internal_verror (file, line, string, ap);
1247 va_end (ap);
1248}
1249
1250static struct internal_problem internal_warning_problem = {
1251 "internal-warning", internal_problem_ask, internal_problem_ask
1252};
1253
1254void
1255internal_vwarning (const char *file, int line, const char *fmt, va_list ap)
1256{
1257 internal_vproblem (&internal_warning_problem, file, line, fmt, ap);
1258}
1259
1260void
1261internal_warning (const char *file, int line, const char *string, ...)
1262{
1263 va_list ap;
cf7f2e2d 1264
5796c8dc
SS
1265 va_start (ap, string);
1266 internal_vwarning (file, line, string, ap);
1267 va_end (ap);
1268}
1269
1270/* Dummy functions to keep add_prefix_cmd happy. */
1271
1272static void
1273set_internal_problem_cmd (char *args, int from_tty)
1274{
1275}
1276
1277static void
1278show_internal_problem_cmd (char *args, int from_tty)
1279{
1280}
1281
1282/* When GDB reports an internal problem (error or warning) it gives
1283 the user the opportunity to quit GDB and/or create a core file of
1284 the current debug session. This function registers a few commands
1285 that make it possible to specify that GDB should always or never
1286 quit or create a core file, without asking. The commands look
1287 like:
1288
1289 maint set PROBLEM-NAME quit ask|yes|no
1290 maint show PROBLEM-NAME quit
1291 maint set PROBLEM-NAME corefile ask|yes|no
1292 maint show PROBLEM-NAME corefile
1293
1294 Where PROBLEM-NAME is currently "internal-error" or
1295 "internal-warning". */
1296
1297static void
1298add_internal_problem_command (struct internal_problem *problem)
1299{
1300 struct cmd_list_element **set_cmd_list;
1301 struct cmd_list_element **show_cmd_list;
1302 char *set_doc;
1303 char *show_doc;
1304
1305 set_cmd_list = xmalloc (sizeof (*set_cmd_list));
1306 show_cmd_list = xmalloc (sizeof (*set_cmd_list));
1307 *set_cmd_list = NULL;
1308 *show_cmd_list = NULL;
1309
1310 set_doc = xstrprintf (_("Configure what GDB does when %s is detected."),
1311 problem->name);
1312
1313 show_doc = xstrprintf (_("Show what GDB does when %s is detected."),
1314 problem->name);
1315
1316 add_prefix_cmd ((char*) problem->name,
1317 class_maintenance, set_internal_problem_cmd, set_doc,
1318 set_cmd_list,
cf7f2e2d
JM
1319 concat ("maintenance set ", problem->name, " ",
1320 (char *) NULL),
5796c8dc
SS
1321 0/*allow-unknown*/, &maintenance_set_cmdlist);
1322
1323 add_prefix_cmd ((char*) problem->name,
1324 class_maintenance, show_internal_problem_cmd, show_doc,
1325 show_cmd_list,
cf7f2e2d
JM
1326 concat ("maintenance show ", problem->name, " ",
1327 (char *) NULL),
5796c8dc
SS
1328 0/*allow-unknown*/, &maintenance_show_cmdlist);
1329
c50c785c
JM
1330 set_doc = xstrprintf (_("Set whether GDB should quit "
1331 "when an %s is detected"),
5796c8dc 1332 problem->name);
c50c785c
JM
1333 show_doc = xstrprintf (_("Show whether GDB will quit "
1334 "when an %s is detected"),
5796c8dc
SS
1335 problem->name);
1336 add_setshow_enum_cmd ("quit", class_maintenance,
1337 internal_problem_modes,
1338 &problem->should_quit,
1339 set_doc,
1340 show_doc,
1341 NULL, /* help_doc */
1342 NULL, /* setfunc */
1343 NULL, /* showfunc */
1344 set_cmd_list,
1345 show_cmd_list);
1346
1347 xfree (set_doc);
1348 xfree (show_doc);
1349
c50c785c
JM
1350 set_doc = xstrprintf (_("Set whether GDB should create a core "
1351 "file of GDB when %s is detected"),
5796c8dc 1352 problem->name);
c50c785c
JM
1353 show_doc = xstrprintf (_("Show whether GDB will create a core "
1354 "file of GDB when %s is detected"),
5796c8dc
SS
1355 problem->name);
1356 add_setshow_enum_cmd ("corefile", class_maintenance,
1357 internal_problem_modes,
1358 &problem->should_dump_core,
1359 set_doc,
1360 show_doc,
1361 NULL, /* help_doc */
1362 NULL, /* setfunc */
1363 NULL, /* showfunc */
1364 set_cmd_list,
1365 show_cmd_list);
1366
1367 xfree (set_doc);
1368 xfree (show_doc);
1369}
1370
1371/* Print the system error message for errno, and also mention STRING
1372 as the file name for which the error was encountered.
1373 Then return to command level. */
1374
cf7f2e2d 1375void
5796c8dc
SS
1376perror_with_name (const char *string)
1377{
1378 char *err;
1379 char *combined;
1380
1381 err = safe_strerror (errno);
1382 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
1383 strcpy (combined, string);
1384 strcat (combined, ": ");
1385 strcat (combined, err);
1386
1387 /* I understand setting these is a matter of taste. Still, some people
1388 may clear errno but not know about bfd_error. Doing this here is not
c50c785c 1389 unreasonable. */
5796c8dc
SS
1390 bfd_set_error (bfd_error_no_error);
1391 errno = 0;
1392
1393 error (_("%s."), combined);
1394}
1395
1396/* Print the system error message for ERRCODE, and also mention STRING
1397 as the file name for which the error was encountered. */
1398
1399void
1400print_sys_errmsg (const char *string, int errcode)
1401{
1402 char *err;
1403 char *combined;
1404
1405 err = safe_strerror (errcode);
1406 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
1407 strcpy (combined, string);
1408 strcat (combined, ": ");
1409 strcat (combined, err);
1410
1411 /* We want anything which was printed on stdout to come out first, before
1412 this message. */
1413 gdb_flush (gdb_stdout);
1414 fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
1415}
1416
1417/* Control C eventually causes this to be called, at a convenient time. */
1418
1419void
1420quit (void)
1421{
1422#ifdef __MSDOS__
1423 /* No steenking SIGINT will ever be coming our way when the
1424 program is resumed. Don't lie. */
1425 fatal ("Quit");
1426#else
1427 if (job_control
1428 /* If there is no terminal switching for this target, then we can't
1429 possibly get screwed by the lack of job control. */
1430 || current_target.to_terminal_ours == NULL)
1431 fatal ("Quit");
1432 else
1433 fatal ("Quit (expect signal SIGINT when the program is resumed)");
1434#endif
1435}
1436
1437\f
1438/* Called when a memory allocation fails, with the number of bytes of
c50c785c 1439 memory requested in SIZE. */
5796c8dc 1440
cf7f2e2d 1441void
5796c8dc
SS
1442nomem (long size)
1443{
1444 if (size > 0)
1445 {
1446 internal_error (__FILE__, __LINE__,
1447 _("virtual memory exhausted: can't allocate %ld bytes."),
1448 size);
1449 }
1450 else
1451 {
1452 internal_error (__FILE__, __LINE__, _("virtual memory exhausted."));
1453 }
1454}
1455
1456/* The xmalloc() (libiberty.h) family of memory management routines.
1457
1458 These are like the ISO-C malloc() family except that they implement
1459 consistent semantics and guard against typical memory management
1460 problems. */
1461
1462/* NOTE: These are declared using PTR to ensure consistency with
1463 "libiberty.h". xfree() is GDB local. */
1464
1465PTR /* ARI: PTR */
1466xmalloc (size_t size)
1467{
1468 void *val;
1469
1470 /* See libiberty/xmalloc.c. This function need's to match that's
1471 semantics. It never returns NULL. */
1472 if (size == 0)
1473 size = 1;
1474
1475 val = malloc (size); /* ARI: malloc */
1476 if (val == NULL)
1477 nomem (size);
1478
1479 return (val);
1480}
1481
1482void *
1483xzalloc (size_t size)
1484{
1485 return xcalloc (1, size);
1486}
1487
1488PTR /* ARI: PTR */
1489xrealloc (PTR ptr, size_t size) /* ARI: PTR */
1490{
1491 void *val;
1492
1493 /* See libiberty/xmalloc.c. This function need's to match that's
1494 semantics. It never returns NULL. */
1495 if (size == 0)
1496 size = 1;
1497
1498 if (ptr != NULL)
1499 val = realloc (ptr, size); /* ARI: realloc */
1500 else
1501 val = malloc (size); /* ARI: malloc */
1502 if (val == NULL)
1503 nomem (size);
1504
1505 return (val);
1506}
1507
1508PTR /* ARI: PTR */
1509xcalloc (size_t number, size_t size)
1510{
1511 void *mem;
1512
1513 /* See libiberty/xmalloc.c. This function need's to match that's
1514 semantics. It never returns NULL. */
1515 if (number == 0 || size == 0)
1516 {
1517 number = 1;
1518 size = 1;
1519 }
1520
1521 mem = calloc (number, size); /* ARI: xcalloc */
1522 if (mem == NULL)
1523 nomem (number * size);
1524
1525 return mem;
1526}
1527
1528void
1529xfree (void *ptr)
1530{
1531 if (ptr != NULL)
1532 free (ptr); /* ARI: free */
1533}
1534\f
1535
1536/* Like asprintf/vasprintf but get an internal_error if the call
c50c785c 1537 fails. */
5796c8dc
SS
1538
1539char *
1540xstrprintf (const char *format, ...)
1541{
1542 char *ret;
1543 va_list args;
cf7f2e2d 1544
5796c8dc
SS
1545 va_start (args, format);
1546 ret = xstrvprintf (format, args);
1547 va_end (args);
1548 return ret;
1549}
1550
1551void
1552xasprintf (char **ret, const char *format, ...)
1553{
1554 va_list args;
cf7f2e2d 1555
5796c8dc
SS
1556 va_start (args, format);
1557 (*ret) = xstrvprintf (format, args);
1558 va_end (args);
1559}
1560
1561void
1562xvasprintf (char **ret, const char *format, va_list ap)
1563{
1564 (*ret) = xstrvprintf (format, ap);
1565}
1566
1567char *
1568xstrvprintf (const char *format, va_list ap)
1569{
1570 char *ret = NULL;
1571 int status = vasprintf (&ret, format, ap);
cf7f2e2d 1572
5796c8dc
SS
1573 /* NULL is returned when there was a memory allocation problem, or
1574 any other error (for instance, a bad format string). A negative
1575 status (the printed length) with a non-NULL buffer should never
1576 happen, but just to be sure. */
1577 if (ret == NULL || status < 0)
1578 internal_error (__FILE__, __LINE__, _("vasprintf call failed"));
1579 return ret;
1580}
1581
1582int
1583xsnprintf (char *str, size_t size, const char *format, ...)
1584{
1585 va_list args;
1586 int ret;
1587
1588 va_start (args, format);
1589 ret = vsnprintf (str, size, format, args);
1590 gdb_assert (ret < size);
1591 va_end (args);
1592
1593 return ret;
1594}
1595
1596/* My replacement for the read system call.
1597 Used like `read' but keeps going if `read' returns too soon. */
1598
1599int
1600myread (int desc, char *addr, int len)
1601{
1602 int val;
1603 int orglen = len;
1604
1605 while (len > 0)
1606 {
1607 val = read (desc, addr, len);
1608 if (val < 0)
1609 return val;
1610 if (val == 0)
1611 return orglen - len;
1612 len -= val;
1613 addr += val;
1614 }
1615 return orglen;
1616}
1617\f
1618/* Make a copy of the string at PTR with SIZE characters
1619 (and add a null character at the end in the copy).
1620 Uses malloc to get the space. Returns the address of the copy. */
1621
1622char *
1623savestring (const char *ptr, size_t size)
1624{
1625 char *p = (char *) xmalloc (size + 1);
cf7f2e2d 1626
5796c8dc
SS
1627 memcpy (p, ptr, size);
1628 p[size] = 0;
1629 return p;
1630}
1631
1632void
1633print_spaces (int n, struct ui_file *file)
1634{
1635 fputs_unfiltered (n_spaces (n), file);
1636}
1637
1638/* Print a host address. */
1639
1640void
1641gdb_print_host_address (const void *addr, struct ui_file *stream)
1642{
1643 fprintf_filtered (stream, "%s", host_address_to_string (addr));
1644}
1645\f
1646
c50c785c
JM
1647/* A cleanup function that calls regfree. */
1648
1649static void
1650do_regfree_cleanup (void *r)
1651{
1652 regfree (r);
1653}
1654
1655/* Create a new cleanup that frees the compiled regular expression R. */
1656
1657struct cleanup *
1658make_regfree_cleanup (regex_t *r)
1659{
1660 return make_cleanup (do_regfree_cleanup, r);
1661}
1662
1663/* Return an xmalloc'd error message resulting from a regular
1664 expression compilation failure. */
1665
1666char *
1667get_regcomp_error (int code, regex_t *rx)
1668{
1669 size_t length = regerror (code, rx, NULL, 0);
1670 char *result = xmalloc (length);
1671
1672 regerror (code, rx, result, length);
1673 return result;
1674}
1675
1676\f
1677
5796c8dc
SS
1678/* This function supports the query, nquery, and yquery functions.
1679 Ask user a y-or-n question and return 0 if answer is no, 1 if
1680 answer is yes, or default the answer to the specified default
1681 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1682 default answer, or '\0' for no default.
1683 CTLSTR is the control string and should end in "? ". It should
1684 not say how to answer, because we do that.
1685 ARGS are the arguments passed along with the CTLSTR argument to
1686 printf. */
1687
cf7f2e2d 1688static int ATTRIBUTE_PRINTF (1, 0)
5796c8dc
SS
1689defaulted_query (const char *ctlstr, const char defchar, va_list args)
1690{
1691 int answer;
1692 int ans2;
1693 int retval;
1694 int def_value;
1695 char def_answer, not_def_answer;
1696 char *y_string, *n_string, *question;
1697
1698 /* Set up according to which answer is the default. */
1699 if (defchar == '\0')
1700 {
1701 def_value = 1;
1702 def_answer = 'Y';
1703 not_def_answer = 'N';
1704 y_string = "y";
1705 n_string = "n";
1706 }
1707 else if (defchar == 'y')
1708 {
1709 def_value = 1;
1710 def_answer = 'Y';
1711 not_def_answer = 'N';
1712 y_string = "[y]";
1713 n_string = "n";
1714 }
1715 else
1716 {
1717 def_value = 0;
1718 def_answer = 'N';
1719 not_def_answer = 'Y';
1720 y_string = "y";
1721 n_string = "[n]";
1722 }
1723
1724 /* Automatically answer the default value if the user did not want
1725 prompts or the command was issued with the server prefix. */
1726 if (! caution || server_command)
1727 return def_value;
1728
1729 /* If input isn't coming from the user directly, just say what
1730 question we're asking, and then answer the default automatically. This
1731 way, important error messages don't get lost when talking to GDB
1732 over a pipe. */
1733 if (! input_from_terminal_p ())
1734 {
1735 wrap_here ("");
1736 vfprintf_filtered (gdb_stdout, ctlstr, args);
1737
c50c785c
JM
1738 printf_filtered (_("(%s or %s) [answered %c; "
1739 "input not from terminal]\n"),
5796c8dc
SS
1740 y_string, n_string, def_answer);
1741 gdb_flush (gdb_stdout);
1742
1743 return def_value;
1744 }
1745
1746 if (deprecated_query_hook)
1747 {
1748 return deprecated_query_hook (ctlstr, args);
1749 }
1750
1751 /* Format the question outside of the loop, to avoid reusing args. */
1752 question = xstrvprintf (ctlstr, args);
1753
1754 while (1)
1755 {
c50c785c 1756 wrap_here (""); /* Flush any buffered output. */
5796c8dc
SS
1757 gdb_flush (gdb_stdout);
1758
1759 if (annotation_level > 1)
1760 printf_filtered (("\n\032\032pre-query\n"));
1761
1762 fputs_filtered (question, gdb_stdout);
1763 printf_filtered (_("(%s or %s) "), y_string, n_string);
1764
1765 if (annotation_level > 1)
1766 printf_filtered (("\n\032\032query\n"));
1767
1768 wrap_here ("");
1769 gdb_flush (gdb_stdout);
1770
1771 answer = fgetc (stdin);
1772
1773 /* We expect fgetc to block until a character is read. But
1774 this may not be the case if the terminal was opened with
1775 the NONBLOCK flag. In that case, if there is nothing to
1776 read on stdin, fgetc returns EOF, but also sets the error
1777 condition flag on stdin and errno to EAGAIN. With a true
1778 EOF, stdin's error condition flag is not set.
1779
1780 A situation where this behavior was observed is a pseudo
1781 terminal on AIX. */
1782 while (answer == EOF && ferror (stdin) && errno == EAGAIN)
1783 {
1784 /* Not a real EOF. Wait a little while and try again until
1785 we read something. */
1786 clearerr (stdin);
1787 gdb_usleep (10000);
1788 answer = fgetc (stdin);
1789 }
1790
1791 clearerr (stdin); /* in case of C-d */
1792 if (answer == EOF) /* C-d */
1793 {
1794 printf_filtered ("EOF [assumed %c]\n", def_answer);
1795 retval = def_value;
1796 break;
1797 }
c50c785c 1798 /* Eat rest of input line, to EOF or newline. */
5796c8dc
SS
1799 if (answer != '\n')
1800 do
1801 {
1802 ans2 = fgetc (stdin);
1803 clearerr (stdin);
1804 }
1805 while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1806
1807 if (answer >= 'a')
1808 answer -= 040;
1809 /* Check answer. For the non-default, the user must specify
1810 the non-default explicitly. */
1811 if (answer == not_def_answer)
1812 {
1813 retval = !def_value;
1814 break;
1815 }
1816 /* Otherwise, if a default was specified, the user may either
1817 specify the required input or have it default by entering
1818 nothing. */
1819 if (answer == def_answer
1820 || (defchar != '\0' &&
1821 (answer == '\n' || answer == '\r' || answer == EOF)))
1822 {
1823 retval = def_value;
1824 break;
1825 }
1826 /* Invalid entries are not defaulted and require another selection. */
1827 printf_filtered (_("Please answer %s or %s.\n"),
1828 y_string, n_string);
1829 }
1830
1831 xfree (question);
1832 if (annotation_level > 1)
1833 printf_filtered (("\n\032\032post-query\n"));
1834 return retval;
1835}
1836\f
1837
1838/* Ask user a y-or-n question and return 0 if answer is no, 1 if
1839 answer is yes, or 0 if answer is defaulted.
1840 Takes three args which are given to printf to print the question.
1841 The first, a control string, should end in "? ".
1842 It should not say how to answer, because we do that. */
1843
1844int
1845nquery (const char *ctlstr, ...)
1846{
1847 va_list args;
c50c785c 1848 int ret;
5796c8dc
SS
1849
1850 va_start (args, ctlstr);
c50c785c 1851 ret = defaulted_query (ctlstr, 'n', args);
5796c8dc 1852 va_end (args);
c50c785c 1853 return ret;
5796c8dc
SS
1854}
1855
1856/* Ask user a y-or-n question and return 0 if answer is no, 1 if
1857 answer is yes, or 1 if answer is defaulted.
1858 Takes three args which are given to printf to print the question.
1859 The first, a control string, should end in "? ".
1860 It should not say how to answer, because we do that. */
1861
1862int
1863yquery (const char *ctlstr, ...)
1864{
1865 va_list args;
c50c785c 1866 int ret;
5796c8dc
SS
1867
1868 va_start (args, ctlstr);
c50c785c 1869 ret = defaulted_query (ctlstr, 'y', args);
5796c8dc 1870 va_end (args);
c50c785c 1871 return ret;
5796c8dc
SS
1872}
1873
1874/* Ask user a y-or-n question and return 1 iff answer is yes.
1875 Takes three args which are given to printf to print the question.
1876 The first, a control string, should end in "? ".
1877 It should not say how to answer, because we do that. */
1878
1879int
1880query (const char *ctlstr, ...)
1881{
1882 va_list args;
c50c785c 1883 int ret;
5796c8dc
SS
1884
1885 va_start (args, ctlstr);
c50c785c 1886 ret = defaulted_query (ctlstr, '\0', args);
5796c8dc 1887 va_end (args);
c50c785c 1888 return ret;
5796c8dc
SS
1889}
1890
1891/* A helper for parse_escape that converts a host character to a
1892 target character. C is the host character. If conversion is
1893 possible, then the target character is stored in *TARGET_C and the
1894 function returns 1. Otherwise, the function returns 0. */
1895
1896static int
cf7f2e2d 1897host_char_to_target (struct gdbarch *gdbarch, int c, int *target_c)
5796c8dc
SS
1898{
1899 struct obstack host_data;
1900 char the_char = c;
1901 struct cleanup *cleanups;
1902 int result = 0;
1903
1904 obstack_init (&host_data);
1905 cleanups = make_cleanup_obstack_free (&host_data);
1906
cf7f2e2d 1907 convert_between_encodings (target_charset (gdbarch), host_charset (),
5796c8dc
SS
1908 &the_char, 1, 1, &host_data, translit_none);
1909
1910 if (obstack_object_size (&host_data) == 1)
1911 {
1912 result = 1;
1913 *target_c = *(char *) obstack_base (&host_data);
1914 }
1915
1916 do_cleanups (cleanups);
1917 return result;
1918}
1919
1920/* Parse a C escape sequence. STRING_PTR points to a variable
1921 containing a pointer to the string to parse. That pointer
1922 should point to the character after the \. That pointer
1923 is updated past the characters we use. The value of the
1924 escape sequence is returned.
1925
1926 A negative value means the sequence \ newline was seen,
1927 which is supposed to be equivalent to nothing at all.
1928
1929 If \ is followed by a null character, we return a negative
1930 value and leave the string pointer pointing at the null character.
1931
1932 If \ is followed by 000, we return 0 and leave the string pointer
1933 after the zeros. A value of 0 does not mean end of string. */
1934
1935int
cf7f2e2d 1936parse_escape (struct gdbarch *gdbarch, char **string_ptr)
5796c8dc 1937{
c50c785c 1938 int target_char = -2; /* Initialize to avoid GCC warnings. */
5796c8dc 1939 int c = *(*string_ptr)++;
cf7f2e2d 1940
5796c8dc
SS
1941 switch (c)
1942 {
1943 case '\n':
1944 return -2;
1945 case 0:
1946 (*string_ptr)--;
1947 return 0;
1948
1949 case '0':
1950 case '1':
1951 case '2':
1952 case '3':
1953 case '4':
1954 case '5':
1955 case '6':
1956 case '7':
1957 {
1958 int i = host_hex_value (c);
1959 int count = 0;
1960 while (++count < 3)
1961 {
1962 c = (**string_ptr);
1963 if (isdigit (c) && c != '8' && c != '9')
1964 {
1965 (*string_ptr)++;
1966 i *= 8;
1967 i += host_hex_value (c);
1968 }
1969 else
1970 {
1971 break;
1972 }
1973 }
1974 return i;
1975 }
1976
1977 case 'a':
1978 c = '\a';
1979 break;
1980 case 'b':
1981 c = '\b';
1982 break;
1983 case 'f':
1984 c = '\f';
1985 break;
1986 case 'n':
1987 c = '\n';
1988 break;
1989 case 'r':
1990 c = '\r';
1991 break;
1992 case 't':
1993 c = '\t';
1994 break;
1995 case 'v':
1996 c = '\v';
1997 break;
1998
1999 default:
2000 break;
2001 }
2002
cf7f2e2d 2003 if (!host_char_to_target (gdbarch, c, &target_char))
c50c785c
JM
2004 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
2005 " which has no equivalent\nin the `%s' character set."),
2006 c, c, target_charset (gdbarch));
5796c8dc
SS
2007 return target_char;
2008}
2009\f
2010/* Print the character C on STREAM as part of the contents of a literal
2011 string whose delimiter is QUOTER. Note that this routine should only
2012 be call for printing things which are independent of the language
c50c785c 2013 of the program being debugged. */
5796c8dc
SS
2014
2015static void
2016printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
2017 void (*do_fprintf) (struct ui_file *, const char *, ...)
2018 ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter)
2019{
5796c8dc
SS
2020 c &= 0xFF; /* Avoid sign bit follies */
2021
2022 if (c < 0x20 || /* Low control chars */
2023 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
2024 (sevenbit_strings && c >= 0x80))
2025 { /* high order bit set */
2026 switch (c)
2027 {
2028 case '\n':
2029 do_fputs ("\\n", stream);
2030 break;
2031 case '\b':
2032 do_fputs ("\\b", stream);
2033 break;
2034 case '\t':
2035 do_fputs ("\\t", stream);
2036 break;
2037 case '\f':
2038 do_fputs ("\\f", stream);
2039 break;
2040 case '\r':
2041 do_fputs ("\\r", stream);
2042 break;
2043 case '\033':
2044 do_fputs ("\\e", stream);
2045 break;
2046 case '\007':
2047 do_fputs ("\\a", stream);
2048 break;
2049 default:
2050 do_fprintf (stream, "\\%.3o", (unsigned int) c);
2051 break;
2052 }
2053 }
2054 else
2055 {
2056 if (c == '\\' || c == quoter)
2057 do_fputs ("\\", stream);
2058 do_fprintf (stream, "%c", c);
2059 }
2060}
2061
2062/* Print the character C on STREAM as part of the contents of a
2063 literal string whose delimiter is QUOTER. Note that these routines
2064 should only be call for printing things which are independent of
c50c785c 2065 the language of the program being debugged. */
5796c8dc
SS
2066
2067void
2068fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
2069{
2070 while (*str)
2071 printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
2072}
2073
2074void
2075fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
2076{
2077 while (*str)
2078 printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
2079}
2080
2081void
2082fputstrn_filtered (const char *str, int n, int quoter,
2083 struct ui_file *stream)
2084{
2085 int i;
cf7f2e2d 2086
5796c8dc
SS
2087 for (i = 0; i < n; i++)
2088 printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter);
2089}
2090
2091void
2092fputstrn_unfiltered (const char *str, int n, int quoter,
2093 struct ui_file *stream)
2094{
2095 int i;
cf7f2e2d 2096
5796c8dc
SS
2097 for (i = 0; i < n; i++)
2098 printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
2099}
2100\f
2101
2102/* Number of lines per page or UINT_MAX if paging is disabled. */
2103static unsigned int lines_per_page;
2104static void
2105show_lines_per_page (struct ui_file *file, int from_tty,
2106 struct cmd_list_element *c, const char *value)
2107{
c50c785c
JM
2108 fprintf_filtered (file,
2109 _("Number of lines gdb thinks are in a page is %s.\n"),
5796c8dc
SS
2110 value);
2111}
2112
2113/* Number of chars per line or UINT_MAX if line folding is disabled. */
2114static unsigned int chars_per_line;
2115static void
2116show_chars_per_line (struct ui_file *file, int from_tty,
2117 struct cmd_list_element *c, const char *value)
2118{
c50c785c
JM
2119 fprintf_filtered (file,
2120 _("Number of characters gdb thinks "
2121 "are in a line is %s.\n"),
5796c8dc
SS
2122 value);
2123}
2124
2125/* Current count of lines printed on this page, chars on this line. */
2126static unsigned int lines_printed, chars_printed;
2127
2128/* Buffer and start column of buffered text, for doing smarter word-
2129 wrapping. When someone calls wrap_here(), we start buffering output
2130 that comes through fputs_filtered(). If we see a newline, we just
2131 spit it out and forget about the wrap_here(). If we see another
2132 wrap_here(), we spit it out and remember the newer one. If we see
2133 the end of the line, we spit out a newline, the indent, and then
2134 the buffered output. */
2135
2136/* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
2137 are waiting to be output (they have already been counted in chars_printed).
2138 When wrap_buffer[0] is null, the buffer is empty. */
2139static char *wrap_buffer;
2140
2141/* Pointer in wrap_buffer to the next character to fill. */
2142static char *wrap_pointer;
2143
2144/* String to indent by if the wrap occurs. Must not be NULL if wrap_column
2145 is non-zero. */
2146static char *wrap_indent;
2147
2148/* Column number on the screen where wrap_buffer begins, or 0 if wrapping
2149 is not in effect. */
2150static int wrap_column;
2151\f
2152
2153/* Inialize the number of lines per page and chars per line. */
2154
2155void
2156init_page_info (void)
2157{
cf7f2e2d
JM
2158 if (batch_flag)
2159 {
2160 lines_per_page = UINT_MAX;
2161 chars_per_line = UINT_MAX;
2162 }
2163 else
5796c8dc
SS
2164#if defined(TUI)
2165 if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
2166#endif
2167 {
2168 int rows, cols;
2169
2170#if defined(__GO32__)
2171 rows = ScreenRows ();
2172 cols = ScreenCols ();
2173 lines_per_page = rows;
2174 chars_per_line = cols;
2175#else
2176 /* Make sure Readline has initialized its terminal settings. */
2177 rl_reset_terminal (NULL);
2178
2179 /* Get the screen size from Readline. */
2180 rl_get_screen_size (&rows, &cols);
2181 lines_per_page = rows;
2182 chars_per_line = cols;
2183
2184 /* Readline should have fetched the termcap entry for us. */
2185 if (tgetnum ("li") < 0 || getenv ("EMACS"))
2186 {
2187 /* The number of lines per page is not mentioned in the
2188 terminal description. This probably means that paging is
2189 not useful (e.g. emacs shell window), so disable paging. */
2190 lines_per_page = UINT_MAX;
2191 }
2192
2193 /* FIXME: Get rid of this junk. */
2194#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
2195 SIGWINCH_HANDLER (SIGWINCH);
2196#endif
2197
2198 /* If the output is not a terminal, don't paginate it. */
2199 if (!ui_file_isatty (gdb_stdout))
2200 lines_per_page = UINT_MAX;
2201#endif
2202 }
2203
2204 set_screen_size ();
2205 set_width ();
2206}
2207
cf7f2e2d
JM
2208/* Helper for make_cleanup_restore_page_info. */
2209
2210static void
2211do_restore_page_info_cleanup (void *arg)
2212{
2213 set_screen_size ();
2214 set_width ();
2215}
2216
2217/* Provide cleanup for restoring the terminal size. */
2218
2219struct cleanup *
2220make_cleanup_restore_page_info (void)
2221{
2222 struct cleanup *back_to;
2223
2224 back_to = make_cleanup (do_restore_page_info_cleanup, NULL);
2225 make_cleanup_restore_uinteger (&lines_per_page);
2226 make_cleanup_restore_uinteger (&chars_per_line);
2227
2228 return back_to;
2229}
2230
2231/* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
2232 Provide cleanup for restoring the original state. */
2233
2234struct cleanup *
2235set_batch_flag_and_make_cleanup_restore_page_info (void)
2236{
2237 struct cleanup *back_to = make_cleanup_restore_page_info ();
2238
2239 make_cleanup_restore_integer (&batch_flag);
2240 batch_flag = 1;
2241 init_page_info ();
2242
2243 return back_to;
2244}
2245
5796c8dc
SS
2246/* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
2247
2248static void
2249set_screen_size (void)
2250{
2251 int rows = lines_per_page;
2252 int cols = chars_per_line;
2253
2254 if (rows <= 0)
2255 rows = INT_MAX;
2256
2257 if (cols <= 0)
2258 cols = INT_MAX;
2259
2260 /* Update Readline's idea of the terminal size. */
2261 rl_set_screen_size (rows, cols);
2262}
2263
2264/* Reinitialize WRAP_BUFFER according to the current value of
2265 CHARS_PER_LINE. */
2266
2267static void
2268set_width (void)
2269{
2270 if (chars_per_line == 0)
2271 init_page_info ();
2272
2273 if (!wrap_buffer)
2274 {
2275 wrap_buffer = (char *) xmalloc (chars_per_line + 2);
2276 wrap_buffer[0] = '\0';
2277 }
2278 else
2279 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
2280 wrap_pointer = wrap_buffer; /* Start it at the beginning. */
2281}
2282
2283static void
2284set_width_command (char *args, int from_tty, struct cmd_list_element *c)
2285{
2286 set_screen_size ();
2287 set_width ();
2288}
2289
2290static void
2291set_height_command (char *args, int from_tty, struct cmd_list_element *c)
2292{
2293 set_screen_size ();
2294}
2295
2296/* Wait, so the user can read what's on the screen. Prompt the user
2297 to continue by pressing RETURN. */
2298
2299static void
2300prompt_for_continue (void)
2301{
2302 char *ignore;
2303 char cont_prompt[120];
2304
2305 if (annotation_level > 1)
2306 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
2307
2308 strcpy (cont_prompt,
2309 "---Type <return> to continue, or q <return> to quit---");
2310 if (annotation_level > 1)
2311 strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
2312
2313 /* We must do this *before* we call gdb_readline, else it will eventually
2314 call us -- thinking that we're trying to print beyond the end of the
2315 screen. */
2316 reinitialize_more_filter ();
2317
2318 immediate_quit++;
2319 /* On a real operating system, the user can quit with SIGINT.
2320 But not on GO32.
2321
2322 'q' is provided on all systems so users don't have to change habits
2323 from system to system, and because telling them what to do in
2324 the prompt is more user-friendly than expecting them to think of
2325 SIGINT. */
2326 /* Call readline, not gdb_readline, because GO32 readline handles control-C
2327 whereas control-C to gdb_readline will cause the user to get dumped
2328 out to DOS. */
2329 ignore = gdb_readline_wrapper (cont_prompt);
2330
2331 if (annotation_level > 1)
2332 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
2333
2334 if (ignore)
2335 {
2336 char *p = ignore;
cf7f2e2d 2337
5796c8dc
SS
2338 while (*p == ' ' || *p == '\t')
2339 ++p;
2340 if (p[0] == 'q')
2341 async_request_quit (0);
2342 xfree (ignore);
2343 }
2344 immediate_quit--;
2345
2346 /* Now we have to do this again, so that GDB will know that it doesn't
2347 need to save the ---Type <return>--- line at the top of the screen. */
2348 reinitialize_more_filter ();
2349
c50c785c 2350 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
5796c8dc
SS
2351}
2352
2353/* Reinitialize filter; ie. tell it to reset to original values. */
2354
2355void
2356reinitialize_more_filter (void)
2357{
2358 lines_printed = 0;
2359 chars_printed = 0;
2360}
2361
2362/* Indicate that if the next sequence of characters overflows the line,
c50c785c 2363 a newline should be inserted here rather than when it hits the end.
5796c8dc
SS
2364 If INDENT is non-null, it is a string to be printed to indent the
2365 wrapped part on the next line. INDENT must remain accessible until
2366 the next call to wrap_here() or until a newline is printed through
2367 fputs_filtered().
2368
2369 If the line is already overfull, we immediately print a newline and
2370 the indentation, and disable further wrapping.
2371
2372 If we don't know the width of lines, but we know the page height,
2373 we must not wrap words, but should still keep track of newlines
2374 that were explicitly printed.
2375
2376 INDENT should not contain tabs, as that will mess up the char count
2377 on the next line. FIXME.
2378
2379 This routine is guaranteed to force out any output which has been
2380 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
2381 used to force out output from the wrap_buffer. */
2382
2383void
2384wrap_here (char *indent)
2385{
c50c785c 2386 /* This should have been allocated, but be paranoid anyway. */
5796c8dc 2387 if (!wrap_buffer)
c50c785c
JM
2388 internal_error (__FILE__, __LINE__,
2389 _("failed internal consistency check"));
5796c8dc
SS
2390
2391 if (wrap_buffer[0])
2392 {
2393 *wrap_pointer = '\0';
2394 fputs_unfiltered (wrap_buffer, gdb_stdout);
2395 }
2396 wrap_pointer = wrap_buffer;
2397 wrap_buffer[0] = '\0';
c50c785c 2398 if (chars_per_line == UINT_MAX) /* No line overflow checking. */
5796c8dc
SS
2399 {
2400 wrap_column = 0;
2401 }
2402 else if (chars_printed >= chars_per_line)
2403 {
2404 puts_filtered ("\n");
2405 if (indent != NULL)
2406 puts_filtered (indent);
2407 wrap_column = 0;
2408 }
2409 else
2410 {
2411 wrap_column = chars_printed;
2412 if (indent == NULL)
2413 wrap_indent = "";
2414 else
2415 wrap_indent = indent;
2416 }
2417}
2418
2419/* Print input string to gdb_stdout, filtered, with wrap,
c50c785c 2420 arranging strings in columns of n chars. String can be
5796c8dc
SS
2421 right or left justified in the column. Never prints
2422 trailing spaces. String should never be longer than
2423 width. FIXME: this could be useful for the EXAMINE
c50c785c 2424 command, which currently doesn't tabulate very well. */
5796c8dc
SS
2425
2426void
2427puts_filtered_tabular (char *string, int width, int right)
2428{
2429 int spaces = 0;
2430 int stringlen;
2431 char *spacebuf;
2432
2433 gdb_assert (chars_per_line > 0);
2434 if (chars_per_line == UINT_MAX)
2435 {
2436 fputs_filtered (string, gdb_stdout);
2437 fputs_filtered ("\n", gdb_stdout);
2438 return;
2439 }
2440
2441 if (((chars_printed - 1) / width + 2) * width >= chars_per_line)
2442 fputs_filtered ("\n", gdb_stdout);
2443
2444 if (width >= chars_per_line)
2445 width = chars_per_line - 1;
2446
2447 stringlen = strlen (string);
2448
2449 if (chars_printed > 0)
2450 spaces = width - (chars_printed - 1) % width - 1;
2451 if (right)
2452 spaces += width - stringlen;
2453
2454 spacebuf = alloca (spaces + 1);
2455 spacebuf[spaces] = '\0';
2456 while (spaces--)
2457 spacebuf[spaces] = ' ';
2458
2459 fputs_filtered (spacebuf, gdb_stdout);
2460 fputs_filtered (string, gdb_stdout);
2461}
2462
2463
2464/* Ensure that whatever gets printed next, using the filtered output
c50c785c 2465 commands, starts at the beginning of the line. I.e. if there is
5796c8dc 2466 any pending output for the current line, flush it and start a new
c50c785c 2467 line. Otherwise do nothing. */
5796c8dc
SS
2468
2469void
2470begin_line (void)
2471{
2472 if (chars_printed > 0)
2473 {
2474 puts_filtered ("\n");
2475 }
2476}
2477
2478
2479/* Like fputs but if FILTER is true, pause after every screenful.
2480
2481 Regardless of FILTER can wrap at points other than the final
2482 character of a line.
2483
2484 Unlike fputs, fputs_maybe_filtered does not return a value.
2485 It is OK for LINEBUFFER to be NULL, in which case just don't print
2486 anything.
2487
2488 Note that a longjmp to top level may occur in this routine (only if
2489 FILTER is true) (since prompt_for_continue may do so) so this
2490 routine should not be called when cleanups are not in place. */
2491
2492static void
2493fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
2494 int filter)
2495{
2496 const char *lineptr;
2497
2498 if (linebuffer == 0)
2499 return;
2500
2501 /* Don't do any filtering if it is disabled. */
cf7f2e2d
JM
2502 if (stream != gdb_stdout
2503 || ! pagination_enabled
2504 || ! input_from_terminal_p ()
2505 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)
2506 || top_level_interpreter () == NULL
2507 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
5796c8dc
SS
2508 {
2509 fputs_unfiltered (linebuffer, stream);
2510 return;
2511 }
2512
2513 /* Go through and output each character. Show line extension
2514 when this is necessary; prompt user for new page when this is
2515 necessary. */
2516
2517 lineptr = linebuffer;
2518 while (*lineptr)
2519 {
2520 /* Possible new page. */
2521 if (filter && (lines_printed >= lines_per_page - 1))
2522 prompt_for_continue ();
2523
2524 while (*lineptr && *lineptr != '\n')
2525 {
2526 /* Print a single line. */
2527 if (*lineptr == '\t')
2528 {
2529 if (wrap_column)
2530 *wrap_pointer++ = '\t';
2531 else
2532 fputc_unfiltered ('\t', stream);
2533 /* Shifting right by 3 produces the number of tab stops
2534 we have already passed, and then adding one and
2535 shifting left 3 advances to the next tab stop. */
2536 chars_printed = ((chars_printed >> 3) + 1) << 3;
2537 lineptr++;
2538 }
2539 else
2540 {
2541 if (wrap_column)
2542 *wrap_pointer++ = *lineptr;
2543 else
2544 fputc_unfiltered (*lineptr, stream);
2545 chars_printed++;
2546 lineptr++;
2547 }
2548
2549 if (chars_printed >= chars_per_line)
2550 {
2551 unsigned int save_chars = chars_printed;
2552
2553 chars_printed = 0;
2554 lines_printed++;
2555 /* If we aren't actually wrapping, don't output newline --
2556 if chars_per_line is right, we probably just overflowed
2557 anyway; if it's wrong, let us keep going. */
2558 if (wrap_column)
2559 fputc_unfiltered ('\n', stream);
2560
2561 /* Possible new page. */
2562 if (lines_printed >= lines_per_page - 1)
2563 prompt_for_continue ();
2564
c50c785c 2565 /* Now output indentation and wrapped string. */
5796c8dc
SS
2566 if (wrap_column)
2567 {
2568 fputs_unfiltered (wrap_indent, stream);
c50c785c
JM
2569 *wrap_pointer = '\0'; /* Null-terminate saved stuff, */
2570 fputs_unfiltered (wrap_buffer, stream); /* and eject it. */
5796c8dc
SS
2571 /* FIXME, this strlen is what prevents wrap_indent from
2572 containing tabs. However, if we recurse to print it
2573 and count its chars, we risk trouble if wrap_indent is
c50c785c 2574 longer than (the user settable) chars_per_line.
5796c8dc
SS
2575 Note also that this can set chars_printed > chars_per_line
2576 if we are printing a long string. */
2577 chars_printed = strlen (wrap_indent)
2578 + (save_chars - wrap_column);
2579 wrap_pointer = wrap_buffer; /* Reset buffer */
2580 wrap_buffer[0] = '\0';
2581 wrap_column = 0; /* And disable fancy wrap */
2582 }
2583 }
2584 }
2585
2586 if (*lineptr == '\n')
2587 {
2588 chars_printed = 0;
c50c785c
JM
2589 wrap_here ((char *) 0); /* Spit out chars, cancel
2590 further wraps. */
5796c8dc
SS
2591 lines_printed++;
2592 fputc_unfiltered ('\n', stream);
2593 lineptr++;
2594 }
2595 }
2596}
2597
2598void
2599fputs_filtered (const char *linebuffer, struct ui_file *stream)
2600{
2601 fputs_maybe_filtered (linebuffer, stream, 1);
2602}
2603
2604int
2605putchar_unfiltered (int c)
2606{
2607 char buf = c;
cf7f2e2d 2608
5796c8dc
SS
2609 ui_file_write (gdb_stdout, &buf, 1);
2610 return c;
2611}
2612
2613/* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2614 May return nonlocally. */
2615
2616int
2617putchar_filtered (int c)
2618{
2619 return fputc_filtered (c, gdb_stdout);
2620}
2621
2622int
2623fputc_unfiltered (int c, struct ui_file *stream)
2624{
2625 char buf = c;
cf7f2e2d 2626
5796c8dc
SS
2627 ui_file_write (stream, &buf, 1);
2628 return c;
2629}
2630
2631int
2632fputc_filtered (int c, struct ui_file *stream)
2633{
2634 char buf[2];
2635
2636 buf[0] = c;
2637 buf[1] = 0;
2638 fputs_filtered (buf, stream);
2639 return c;
2640}
2641
2642/* puts_debug is like fputs_unfiltered, except it prints special
2643 characters in printable fashion. */
2644
2645void
2646puts_debug (char *prefix, char *string, char *suffix)
2647{
2648 int ch;
2649
2650 /* Print prefix and suffix after each line. */
2651 static int new_line = 1;
2652 static int return_p = 0;
2653 static char *prev_prefix = "";
2654 static char *prev_suffix = "";
2655
2656 if (*string == '\n')
2657 return_p = 0;
2658
2659 /* If the prefix is changing, print the previous suffix, a new line,
2660 and the new prefix. */
2661 if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
2662 {
2663 fputs_unfiltered (prev_suffix, gdb_stdlog);
2664 fputs_unfiltered ("\n", gdb_stdlog);
2665 fputs_unfiltered (prefix, gdb_stdlog);
2666 }
2667
2668 /* Print prefix if we printed a newline during the previous call. */
2669 if (new_line)
2670 {
2671 new_line = 0;
2672 fputs_unfiltered (prefix, gdb_stdlog);
2673 }
2674
2675 prev_prefix = prefix;
2676 prev_suffix = suffix;
2677
2678 /* Output characters in a printable format. */
2679 while ((ch = *string++) != '\0')
2680 {
2681 switch (ch)
2682 {
2683 default:
2684 if (isprint (ch))
2685 fputc_unfiltered (ch, gdb_stdlog);
2686
2687 else
2688 fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
2689 break;
2690
2691 case '\\':
2692 fputs_unfiltered ("\\\\", gdb_stdlog);
2693 break;
2694 case '\b':
2695 fputs_unfiltered ("\\b", gdb_stdlog);
2696 break;
2697 case '\f':
2698 fputs_unfiltered ("\\f", gdb_stdlog);
2699 break;
2700 case '\n':
2701 new_line = 1;
2702 fputs_unfiltered ("\\n", gdb_stdlog);
2703 break;
2704 case '\r':
2705 fputs_unfiltered ("\\r", gdb_stdlog);
2706 break;
2707 case '\t':
2708 fputs_unfiltered ("\\t", gdb_stdlog);
2709 break;
2710 case '\v':
2711 fputs_unfiltered ("\\v", gdb_stdlog);
2712 break;
2713 }
2714
2715 return_p = ch == '\r';
2716 }
2717
2718 /* Print suffix if we printed a newline. */
2719 if (new_line)
2720 {
2721 fputs_unfiltered (suffix, gdb_stdlog);
2722 fputs_unfiltered ("\n", gdb_stdlog);
2723 }
2724}
2725
2726
2727/* Print a variable number of ARGS using format FORMAT. If this
2728 information is going to put the amount written (since the last call
2729 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2730 call prompt_for_continue to get the users permision to continue.
2731
2732 Unlike fprintf, this function does not return a value.
2733
2734 We implement three variants, vfprintf (takes a vararg list and stream),
2735 fprintf (takes a stream to write on), and printf (the usual).
2736
2737 Note also that a longjmp to top level may occur in this routine
2738 (since prompt_for_continue may do so) so this routine should not be
2739 called when cleanups are not in place. */
2740
2741static void
2742vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
2743 va_list args, int filter)
2744{
2745 char *linebuffer;
2746 struct cleanup *old_cleanups;
2747
2748 linebuffer = xstrvprintf (format, args);
2749 old_cleanups = make_cleanup (xfree, linebuffer);
2750 fputs_maybe_filtered (linebuffer, stream, filter);
2751 do_cleanups (old_cleanups);
2752}
2753
2754
2755void
2756vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
2757{
2758 vfprintf_maybe_filtered (stream, format, args, 1);
2759}
2760
2761void
2762vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
2763{
2764 char *linebuffer;
2765 struct cleanup *old_cleanups;
2766
2767 linebuffer = xstrvprintf (format, args);
2768 old_cleanups = make_cleanup (xfree, linebuffer);
2769 if (debug_timestamp && stream == gdb_stdlog)
2770 {
2771 struct timeval tm;
2772 char *timestamp;
2773 int len, need_nl;
2774
2775 gettimeofday (&tm, NULL);
2776
2777 len = strlen (linebuffer);
2778 need_nl = (len > 0 && linebuffer[len - 1] != '\n');
2779
2780 timestamp = xstrprintf ("%ld:%ld %s%s",
2781 (long) tm.tv_sec, (long) tm.tv_usec,
2782 linebuffer,
2783 need_nl ? "\n": "");
2784 make_cleanup (xfree, timestamp);
2785 fputs_unfiltered (timestamp, stream);
2786 }
2787 else
2788 fputs_unfiltered (linebuffer, stream);
2789 do_cleanups (old_cleanups);
2790}
2791
2792void
2793vprintf_filtered (const char *format, va_list args)
2794{
2795 vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2796}
2797
2798void
2799vprintf_unfiltered (const char *format, va_list args)
2800{
2801 vfprintf_unfiltered (gdb_stdout, format, args);
2802}
2803
2804void
2805fprintf_filtered (struct ui_file *stream, const char *format, ...)
2806{
2807 va_list args;
cf7f2e2d 2808
5796c8dc
SS
2809 va_start (args, format);
2810 vfprintf_filtered (stream, format, args);
2811 va_end (args);
2812}
2813
2814void
2815fprintf_unfiltered (struct ui_file *stream, const char *format, ...)
2816{
2817 va_list args;
cf7f2e2d 2818
5796c8dc
SS
2819 va_start (args, format);
2820 vfprintf_unfiltered (stream, format, args);
2821 va_end (args);
2822}
2823
2824/* Like fprintf_filtered, but prints its result indented.
2825 Called as fprintfi_filtered (spaces, stream, format, ...); */
2826
2827void
2828fprintfi_filtered (int spaces, struct ui_file *stream, const char *format,
2829 ...)
2830{
2831 va_list args;
cf7f2e2d 2832
5796c8dc
SS
2833 va_start (args, format);
2834 print_spaces_filtered (spaces, stream);
2835
2836 vfprintf_filtered (stream, format, args);
2837 va_end (args);
2838}
2839
2840
2841void
2842printf_filtered (const char *format, ...)
2843{
2844 va_list args;
cf7f2e2d 2845
5796c8dc
SS
2846 va_start (args, format);
2847 vfprintf_filtered (gdb_stdout, format, args);
2848 va_end (args);
2849}
2850
2851
2852void
2853printf_unfiltered (const char *format, ...)
2854{
2855 va_list args;
cf7f2e2d 2856
5796c8dc
SS
2857 va_start (args, format);
2858 vfprintf_unfiltered (gdb_stdout, format, args);
2859 va_end (args);
2860}
2861
2862/* Like printf_filtered, but prints it's result indented.
2863 Called as printfi_filtered (spaces, format, ...); */
2864
2865void
2866printfi_filtered (int spaces, const char *format, ...)
2867{
2868 va_list args;
cf7f2e2d 2869
5796c8dc
SS
2870 va_start (args, format);
2871 print_spaces_filtered (spaces, gdb_stdout);
2872 vfprintf_filtered (gdb_stdout, format, args);
2873 va_end (args);
2874}
2875
2876/* Easy -- but watch out!
2877
2878 This routine is *not* a replacement for puts()! puts() appends a newline.
2879 This one doesn't, and had better not! */
2880
2881void
2882puts_filtered (const char *string)
2883{
2884 fputs_filtered (string, gdb_stdout);
2885}
2886
2887void
2888puts_unfiltered (const char *string)
2889{
2890 fputs_unfiltered (string, gdb_stdout);
2891}
2892
2893/* Return a pointer to N spaces and a null. The pointer is good
2894 until the next call to here. */
2895char *
2896n_spaces (int n)
2897{
2898 char *t;
2899 static char *spaces = 0;
2900 static int max_spaces = -1;
2901
2902 if (n > max_spaces)
2903 {
2904 if (spaces)
2905 xfree (spaces);
2906 spaces = (char *) xmalloc (n + 1);
2907 for (t = spaces + n; t != spaces;)
2908 *--t = ' ';
2909 spaces[n] = '\0';
2910 max_spaces = n;
2911 }
2912
2913 return spaces + max_spaces - n;
2914}
2915
2916/* Print N spaces. */
2917void
2918print_spaces_filtered (int n, struct ui_file *stream)
2919{
2920 fputs_filtered (n_spaces (n), stream);
2921}
2922\f
2923/* C++/ObjC demangler stuff. */
2924
2925/* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2926 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2927 If the name is not mangled, or the language for the name is unknown, or
c50c785c 2928 demangling is off, the name is printed in its "raw" form. */
5796c8dc
SS
2929
2930void
2931fprintf_symbol_filtered (struct ui_file *stream, char *name,
2932 enum language lang, int arg_mode)
2933{
2934 char *demangled;
2935
2936 if (name != NULL)
2937 {
2938 /* If user wants to see raw output, no problem. */
2939 if (!demangle)
2940 {
2941 fputs_filtered (name, stream);
2942 }
2943 else
2944 {
2945 demangled = language_demangle (language_def (lang), name, arg_mode);
2946 fputs_filtered (demangled ? demangled : name, stream);
2947 if (demangled != NULL)
2948 {
2949 xfree (demangled);
2950 }
2951 }
2952 }
2953}
2954
2955/* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2956 differences in whitespace. Returns 0 if they match, non-zero if they
2957 don't (slightly different than strcmp()'s range of return values).
2958
2959 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2960 This "feature" is useful when searching for matching C++ function names
2961 (such as if the user types 'break FOO', where FOO is a mangled C++
c50c785c 2962 function). */
5796c8dc
SS
2963
2964int
2965strcmp_iw (const char *string1, const char *string2)
2966{
2967 while ((*string1 != '\0') && (*string2 != '\0'))
2968 {
2969 while (isspace (*string1))
2970 {
2971 string1++;
2972 }
2973 while (isspace (*string2))
2974 {
2975 string2++;
2976 }
2977 if (*string1 != *string2)
2978 {
2979 break;
2980 }
2981 if (*string1 != '\0')
2982 {
2983 string1++;
2984 string2++;
2985 }
2986 }
2987 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2988}
2989
2990/* This is like strcmp except that it ignores whitespace and treats
2991 '(' as the first non-NULL character in terms of ordering. Like
2992 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2993 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2994 according to that ordering.
2995
2996 If a list is sorted according to this function and if you want to
2997 find names in the list that match some fixed NAME according to
2998 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2999 where this function would put NAME.
3000
3001 Here are some examples of why using strcmp to sort is a bad idea:
3002
3003 Whitespace example:
3004
3005 Say your partial symtab contains: "foo<char *>", "goo". Then, if
3006 we try to do a search for "foo<char*>", strcmp will locate this
3007 after "foo<char *>" and before "goo". Then lookup_partial_symbol
3008 will start looking at strings beginning with "goo", and will never
3009 see the correct match of "foo<char *>".
3010
3011 Parenthesis example:
3012
3013 In practice, this is less like to be an issue, but I'll give it a
3014 shot. Let's assume that '$' is a legitimate character to occur in
3015 symbols. (Which may well even be the case on some systems.) Then
3016 say that the partial symbol table contains "foo$" and "foo(int)".
3017 strcmp will put them in this order, since '$' < '('. Now, if the
3018 user searches for "foo", then strcmp will sort "foo" before "foo$".
3019 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
3020 "foo") is false, so it won't proceed to the actual match of
3021 "foo(int)" with "foo". */
3022
3023int
3024strcmp_iw_ordered (const char *string1, const char *string2)
3025{
3026 while ((*string1 != '\0') && (*string2 != '\0'))
3027 {
3028 while (isspace (*string1))
3029 {
3030 string1++;
3031 }
3032 while (isspace (*string2))
3033 {
3034 string2++;
3035 }
3036 if (*string1 != *string2)
3037 {
3038 break;
3039 }
3040 if (*string1 != '\0')
3041 {
3042 string1++;
3043 string2++;
3044 }
3045 }
3046
3047 switch (*string1)
3048 {
3049 /* Characters are non-equal unless they're both '\0'; we want to
3050 make sure we get the comparison right according to our
3051 comparison in the cases where one of them is '\0' or '('. */
3052 case '\0':
3053 if (*string2 == '\0')
3054 return 0;
3055 else
3056 return -1;
3057 case '(':
3058 if (*string2 == '\0')
3059 return 1;
3060 else
3061 return -1;
3062 default:
3063 if (*string2 == '(')
3064 return 1;
3065 else
3066 return *string1 - *string2;
3067 }
3068}
3069
3070/* A simple comparison function with opposite semantics to strcmp. */
3071
3072int
3073streq (const char *lhs, const char *rhs)
3074{
3075 return !strcmp (lhs, rhs);
3076}
3077\f
3078
3079/*
3080 ** subset_compare()
3081 ** Answer whether string_to_compare is a full or partial match to
3082 ** template_string. The partial match must be in sequence starting
3083 ** at index 0.
3084 */
3085int
3086subset_compare (char *string_to_compare, char *template_string)
3087{
3088 int match;
cf7f2e2d 3089
5796c8dc
SS
3090 if (template_string != (char *) NULL && string_to_compare != (char *) NULL
3091 && strlen (string_to_compare) <= strlen (template_string))
3092 match =
3093 (strncmp
3094 (template_string, string_to_compare, strlen (string_to_compare)) == 0);
3095 else
3096 match = 0;
3097 return match;
3098}
3099
3100static void
3101pagination_on_command (char *arg, int from_tty)
3102{
3103 pagination_enabled = 1;
3104}
3105
3106static void
3107pagination_off_command (char *arg, int from_tty)
3108{
3109 pagination_enabled = 0;
3110}
3111
3112static void
3113show_debug_timestamp (struct ui_file *file, int from_tty,
3114 struct cmd_list_element *c, const char *value)
3115{
c50c785c
JM
3116 fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"),
3117 value);
5796c8dc
SS
3118}
3119\f
3120
3121void
3122initialize_utils (void)
3123{
5796c8dc
SS
3124 add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
3125Set number of characters gdb thinks are in a line."), _("\
3126Show number of characters gdb thinks are in a line."), NULL,
3127 set_width_command,
3128 show_chars_per_line,
3129 &setlist, &showlist);
3130
3131 add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\
3132Set number of lines gdb thinks are in a page."), _("\
3133Show number of lines gdb thinks are in a page."), NULL,
3134 set_height_command,
3135 show_lines_per_page,
3136 &setlist, &showlist);
3137
3138 init_page_info ();
3139
3140 add_setshow_boolean_cmd ("demangle", class_support, &demangle, _("\
3141Set demangling of encoded C++/ObjC names when displaying symbols."), _("\
3142Show demangling of encoded C++/ObjC names when displaying symbols."), NULL,
3143 NULL,
3144 show_demangle,
3145 &setprintlist, &showprintlist);
3146
3147 add_setshow_boolean_cmd ("pagination", class_support,
3148 &pagination_enabled, _("\
3149Set state of pagination."), _("\
3150Show state of pagination."), NULL,
3151 NULL,
3152 show_pagination_enabled,
3153 &setlist, &showlist);
3154
3155 if (xdb_commands)
3156 {
3157 add_com ("am", class_support, pagination_on_command,
3158 _("Enable pagination"));
3159 add_com ("sm", class_support, pagination_off_command,
3160 _("Disable pagination"));
3161 }
3162
3163 add_setshow_boolean_cmd ("sevenbit-strings", class_support,
3164 &sevenbit_strings, _("\
3165Set printing of 8-bit characters in strings as \\nnn."), _("\
3166Show printing of 8-bit characters in strings as \\nnn."), NULL,
3167 NULL,
3168 show_sevenbit_strings,
3169 &setprintlist, &showprintlist);
3170
3171 add_setshow_boolean_cmd ("asm-demangle", class_support, &asm_demangle, _("\
3172Set demangling of C++/ObjC names in disassembly listings."), _("\
3173Show demangling of C++/ObjC names in disassembly listings."), NULL,
3174 NULL,
3175 show_asm_demangle,
3176 &setprintlist, &showprintlist);
3177
3178 add_setshow_boolean_cmd ("timestamp", class_maintenance,
3179 &debug_timestamp, _("\
3180Set timestamping of debugging messages."), _("\
3181Show timestamping of debugging messages."), _("\
3182When set, debugging messages will be marked with seconds and microseconds."),
3183 NULL,
3184 show_debug_timestamp,
3185 &setdebuglist, &showdebuglist);
3186}
3187
c50c785c 3188/* Machine specific function to handle SIGWINCH signal. */
5796c8dc
SS
3189
3190#ifdef SIGWINCH_HANDLER_BODY
3191SIGWINCH_HANDLER_BODY
3192#endif
c50c785c
JM
3193/* Print routines to handle variable size regs, etc. */
3194/* Temporary storage using circular buffer. */
5796c8dc
SS
3195#define NUMCELLS 16
3196#define CELLSIZE 50
3197static char *
3198get_cell (void)
3199{
3200 static char buf[NUMCELLS][CELLSIZE];
3201 static int cell = 0;
cf7f2e2d 3202
5796c8dc
SS
3203 if (++cell >= NUMCELLS)
3204 cell = 0;
3205 return buf[cell];
3206}
3207
3208const char *
3209paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
3210{
3211 /* Truncate address to the size of a target address, avoiding shifts
3212 larger or equal than the width of a CORE_ADDR. The local
3213 variable ADDR_BIT stops the compiler reporting a shift overflow
c50c785c 3214 when it won't occur. */
5796c8dc
SS
3215 /* NOTE: This assumes that the significant address information is
3216 kept in the least significant bits of ADDR - the upper bits were
3217 either zero or sign extended. Should gdbarch_address_to_pointer or
3218 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
3219
3220 int addr_bit = gdbarch_addr_bit (gdbarch);
3221
3222 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
3223 addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
3224 return hex_string (addr);
3225}
3226
c50c785c
JM
3227/* This function is described in "defs.h". */
3228
3229const char *
3230print_core_address (struct gdbarch *gdbarch, CORE_ADDR address)
3231{
3232 int addr_bit = gdbarch_addr_bit (gdbarch);
3233
3234 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
3235 address &= ((CORE_ADDR) 1 << addr_bit) - 1;
3236
3237 /* FIXME: cagney/2002-05-03: Need local_address_string() function
3238 that returns the language localized string formatted to a width
3239 based on gdbarch_addr_bit. */
3240 if (addr_bit <= 32)
3241 return hex_string_custom (address, 8);
3242 else
3243 return hex_string_custom (address, 16);
3244}
3245
5796c8dc
SS
3246static char *
3247decimal2str (char *sign, ULONGEST addr, int width)
3248{
3249 /* Steal code from valprint.c:print_decimal(). Should this worry
c50c785c 3250 about the real size of addr as the above does? */
5796c8dc
SS
3251 unsigned long temp[3];
3252 char *str = get_cell ();
5796c8dc 3253 int i = 0;
cf7f2e2d 3254
5796c8dc
SS
3255 do
3256 {
3257 temp[i] = addr % (1000 * 1000 * 1000);
3258 addr /= (1000 * 1000 * 1000);
3259 i++;
3260 width -= 9;
3261 }
3262 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
3263
3264 width += 9;
3265 if (width < 0)
3266 width = 0;
3267
3268 switch (i)
3269 {
3270 case 1:
3271 xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]);
3272 break;
3273 case 2:
3274 xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width,
3275 temp[1], temp[0]);
3276 break;
3277 case 3:
3278 xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width,
3279 temp[2], temp[1], temp[0]);
3280 break;
3281 default:
3282 internal_error (__FILE__, __LINE__,
3283 _("failed internal consistency check"));
3284 }
3285
3286 return str;
3287}
3288
3289static char *
3290octal2str (ULONGEST addr, int width)
3291{
3292 unsigned long temp[3];
3293 char *str = get_cell ();
5796c8dc 3294 int i = 0;
cf7f2e2d 3295
5796c8dc
SS
3296 do
3297 {
3298 temp[i] = addr % (0100000 * 0100000);
3299 addr /= (0100000 * 0100000);
3300 i++;
3301 width -= 10;
3302 }
3303 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
3304
3305 width += 10;
3306 if (width < 0)
3307 width = 0;
3308
3309 switch (i)
3310 {
3311 case 1:
3312 if (temp[0] == 0)
3313 xsnprintf (str, CELLSIZE, "%*o", width, 0);
3314 else
3315 xsnprintf (str, CELLSIZE, "0%0*lo", width, temp[0]);
3316 break;
3317 case 2:
3318 xsnprintf (str, CELLSIZE, "0%0*lo%010lo", width, temp[1], temp[0]);
3319 break;
3320 case 3:
3321 xsnprintf (str, CELLSIZE, "0%0*lo%010lo%010lo", width,
3322 temp[2], temp[1], temp[0]);
3323 break;
3324 default:
3325 internal_error (__FILE__, __LINE__,
3326 _("failed internal consistency check"));
3327 }
3328
3329 return str;
3330}
3331
3332char *
3333pulongest (ULONGEST u)
3334{
3335 return decimal2str ("", u, 0);
3336}
3337
3338char *
3339plongest (LONGEST l)
3340{
3341 if (l < 0)
3342 return decimal2str ("-", -l, 0);
3343 else
3344 return decimal2str ("", l, 0);
3345}
3346
3347/* Eliminate warning from compiler on 32-bit systems. */
3348static int thirty_two = 32;
3349
3350char *
3351phex (ULONGEST l, int sizeof_l)
3352{
3353 char *str;
3354
3355 switch (sizeof_l)
3356 {
3357 case 8:
3358 str = get_cell ();
3359 xsnprintf (str, CELLSIZE, "%08lx%08lx",
3360 (unsigned long) (l >> thirty_two),
3361 (unsigned long) (l & 0xffffffff));
3362 break;
3363 case 4:
3364 str = get_cell ();
3365 xsnprintf (str, CELLSIZE, "%08lx", (unsigned long) l);
3366 break;
3367 case 2:
3368 str = get_cell ();
3369 xsnprintf (str, CELLSIZE, "%04x", (unsigned short) (l & 0xffff));
3370 break;
3371 default:
3372 str = phex (l, sizeof (l));
3373 break;
3374 }
3375
3376 return str;
3377}
3378
3379char *
3380phex_nz (ULONGEST l, int sizeof_l)
3381{
3382 char *str;
3383
3384 switch (sizeof_l)
3385 {
3386 case 8:
3387 {
3388 unsigned long high = (unsigned long) (l >> thirty_two);
cf7f2e2d 3389
5796c8dc
SS
3390 str = get_cell ();
3391 if (high == 0)
3392 xsnprintf (str, CELLSIZE, "%lx",
3393 (unsigned long) (l & 0xffffffff));
3394 else
3395 xsnprintf (str, CELLSIZE, "%lx%08lx", high,
3396 (unsigned long) (l & 0xffffffff));
3397 break;
3398 }
3399 case 4:
3400 str = get_cell ();
3401 xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l);
3402 break;
3403 case 2:
3404 str = get_cell ();
3405 xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff));
3406 break;
3407 default:
3408 str = phex_nz (l, sizeof (l));
3409 break;
3410 }
3411
3412 return str;
3413}
3414
3415/* Converts a LONGEST to a C-format hexadecimal literal and stores it
3416 in a static string. Returns a pointer to this string. */
3417char *
3418hex_string (LONGEST num)
3419{
3420 char *result = get_cell ();
cf7f2e2d 3421
5796c8dc
SS
3422 xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
3423 return result;
3424}
3425
3426/* Converts a LONGEST number to a C-format hexadecimal literal and
3427 stores it in a static string. Returns a pointer to this string
3428 that is valid until the next call. The number is padded on the
3429 left with 0s to at least WIDTH characters. */
3430char *
3431hex_string_custom (LONGEST num, int width)
3432{
3433 char *result = get_cell ();
3434 char *result_end = result + CELLSIZE - 1;
3435 const char *hex = phex_nz (num, sizeof (num));
3436 int hex_len = strlen (hex);
3437
3438 if (hex_len > width)
3439 width = hex_len;
3440 if (width + 2 >= CELLSIZE)
c50c785c
JM
3441 internal_error (__FILE__, __LINE__, _("\
3442hex_string_custom: insufficient space to store result"));
5796c8dc
SS
3443
3444 strcpy (result_end - width - 2, "0x");
3445 memset (result_end - width, '0', width);
3446 strcpy (result_end - hex_len, hex);
3447 return result_end - width - 2;
3448}
3449
3450/* Convert VAL to a numeral in the given radix. For
3451 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
3452 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
3453 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
3454 * to use C format in all cases. If it is false, then 'x'
c50c785c 3455 * and 'o' formats do not include a prefix (0x or leading 0). */
5796c8dc
SS
3456
3457char *
3458int_string (LONGEST val, int radix, int is_signed, int width,
3459 int use_c_format)
3460{
3461 switch (radix)
3462 {
3463 case 16:
3464 {
3465 char *result;
cf7f2e2d 3466
5796c8dc
SS
3467 if (width == 0)
3468 result = hex_string (val);
3469 else
3470 result = hex_string_custom (val, width);
3471 if (! use_c_format)
3472 result += 2;
3473 return result;
3474 }
3475 case 10:
3476 {
3477 if (is_signed && val < 0)
3478 return decimal2str ("-", -val, width);
3479 else
3480 return decimal2str ("", val, width);
3481 }
3482 case 8:
3483 {
3484 char *result = octal2str (val, width);
cf7f2e2d 3485
5796c8dc
SS
3486 if (use_c_format || val == 0)
3487 return result;
3488 else
3489 return result + 1;
3490 }
3491 default:
3492 internal_error (__FILE__, __LINE__,
3493 _("failed internal consistency check"));
3494 }
3495}
3496
3497/* Convert a CORE_ADDR into a string. */
3498const char *
3499core_addr_to_string (const CORE_ADDR addr)
3500{
3501 char *str = get_cell ();
cf7f2e2d 3502
5796c8dc
SS
3503 strcpy (str, "0x");
3504 strcat (str, phex (addr, sizeof (addr)));
3505 return str;
3506}
3507
3508const char *
3509core_addr_to_string_nz (const CORE_ADDR addr)
3510{
3511 char *str = get_cell ();
cf7f2e2d 3512
5796c8dc
SS
3513 strcpy (str, "0x");
3514 strcat (str, phex_nz (addr, sizeof (addr)));
3515 return str;
3516}
3517
3518/* Convert a string back into a CORE_ADDR. */
3519CORE_ADDR
3520string_to_core_addr (const char *my_string)
3521{
3522 CORE_ADDR addr = 0;
3523
3524 if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
3525 {
3526 /* Assume that it is in hex. */
3527 int i;
cf7f2e2d 3528
5796c8dc
SS
3529 for (i = 2; my_string[i] != '\0'; i++)
3530 {
3531 if (isdigit (my_string[i]))
3532 addr = (my_string[i] - '0') + (addr * 16);
3533 else if (isxdigit (my_string[i]))
3534 addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
3535 else
3536 error (_("invalid hex \"%s\""), my_string);
3537 }
3538 }
3539 else
3540 {
3541 /* Assume that it is in decimal. */
3542 int i;
cf7f2e2d 3543
5796c8dc
SS
3544 for (i = 0; my_string[i] != '\0'; i++)
3545 {
3546 if (isdigit (my_string[i]))
3547 addr = (my_string[i] - '0') + (addr * 10);
3548 else
3549 error (_("invalid decimal \"%s\""), my_string);
3550 }
3551 }
3552
3553 return addr;
3554}
3555
3556const char *
3557host_address_to_string (const void *addr)
3558{
3559 char *str = get_cell ();
3560
3561 xsnprintf (str, CELLSIZE, "0x%s", phex_nz ((uintptr_t) addr, sizeof (addr)));
3562 return str;
3563}
3564
3565char *
3566gdb_realpath (const char *filename)
3567{
3568 /* Method 1: The system has a compile time upper bound on a filename
3569 path. Use that and realpath() to canonicalize the name. This is
3570 the most common case. Note that, if there isn't a compile time
3571 upper bound, you want to avoid realpath() at all costs. */
3572#if defined(HAVE_REALPATH)
3573 {
3574# if defined (PATH_MAX)
3575 char buf[PATH_MAX];
3576# define USE_REALPATH
3577# elif defined (MAXPATHLEN)
3578 char buf[MAXPATHLEN];
3579# define USE_REALPATH
3580# endif
3581# if defined (USE_REALPATH)
3582 const char *rp = realpath (filename, buf);
cf7f2e2d 3583
5796c8dc
SS
3584 if (rp == NULL)
3585 rp = filename;
3586 return xstrdup (rp);
3587# endif
3588 }
3589#endif /* HAVE_REALPATH */
3590
3591 /* Method 2: The host system (i.e., GNU) has the function
3592 canonicalize_file_name() which malloc's a chunk of memory and
3593 returns that, use that. */
3594#if defined(HAVE_CANONICALIZE_FILE_NAME)
3595 {
3596 char *rp = canonicalize_file_name (filename);
cf7f2e2d 3597
5796c8dc
SS
3598 if (rp == NULL)
3599 return xstrdup (filename);
3600 else
3601 return rp;
3602 }
3603#endif
3604
3605 /* FIXME: cagney/2002-11-13:
3606
3607 Method 2a: Use realpath() with a NULL buffer. Some systems, due
3608 to the problems described in in method 3, have modified their
3609 realpath() implementation so that it will allocate a buffer when
3610 NULL is passed in. Before this can be used, though, some sort of
3611 configure time test would need to be added. Otherwize the code
3612 will likely core dump. */
3613
3614 /* Method 3: Now we're getting desperate! The system doesn't have a
3615 compile time buffer size and no alternative function. Query the
3616 OS, using pathconf(), for the buffer limit. Care is needed
3617 though, some systems do not limit PATH_MAX (return -1 for
3618 pathconf()) making it impossible to pass a correctly sized buffer
3619 to realpath() (it could always overflow). On those systems, we
3620 skip this. */
3621#if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
3622 {
3623 /* Find out the max path size. */
3624 long path_max = pathconf ("/", _PC_PATH_MAX);
cf7f2e2d 3625
5796c8dc
SS
3626 if (path_max > 0)
3627 {
3628 /* PATH_MAX is bounded. */
3629 char *buf = alloca (path_max);
3630 char *rp = realpath (filename, buf);
cf7f2e2d 3631
5796c8dc
SS
3632 return xstrdup (rp ? rp : filename);
3633 }
3634 }
3635#endif
3636
3637 /* This system is a lost cause, just dup the buffer. */
3638 return xstrdup (filename);
3639}
3640
3641/* Return a copy of FILENAME, with its directory prefix canonicalized
3642 by gdb_realpath. */
3643
3644char *
3645xfullpath (const char *filename)
3646{
3647 const char *base_name = lbasename (filename);
3648 char *dir_name;
3649 char *real_path;
3650 char *result;
3651
3652 /* Extract the basename of filename, and return immediately
c50c785c 3653 a copy of filename if it does not contain any directory prefix. */
5796c8dc
SS
3654 if (base_name == filename)
3655 return xstrdup (filename);
3656
3657 dir_name = alloca ((size_t) (base_name - filename + 2));
3658 /* Allocate enough space to store the dir_name + plus one extra
3659 character sometimes needed under Windows (see below), and
c50c785c 3660 then the closing \000 character. */
5796c8dc
SS
3661 strncpy (dir_name, filename, base_name - filename);
3662 dir_name[base_name - filename] = '\000';
3663
3664#ifdef HAVE_DOS_BASED_FILE_SYSTEM
3665 /* We need to be careful when filename is of the form 'd:foo', which
3666 is equivalent of d:./foo, which is totally different from d:/foo. */
3667 if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':')
3668 {
3669 dir_name[2] = '.';
3670 dir_name[3] = '\000';
3671 }
3672#endif
3673
3674 /* Canonicalize the directory prefix, and build the resulting
c50c785c 3675 filename. If the dirname realpath already contains an ending
5796c8dc
SS
3676 directory separator, avoid doubling it. */
3677 real_path = gdb_realpath (dir_name);
3678 if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
cf7f2e2d 3679 result = concat (real_path, base_name, (char *) NULL);
5796c8dc 3680 else
cf7f2e2d 3681 result = concat (real_path, SLASH_STRING, base_name, (char *) NULL);
5796c8dc
SS
3682
3683 xfree (real_path);
3684 return result;
3685}
3686
3687
3688/* This is the 32-bit CRC function used by the GNU separate debug
3689 facility. An executable may contain a section named
3690 .gnu_debuglink, which holds the name of a separate executable file
3691 containing its debug info, and a checksum of that file's contents,
3692 computed using this function. */
3693unsigned long
3694gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len)
3695{
3696 static const unsigned int crc32_table[256] = {
3697 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3698 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3699 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3700 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3701 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3702 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3703 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3704 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3705 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3706 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3707 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3708 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3709 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3710 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3711 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3712 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3713 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3714 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3715 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3716 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3717 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3718 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3719 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3720 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3721 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3722 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3723 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3724 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3725 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3726 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3727 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3728 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3729 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3730 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3731 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3732 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3733 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3734 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3735 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3736 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3737 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3738 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3739 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3740 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3741 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3742 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3743 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3744 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3745 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3746 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3747 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3748 0x2d02ef8d
3749 };
3750 unsigned char *end;
3751
3752 crc = ~crc & 0xffffffff;
3753 for (end = buf + len; buf < end; ++buf)
3754 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
c50c785c 3755 return ~crc & 0xffffffff;
5796c8dc
SS
3756}
3757
3758ULONGEST
3759align_up (ULONGEST v, int n)
3760{
3761 /* Check that N is really a power of two. */
3762 gdb_assert (n && (n & (n-1)) == 0);
3763 return (v + n - 1) & -n;
3764}
3765
3766ULONGEST
3767align_down (ULONGEST v, int n)
3768{
3769 /* Check that N is really a power of two. */
3770 gdb_assert (n && (n & (n-1)) == 0);
3771 return (v & -n);
3772}
3773
3774/* Allocation function for the libiberty hash table which uses an
3775 obstack. The obstack is passed as DATA. */
3776
3777void *
3778hashtab_obstack_allocate (void *data, size_t size, size_t count)
3779{
3780 unsigned int total = size * count;
3781 void *ptr = obstack_alloc ((struct obstack *) data, total);
cf7f2e2d 3782
5796c8dc
SS
3783 memset (ptr, 0, total);
3784 return ptr;
3785}
3786
3787/* Trivial deallocation function for the libiberty splay tree and hash
3788 table - don't deallocate anything. Rely on later deletion of the
3789 obstack. DATA will be the obstack, although it is not needed
3790 here. */
3791
3792void
3793dummy_obstack_deallocate (void *object, void *data)
3794{
3795 return;
3796}
3797
3798/* The bit offset of the highest byte in a ULONGEST, for overflow
3799 checking. */
3800
3801#define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3802
3803/* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3804 where 2 <= BASE <= 36. */
3805
3806static int
3807is_digit_in_base (unsigned char digit, int base)
3808{
3809 if (!isalnum (digit))
3810 return 0;
3811 if (base <= 10)
3812 return (isdigit (digit) && digit < base + '0');
3813 else
3814 return (isdigit (digit) || tolower (digit) < base - 10 + 'a');
3815}
3816
3817static int
3818digit_to_int (unsigned char c)
3819{
3820 if (isdigit (c))
3821 return c - '0';
3822 else
3823 return tolower (c) - 'a' + 10;
3824}
3825