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