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