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