Move GDB producer parsing routines to a separate file
[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 (&quit_handler, default_quit_handler),
908       m_ui (NULL)
909   {
910     target_terminal::ours ();
911     ui_register_input_event_handler (current_ui);
912     if (current_ui->prompt_state == PROMPT_BLOCKED)
913       m_ui = current_ui;
914   }
915
916   ~scoped_input_handler ()
917   {
918     if (m_ui != NULL)
919       ui_unregister_input_event_handler (m_ui);
920   }
921
922   DISABLE_COPY_AND_ASSIGN (scoped_input_handler);
923
924 private:
925
926   /* Save and restore the terminal state.  */
927   target_terminal::scoped_restore_terminal_state m_term_state;
928
929   /* Save and restore the quit handler.  */
930   scoped_restore_tmpl<quit_handler_ftype *> m_quit_handler;
931
932   /* The saved UI, if non-NULL.  */
933   struct ui *m_ui;
934 };
935
936 \f
937
938 /* This function supports the query, nquery, and yquery functions.
939    Ask user a y-or-n question and return 0 if answer is no, 1 if
940    answer is yes, or default the answer to the specified default
941    (for yquery or nquery).  DEFCHAR may be 'y' or 'n' to provide a
942    default answer, or '\0' for no default.
943    CTLSTR is the control string and should end in "? ".  It should
944    not say how to answer, because we do that.
945    ARGS are the arguments passed along with the CTLSTR argument to
946    printf.  */
947
948 static int ATTRIBUTE_PRINTF (1, 0)
949 defaulted_query (const char *ctlstr, const char defchar, va_list args)
950 {
951   int ans2;
952   int retval;
953   int def_value;
954   char def_answer, not_def_answer;
955   const char *y_string, *n_string;
956   char *question, *prompt;
957   struct cleanup *old_chain;
958
959   /* Set up according to which answer is the default.  */
960   if (defchar == '\0')
961     {
962       def_value = 1;
963       def_answer = 'Y';
964       not_def_answer = 'N';
965       y_string = "y";
966       n_string = "n";
967     }
968   else if (defchar == 'y')
969     {
970       def_value = 1;
971       def_answer = 'Y';
972       not_def_answer = 'N';
973       y_string = "[y]";
974       n_string = "n";
975     }
976   else
977     {
978       def_value = 0;
979       def_answer = 'N';
980       not_def_answer = 'Y';
981       y_string = "y";
982       n_string = "[n]";
983     }
984
985   /* Automatically answer the default value if the user did not want
986      prompts or the command was issued with the server prefix.  */
987   if (!confirm || server_command)
988     return def_value;
989
990   /* If input isn't coming from the user directly, just say what
991      question we're asking, and then answer the default automatically.  This
992      way, important error messages don't get lost when talking to GDB
993      over a pipe.  */
994   if (current_ui->instream != current_ui->stdin_stream
995       || !input_interactive_p (current_ui)
996       /* Restrict queries to the main UI.  */
997       || current_ui != main_ui)
998     {
999       target_terminal::scoped_restore_terminal_state term_state;
1000       target_terminal::ours_for_output ();
1001       wrap_here ("");
1002       vfprintf_filtered (gdb_stdout, ctlstr, args);
1003
1004       printf_filtered (_("(%s or %s) [answered %c; "
1005                          "input not from terminal]\n"),
1006                        y_string, n_string, def_answer);
1007       gdb_flush (gdb_stdout);
1008
1009       return def_value;
1010     }
1011
1012   if (deprecated_query_hook)
1013     {
1014       target_terminal::scoped_restore_terminal_state term_state;
1015       return deprecated_query_hook (ctlstr, args);
1016     }
1017
1018   /* Format the question outside of the loop, to avoid reusing args.  */
1019   question = xstrvprintf (ctlstr, args);
1020   old_chain = make_cleanup (xfree, question);
1021   prompt = xstrprintf (_("%s%s(%s or %s) %s"),
1022                       annotation_level > 1 ? "\n\032\032pre-query\n" : "",
1023                       question, y_string, n_string,
1024                       annotation_level > 1 ? "\n\032\032query\n" : "");
1025   make_cleanup (xfree, prompt);
1026
1027   /* Used to add duration we waited for user to respond to
1028      prompt_for_continue_wait_time.  */
1029   using namespace std::chrono;
1030   steady_clock::time_point prompt_started = steady_clock::now ();
1031
1032   scoped_input_handler prepare_input;
1033
1034   while (1)
1035     {
1036       char *response, answer;
1037
1038       gdb_flush (gdb_stdout);
1039       response = gdb_readline_wrapper (prompt);
1040
1041       if (response == NULL)     /* C-d  */
1042         {
1043           printf_filtered ("EOF [assumed %c]\n", def_answer);
1044           retval = def_value;
1045           break;
1046         }
1047
1048       answer = response[0];
1049       xfree (response);
1050
1051       if (answer >= 'a')
1052         answer -= 040;
1053       /* Check answer.  For the non-default, the user must specify
1054          the non-default explicitly.  */
1055       if (answer == not_def_answer)
1056         {
1057           retval = !def_value;
1058           break;
1059         }
1060       /* Otherwise, if a default was specified, the user may either
1061          specify the required input or have it default by entering
1062          nothing.  */
1063       if (answer == def_answer
1064           || (defchar != '\0' && answer == '\0'))
1065         {
1066           retval = def_value;
1067           break;
1068         }
1069       /* Invalid entries are not defaulted and require another selection.  */
1070       printf_filtered (_("Please answer %s or %s.\n"),
1071                        y_string, n_string);
1072     }
1073
1074   /* Add time spend in this routine to prompt_for_continue_wait_time.  */
1075   prompt_for_continue_wait_time += steady_clock::now () - prompt_started;
1076
1077   if (annotation_level > 1)
1078     printf_filtered (("\n\032\032post-query\n"));
1079   do_cleanups (old_chain);
1080   return retval;
1081 }
1082 \f
1083
1084 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1085    answer is yes, or 0 if answer is defaulted.
1086    Takes three args which are given to printf to print the question.
1087    The first, a control string, should end in "? ".
1088    It should not say how to answer, because we do that.  */
1089
1090 int
1091 nquery (const char *ctlstr, ...)
1092 {
1093   va_list args;
1094   int ret;
1095
1096   va_start (args, ctlstr);
1097   ret = defaulted_query (ctlstr, 'n', args);
1098   va_end (args);
1099   return ret;
1100 }
1101
1102 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1103    answer is yes, or 1 if answer is defaulted.
1104    Takes three args which are given to printf to print the question.
1105    The first, a control string, should end in "? ".
1106    It should not say how to answer, because we do that.  */
1107
1108 int
1109 yquery (const char *ctlstr, ...)
1110 {
1111   va_list args;
1112   int ret;
1113
1114   va_start (args, ctlstr);
1115   ret = defaulted_query (ctlstr, 'y', args);
1116   va_end (args);
1117   return ret;
1118 }
1119
1120 /* Ask user a y-or-n question and return 1 iff answer is yes.
1121    Takes three args which are given to printf to print the question.
1122    The first, a control string, should end in "? ".
1123    It should not say how to answer, because we do that.  */
1124
1125 int
1126 query (const char *ctlstr, ...)
1127 {
1128   va_list args;
1129   int ret;
1130
1131   va_start (args, ctlstr);
1132   ret = defaulted_query (ctlstr, '\0', args);
1133   va_end (args);
1134   return ret;
1135 }
1136
1137 /* A helper for parse_escape that converts a host character to a
1138    target character.  C is the host character.  If conversion is
1139    possible, then the target character is stored in *TARGET_C and the
1140    function returns 1.  Otherwise, the function returns 0.  */
1141
1142 static int
1143 host_char_to_target (struct gdbarch *gdbarch, int c, int *target_c)
1144 {
1145   char the_char = c;
1146   int result = 0;
1147
1148   auto_obstack host_data;
1149
1150   convert_between_encodings (target_charset (gdbarch), host_charset (),
1151                              (gdb_byte *) &the_char, 1, 1,
1152                              &host_data, translit_none);
1153
1154   if (obstack_object_size (&host_data) == 1)
1155     {
1156       result = 1;
1157       *target_c = *(char *) obstack_base (&host_data);
1158     }
1159
1160   return result;
1161 }
1162
1163 /* Parse a C escape sequence.  STRING_PTR points to a variable
1164    containing a pointer to the string to parse.  That pointer
1165    should point to the character after the \.  That pointer
1166    is updated past the characters we use.  The value of the
1167    escape sequence is returned.
1168
1169    A negative value means the sequence \ newline was seen,
1170    which is supposed to be equivalent to nothing at all.
1171
1172    If \ is followed by a null character, we return a negative
1173    value and leave the string pointer pointing at the null character.
1174
1175    If \ is followed by 000, we return 0 and leave the string pointer
1176    after the zeros.  A value of 0 does not mean end of string.  */
1177
1178 int
1179 parse_escape (struct gdbarch *gdbarch, const char **string_ptr)
1180 {
1181   int target_char = -2; /* Initialize to avoid GCC warnings.  */
1182   int c = *(*string_ptr)++;
1183
1184   switch (c)
1185     {
1186       case '\n':
1187         return -2;
1188       case 0:
1189         (*string_ptr)--;
1190         return 0;
1191
1192       case '0':
1193       case '1':
1194       case '2':
1195       case '3':
1196       case '4':
1197       case '5':
1198       case '6':
1199       case '7':
1200         {
1201           int i = host_hex_value (c);
1202           int count = 0;
1203           while (++count < 3)
1204             {
1205               c = (**string_ptr);
1206               if (isdigit (c) && c != '8' && c != '9')
1207                 {
1208                   (*string_ptr)++;
1209                   i *= 8;
1210                   i += host_hex_value (c);
1211                 }
1212               else
1213                 {
1214                   break;
1215                 }
1216             }
1217           return i;
1218         }
1219
1220     case 'a':
1221       c = '\a';
1222       break;
1223     case 'b':
1224       c = '\b';
1225       break;
1226     case 'f':
1227       c = '\f';
1228       break;
1229     case 'n':
1230       c = '\n';
1231       break;
1232     case 'r':
1233       c = '\r';
1234       break;
1235     case 't':
1236       c = '\t';
1237       break;
1238     case 'v':
1239       c = '\v';
1240       break;
1241
1242     default:
1243       break;
1244     }
1245
1246   if (!host_char_to_target (gdbarch, c, &target_char))
1247     error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1248              " which has no equivalent\nin the `%s' character set."),
1249            c, c, target_charset (gdbarch));
1250   return target_char;
1251 }
1252 \f
1253 /* Print the character C on STREAM as part of the contents of a literal
1254    string whose delimiter is QUOTER.  Note that this routine should only
1255    be called for printing things which are independent of the language
1256    of the program being debugged.
1257
1258    printchar will normally escape backslashes and instances of QUOTER. If
1259    QUOTER is 0, printchar won't escape backslashes or any quoting character.
1260    As a side effect, if you pass the backslash character as the QUOTER,
1261    printchar will escape backslashes as usual, but not any other quoting
1262    character. */
1263
1264 static void
1265 printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
1266            void (*do_fprintf) (struct ui_file *, const char *, ...)
1267            ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter)
1268 {
1269   c &= 0xFF;                    /* Avoid sign bit follies */
1270
1271   if (c < 0x20 ||               /* Low control chars */
1272       (c >= 0x7F && c < 0xA0) ||        /* DEL, High controls */
1273       (sevenbit_strings && c >= 0x80))
1274     {                           /* high order bit set */
1275       switch (c)
1276         {
1277         case '\n':
1278           do_fputs ("\\n", stream);
1279           break;
1280         case '\b':
1281           do_fputs ("\\b", stream);
1282           break;
1283         case '\t':
1284           do_fputs ("\\t", stream);
1285           break;
1286         case '\f':
1287           do_fputs ("\\f", stream);
1288           break;
1289         case '\r':
1290           do_fputs ("\\r", stream);
1291           break;
1292         case '\033':
1293           do_fputs ("\\e", stream);
1294           break;
1295         case '\007':
1296           do_fputs ("\\a", stream);
1297           break;
1298         default:
1299           do_fprintf (stream, "\\%.3o", (unsigned int) c);
1300           break;
1301         }
1302     }
1303   else
1304     {
1305       if (quoter != 0 && (c == '\\' || c == quoter))
1306         do_fputs ("\\", stream);
1307       do_fprintf (stream, "%c", c);
1308     }
1309 }
1310
1311 /* Print the character C on STREAM as part of the contents of a
1312    literal string whose delimiter is QUOTER.  Note that these routines
1313    should only be call for printing things which are independent of
1314    the language of the program being debugged.  */
1315
1316 void
1317 fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
1318 {
1319   while (*str)
1320     printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
1321 }
1322
1323 void
1324 fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
1325 {
1326   while (*str)
1327     printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1328 }
1329
1330 void
1331 fputstrn_filtered (const char *str, int n, int quoter,
1332                    struct ui_file *stream)
1333 {
1334   int i;
1335
1336   for (i = 0; i < n; i++)
1337     printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter);
1338 }
1339
1340 void
1341 fputstrn_unfiltered (const char *str, int n, int quoter,
1342                      struct ui_file *stream)
1343 {
1344   int i;
1345
1346   for (i = 0; i < n; i++)
1347     printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1348 }
1349 \f
1350
1351 /* Number of lines per page or UINT_MAX if paging is disabled.  */
1352 static unsigned int lines_per_page;
1353 static void
1354 show_lines_per_page (struct ui_file *file, int from_tty,
1355                      struct cmd_list_element *c, const char *value)
1356 {
1357   fprintf_filtered (file,
1358                     _("Number of lines gdb thinks are in a page is %s.\n"),
1359                     value);
1360 }
1361
1362 /* Number of chars per line or UINT_MAX if line folding is disabled.  */
1363 static unsigned int chars_per_line;
1364 static void
1365 show_chars_per_line (struct ui_file *file, int from_tty,
1366                      struct cmd_list_element *c, const char *value)
1367 {
1368   fprintf_filtered (file,
1369                     _("Number of characters gdb thinks "
1370                       "are in a line is %s.\n"),
1371                     value);
1372 }
1373
1374 /* Current count of lines printed on this page, chars on this line.  */
1375 static unsigned int lines_printed, chars_printed;
1376
1377 /* Buffer and start column of buffered text, for doing smarter word-
1378    wrapping.  When someone calls wrap_here(), we start buffering output
1379    that comes through fputs_filtered().  If we see a newline, we just
1380    spit it out and forget about the wrap_here().  If we see another
1381    wrap_here(), we spit it out and remember the newer one.  If we see
1382    the end of the line, we spit out a newline, the indent, and then
1383    the buffered output.  */
1384
1385 /* Malloc'd buffer with chars_per_line+2 bytes.  Contains characters which
1386    are waiting to be output (they have already been counted in chars_printed).
1387    When wrap_buffer[0] is null, the buffer is empty.  */
1388 static char *wrap_buffer;
1389
1390 /* Pointer in wrap_buffer to the next character to fill.  */
1391 static char *wrap_pointer;
1392
1393 /* String to indent by if the wrap occurs.  Must not be NULL if wrap_column
1394    is non-zero.  */
1395 static const char *wrap_indent;
1396
1397 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1398    is not in effect.  */
1399 static int wrap_column;
1400 \f
1401
1402 /* Initialize the number of lines per page and chars per line.  */
1403
1404 void
1405 init_page_info (void)
1406 {
1407   if (batch_flag)
1408     {
1409       lines_per_page = UINT_MAX;
1410       chars_per_line = UINT_MAX;
1411     }
1412   else
1413 #if defined(TUI)
1414   if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
1415 #endif
1416     {
1417       int rows, cols;
1418
1419 #if defined(__GO32__)
1420       rows = ScreenRows ();
1421       cols = ScreenCols ();
1422       lines_per_page = rows;
1423       chars_per_line = cols;
1424 #else
1425       /* Make sure Readline has initialized its terminal settings.  */
1426       rl_reset_terminal (NULL);
1427
1428       /* Get the screen size from Readline.  */
1429       rl_get_screen_size (&rows, &cols);
1430       lines_per_page = rows;
1431       chars_per_line = cols;
1432
1433       /* Readline should have fetched the termcap entry for us.
1434          Only try to use tgetnum function if rl_get_screen_size
1435          did not return a useful value. */
1436       if (((rows <= 0) && (tgetnum ((char *) "li") < 0))
1437         /* Also disable paging if inside Emacs.  $EMACS was used
1438            before Emacs v25.1, $INSIDE_EMACS is used since then.  */
1439           || getenv ("EMACS") || getenv ("INSIDE_EMACS"))
1440         {
1441           /* The number of lines per page is not mentioned in the terminal
1442              description or EMACS evironment variable is set.  This probably
1443              means that paging is not useful, so disable paging.  */
1444           lines_per_page = UINT_MAX;
1445         }
1446
1447       /* If the output is not a terminal, don't paginate it.  */
1448       if (!ui_file_isatty (gdb_stdout))
1449         lines_per_page = UINT_MAX;
1450 #endif
1451     }
1452
1453   /* We handle SIGWINCH ourselves.  */
1454   rl_catch_sigwinch = 0;
1455
1456   set_screen_size ();
1457   set_width ();
1458 }
1459
1460 /* Return nonzero if filtered printing is initialized.  */
1461 int
1462 filtered_printing_initialized (void)
1463 {
1464   return wrap_buffer != NULL;
1465 }
1466
1467 /* Helper for make_cleanup_restore_page_info.  */
1468
1469 static void
1470 do_restore_page_info_cleanup (void *arg)
1471 {
1472   set_screen_size ();
1473   set_width ();
1474 }
1475
1476 /* Provide cleanup for restoring the terminal size.  */
1477
1478 struct cleanup *
1479 make_cleanup_restore_page_info (void)
1480 {
1481   struct cleanup *back_to;
1482
1483   back_to = make_cleanup (do_restore_page_info_cleanup, NULL);
1484   make_cleanup_restore_uinteger (&lines_per_page);
1485   make_cleanup_restore_uinteger (&chars_per_line);
1486
1487   return back_to;
1488 }
1489
1490 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
1491    Provide cleanup for restoring the original state.  */
1492
1493 struct cleanup *
1494 set_batch_flag_and_make_cleanup_restore_page_info (void)
1495 {
1496   struct cleanup *back_to = make_cleanup_restore_page_info ();
1497   
1498   make_cleanup_restore_integer (&batch_flag);
1499   batch_flag = 1;
1500   init_page_info ();
1501
1502   return back_to;
1503 }
1504
1505 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE.  */
1506
1507 static void
1508 set_screen_size (void)
1509 {
1510   int rows = lines_per_page;
1511   int cols = chars_per_line;
1512
1513   if (rows <= 0)
1514     rows = INT_MAX;
1515
1516   if (cols <= 0)
1517     cols = INT_MAX;
1518
1519   /* Update Readline's idea of the terminal size.  */
1520   rl_set_screen_size (rows, cols);
1521 }
1522
1523 /* Reinitialize WRAP_BUFFER according to the current value of
1524    CHARS_PER_LINE.  */
1525
1526 static void
1527 set_width (void)
1528 {
1529   if (chars_per_line == 0)
1530     init_page_info ();
1531
1532   if (!wrap_buffer)
1533     {
1534       wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1535       wrap_buffer[0] = '\0';
1536     }
1537   else
1538     wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1539   wrap_pointer = wrap_buffer;   /* Start it at the beginning.  */
1540 }
1541
1542 static void
1543 set_width_command (char *args, int from_tty, struct cmd_list_element *c)
1544 {
1545   set_screen_size ();
1546   set_width ();
1547 }
1548
1549 static void
1550 set_height_command (char *args, int from_tty, struct cmd_list_element *c)
1551 {
1552   set_screen_size ();
1553 }
1554
1555 /* See utils.h.  */
1556
1557 void
1558 set_screen_width_and_height (int width, int height)
1559 {
1560   lines_per_page = height;
1561   chars_per_line = width;
1562
1563   set_screen_size ();
1564   set_width ();
1565 }
1566
1567 /* Wait, so the user can read what's on the screen.  Prompt the user
1568    to continue by pressing RETURN.  'q' is also provided because
1569    telling users what to do in the prompt is more user-friendly than
1570    expecting them to think of Ctrl-C/SIGINT.  */
1571
1572 static void
1573 prompt_for_continue (void)
1574 {
1575   char *ignore;
1576   char cont_prompt[120];
1577   struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1578   /* Used to add duration we waited for user to respond to
1579      prompt_for_continue_wait_time.  */
1580   using namespace std::chrono;
1581   steady_clock::time_point prompt_started = steady_clock::now ();
1582
1583   if (annotation_level > 1)
1584     printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1585
1586   strcpy (cont_prompt,
1587           "---Type <return> to continue, or q <return> to quit---");
1588   if (annotation_level > 1)
1589     strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1590
1591   /* We must do this *before* we call gdb_readline_wrapper, else it
1592      will eventually call us -- thinking that we're trying to print
1593      beyond the end of the screen.  */
1594   reinitialize_more_filter ();
1595
1596   scoped_input_handler prepare_input;
1597
1598   /* Call gdb_readline_wrapper, not readline, in order to keep an
1599      event loop running.  */
1600   ignore = gdb_readline_wrapper (cont_prompt);
1601   make_cleanup (xfree, ignore);
1602
1603   /* Add time spend in this routine to prompt_for_continue_wait_time.  */
1604   prompt_for_continue_wait_time += steady_clock::now () - prompt_started;
1605
1606   if (annotation_level > 1)
1607     printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1608
1609   if (ignore != NULL)
1610     {
1611       char *p = ignore;
1612
1613       while (*p == ' ' || *p == '\t')
1614         ++p;
1615       if (p[0] == 'q')
1616         /* Do not call quit here; there is no possibility of SIGINT.  */
1617         throw_quit ("Quit");
1618     }
1619
1620   /* Now we have to do this again, so that GDB will know that it doesn't
1621      need to save the ---Type <return>--- line at the top of the screen.  */
1622   reinitialize_more_filter ();
1623
1624   dont_repeat ();               /* Forget prev cmd -- CR won't repeat it.  */
1625
1626   do_cleanups (old_chain);
1627 }
1628
1629 /* Initialize timer to keep track of how long we waited for the user.  */
1630
1631 void
1632 reset_prompt_for_continue_wait_time (void)
1633 {
1634   using namespace std::chrono;
1635
1636   prompt_for_continue_wait_time = steady_clock::duration::zero ();
1637 }
1638
1639 /* Fetch the cumulative time spent in prompt_for_continue.  */
1640
1641 std::chrono::steady_clock::duration
1642 get_prompt_for_continue_wait_time ()
1643 {
1644   return prompt_for_continue_wait_time;
1645 }
1646
1647 /* Reinitialize filter; ie. tell it to reset to original values.  */
1648
1649 void
1650 reinitialize_more_filter (void)
1651 {
1652   lines_printed = 0;
1653   chars_printed = 0;
1654 }
1655
1656 /* Indicate that if the next sequence of characters overflows the line,
1657    a newline should be inserted here rather than when it hits the end.
1658    If INDENT is non-null, it is a string to be printed to indent the
1659    wrapped part on the next line.  INDENT must remain accessible until
1660    the next call to wrap_here() or until a newline is printed through
1661    fputs_filtered().
1662
1663    If the line is already overfull, we immediately print a newline and
1664    the indentation, and disable further wrapping.
1665
1666    If we don't know the width of lines, but we know the page height,
1667    we must not wrap words, but should still keep track of newlines
1668    that were explicitly printed.
1669
1670    INDENT should not contain tabs, as that will mess up the char count
1671    on the next line.  FIXME.
1672
1673    This routine is guaranteed to force out any output which has been
1674    squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1675    used to force out output from the wrap_buffer.  */
1676
1677 void
1678 wrap_here (const char *indent)
1679 {
1680   /* This should have been allocated, but be paranoid anyway.  */
1681   if (!wrap_buffer)
1682     internal_error (__FILE__, __LINE__,
1683                     _("failed internal consistency check"));
1684
1685   if (wrap_buffer[0])
1686     {
1687       *wrap_pointer = '\0';
1688       fputs_unfiltered (wrap_buffer, gdb_stdout);
1689     }
1690   wrap_pointer = wrap_buffer;
1691   wrap_buffer[0] = '\0';
1692   if (chars_per_line == UINT_MAX)       /* No line overflow checking.  */
1693     {
1694       wrap_column = 0;
1695     }
1696   else if (chars_printed >= chars_per_line)
1697     {
1698       puts_filtered ("\n");
1699       if (indent != NULL)
1700         puts_filtered (indent);
1701       wrap_column = 0;
1702     }
1703   else
1704     {
1705       wrap_column = chars_printed;
1706       if (indent == NULL)
1707         wrap_indent = "";
1708       else
1709         wrap_indent = indent;
1710     }
1711 }
1712
1713 /* Print input string to gdb_stdout, filtered, with wrap, 
1714    arranging strings in columns of n chars.  String can be
1715    right or left justified in the column.  Never prints 
1716    trailing spaces.  String should never be longer than
1717    width.  FIXME: this could be useful for the EXAMINE 
1718    command, which currently doesn't tabulate very well.  */
1719
1720 void
1721 puts_filtered_tabular (char *string, int width, int right)
1722 {
1723   int spaces = 0;
1724   int stringlen;
1725   char *spacebuf;
1726
1727   gdb_assert (chars_per_line > 0);
1728   if (chars_per_line == UINT_MAX)
1729     {
1730       fputs_filtered (string, gdb_stdout);
1731       fputs_filtered ("\n", gdb_stdout);
1732       return;
1733     }
1734
1735   if (((chars_printed - 1) / width + 2) * width >= chars_per_line)
1736     fputs_filtered ("\n", gdb_stdout);
1737
1738   if (width >= chars_per_line)
1739     width = chars_per_line - 1;
1740
1741   stringlen = strlen (string);
1742
1743   if (chars_printed > 0)
1744     spaces = width - (chars_printed - 1) % width - 1;
1745   if (right)
1746     spaces += width - stringlen;
1747
1748   spacebuf = (char *) alloca (spaces + 1);
1749   spacebuf[spaces] = '\0';
1750   while (spaces--)
1751     spacebuf[spaces] = ' ';
1752
1753   fputs_filtered (spacebuf, gdb_stdout);
1754   fputs_filtered (string, gdb_stdout);
1755 }
1756
1757
1758 /* Ensure that whatever gets printed next, using the filtered output
1759    commands, starts at the beginning of the line.  I.e. if there is
1760    any pending output for the current line, flush it and start a new
1761    line.  Otherwise do nothing.  */
1762
1763 void
1764 begin_line (void)
1765 {
1766   if (chars_printed > 0)
1767     {
1768       puts_filtered ("\n");
1769     }
1770 }
1771
1772
1773 /* Like fputs but if FILTER is true, pause after every screenful.
1774
1775    Regardless of FILTER can wrap at points other than the final
1776    character of a line.
1777
1778    Unlike fputs, fputs_maybe_filtered does not return a value.
1779    It is OK for LINEBUFFER to be NULL, in which case just don't print
1780    anything.
1781
1782    Note that a longjmp to top level may occur in this routine (only if
1783    FILTER is true) (since prompt_for_continue may do so) so this
1784    routine should not be called when cleanups are not in place.  */
1785
1786 static void
1787 fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
1788                       int filter)
1789 {
1790   const char *lineptr;
1791
1792   if (linebuffer == 0)
1793     return;
1794
1795   /* Don't do any filtering if it is disabled.  */
1796   if (stream != gdb_stdout
1797       || !pagination_enabled
1798       || batch_flag
1799       || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)
1800       || top_level_interpreter () == NULL
1801       || interp_ui_out (top_level_interpreter ())->is_mi_like_p ())
1802     {
1803       fputs_unfiltered (linebuffer, stream);
1804       return;
1805     }
1806
1807   /* Go through and output each character.  Show line extension
1808      when this is necessary; prompt user for new page when this is
1809      necessary.  */
1810
1811   lineptr = linebuffer;
1812   while (*lineptr)
1813     {
1814       /* Possible new page.  */
1815       if (filter && (lines_printed >= lines_per_page - 1))
1816         prompt_for_continue ();
1817
1818       while (*lineptr && *lineptr != '\n')
1819         {
1820           /* Print a single line.  */
1821           if (*lineptr == '\t')
1822             {
1823               if (wrap_column)
1824                 *wrap_pointer++ = '\t';
1825               else
1826                 fputc_unfiltered ('\t', stream);
1827               /* Shifting right by 3 produces the number of tab stops
1828                  we have already passed, and then adding one and
1829                  shifting left 3 advances to the next tab stop.  */
1830               chars_printed = ((chars_printed >> 3) + 1) << 3;
1831               lineptr++;
1832             }
1833           else
1834             {
1835               if (wrap_column)
1836                 *wrap_pointer++ = *lineptr;
1837               else
1838                 fputc_unfiltered (*lineptr, stream);
1839               chars_printed++;
1840               lineptr++;
1841             }
1842
1843           if (chars_printed >= chars_per_line)
1844             {
1845               unsigned int save_chars = chars_printed;
1846
1847               chars_printed = 0;
1848               lines_printed++;
1849               /* If we aren't actually wrapping, don't output newline --
1850                  if chars_per_line is right, we probably just overflowed
1851                  anyway; if it's wrong, let us keep going.  */
1852               if (wrap_column)
1853                 fputc_unfiltered ('\n', stream);
1854
1855               /* Possible new page.  */
1856               if (lines_printed >= lines_per_page - 1)
1857                 prompt_for_continue ();
1858
1859               /* Now output indentation and wrapped string.  */
1860               if (wrap_column)
1861                 {
1862                   fputs_unfiltered (wrap_indent, stream);
1863                   *wrap_pointer = '\0'; /* Null-terminate saved stuff, */
1864                   fputs_unfiltered (wrap_buffer, stream); /* and eject it.  */
1865                   /* FIXME, this strlen is what prevents wrap_indent from
1866                      containing tabs.  However, if we recurse to print it
1867                      and count its chars, we risk trouble if wrap_indent is
1868                      longer than (the user settable) chars_per_line.
1869                      Note also that this can set chars_printed > chars_per_line
1870                      if we are printing a long string.  */
1871                   chars_printed = strlen (wrap_indent)
1872                     + (save_chars - wrap_column);
1873                   wrap_pointer = wrap_buffer;   /* Reset buffer */
1874                   wrap_buffer[0] = '\0';
1875                   wrap_column = 0;      /* And disable fancy wrap */
1876                 }
1877             }
1878         }
1879
1880       if (*lineptr == '\n')
1881         {
1882           chars_printed = 0;
1883           wrap_here ((char *) 0);       /* Spit out chars, cancel
1884                                            further wraps.  */
1885           lines_printed++;
1886           fputc_unfiltered ('\n', stream);
1887           lineptr++;
1888         }
1889     }
1890 }
1891
1892 void
1893 fputs_filtered (const char *linebuffer, struct ui_file *stream)
1894 {
1895   fputs_maybe_filtered (linebuffer, stream, 1);
1896 }
1897
1898 int
1899 putchar_unfiltered (int c)
1900 {
1901   char buf = c;
1902
1903   ui_file_write (gdb_stdout, &buf, 1);
1904   return c;
1905 }
1906
1907 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1908    May return nonlocally.  */
1909
1910 int
1911 putchar_filtered (int c)
1912 {
1913   return fputc_filtered (c, gdb_stdout);
1914 }
1915
1916 int
1917 fputc_unfiltered (int c, struct ui_file *stream)
1918 {
1919   char buf = c;
1920
1921   ui_file_write (stream, &buf, 1);
1922   return c;
1923 }
1924
1925 int
1926 fputc_filtered (int c, struct ui_file *stream)
1927 {
1928   char buf[2];
1929
1930   buf[0] = c;
1931   buf[1] = 0;
1932   fputs_filtered (buf, stream);
1933   return c;
1934 }
1935
1936 /* puts_debug is like fputs_unfiltered, except it prints special
1937    characters in printable fashion.  */
1938
1939 void
1940 puts_debug (char *prefix, char *string, char *suffix)
1941 {
1942   int ch;
1943
1944   /* Print prefix and suffix after each line.  */
1945   static int new_line = 1;
1946   static int return_p = 0;
1947   static const char *prev_prefix = "";
1948   static const char *prev_suffix = "";
1949
1950   if (*string == '\n')
1951     return_p = 0;
1952
1953   /* If the prefix is changing, print the previous suffix, a new line,
1954      and the new prefix.  */
1955   if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
1956     {
1957       fputs_unfiltered (prev_suffix, gdb_stdlog);
1958       fputs_unfiltered ("\n", gdb_stdlog);
1959       fputs_unfiltered (prefix, gdb_stdlog);
1960     }
1961
1962   /* Print prefix if we printed a newline during the previous call.  */
1963   if (new_line)
1964     {
1965       new_line = 0;
1966       fputs_unfiltered (prefix, gdb_stdlog);
1967     }
1968
1969   prev_prefix = prefix;
1970   prev_suffix = suffix;
1971
1972   /* Output characters in a printable format.  */
1973   while ((ch = *string++) != '\0')
1974     {
1975       switch (ch)
1976         {
1977         default:
1978           if (isprint (ch))
1979             fputc_unfiltered (ch, gdb_stdlog);
1980
1981           else
1982             fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
1983           break;
1984
1985         case '\\':
1986           fputs_unfiltered ("\\\\", gdb_stdlog);
1987           break;
1988         case '\b':
1989           fputs_unfiltered ("\\b", gdb_stdlog);
1990           break;
1991         case '\f':
1992           fputs_unfiltered ("\\f", gdb_stdlog);
1993           break;
1994         case '\n':
1995           new_line = 1;
1996           fputs_unfiltered ("\\n", gdb_stdlog);
1997           break;
1998         case '\r':
1999           fputs_unfiltered ("\\r", gdb_stdlog);
2000           break;
2001         case '\t':
2002           fputs_unfiltered ("\\t", gdb_stdlog);
2003           break;
2004         case '\v':
2005           fputs_unfiltered ("\\v", gdb_stdlog);
2006           break;
2007         }
2008
2009       return_p = ch == '\r';
2010     }
2011
2012   /* Print suffix if we printed a newline.  */
2013   if (new_line)
2014     {
2015       fputs_unfiltered (suffix, gdb_stdlog);
2016       fputs_unfiltered ("\n", gdb_stdlog);
2017     }
2018 }
2019
2020
2021 /* Print a variable number of ARGS using format FORMAT.  If this
2022    information is going to put the amount written (since the last call
2023    to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2024    call prompt_for_continue to get the users permision to continue.
2025
2026    Unlike fprintf, this function does not return a value.
2027
2028    We implement three variants, vfprintf (takes a vararg list and stream),
2029    fprintf (takes a stream to write on), and printf (the usual).
2030
2031    Note also that a longjmp to top level may occur in this routine
2032    (since prompt_for_continue may do so) so this routine should not be
2033    called when cleanups are not in place.  */
2034
2035 static void
2036 vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
2037                          va_list args, int filter)
2038 {
2039   char *linebuffer;
2040   struct cleanup *old_cleanups;
2041
2042   linebuffer = xstrvprintf (format, args);
2043   old_cleanups = make_cleanup (xfree, linebuffer);
2044   fputs_maybe_filtered (linebuffer, stream, filter);
2045   do_cleanups (old_cleanups);
2046 }
2047
2048
2049 void
2050 vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
2051 {
2052   vfprintf_maybe_filtered (stream, format, args, 1);
2053 }
2054
2055 void
2056 vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
2057 {
2058   char *linebuffer;
2059   struct cleanup *old_cleanups;
2060
2061   linebuffer = xstrvprintf (format, args);
2062   old_cleanups = make_cleanup (xfree, linebuffer);
2063   if (debug_timestamp && stream == gdb_stdlog)
2064     {
2065       using namespace std::chrono;
2066       int len, need_nl;
2067
2068       steady_clock::time_point now = steady_clock::now ();
2069       seconds s = duration_cast<seconds> (now.time_since_epoch ());
2070       microseconds us = duration_cast<microseconds> (now.time_since_epoch () - s);
2071
2072       len = strlen (linebuffer);
2073       need_nl = (len > 0 && linebuffer[len - 1] != '\n');
2074
2075       std::string timestamp = string_printf ("%ld.%06ld %s%s",
2076                                              (long) s.count (),
2077                                              (long) us.count (),
2078                                              linebuffer, need_nl ? "\n": "");
2079       fputs_unfiltered (timestamp.c_str (), stream);
2080     }
2081   else
2082     fputs_unfiltered (linebuffer, stream);
2083   do_cleanups (old_cleanups);
2084 }
2085
2086 void
2087 vprintf_filtered (const char *format, va_list args)
2088 {
2089   vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2090 }
2091
2092 void
2093 vprintf_unfiltered (const char *format, va_list args)
2094 {
2095   vfprintf_unfiltered (gdb_stdout, format, args);
2096 }
2097
2098 void
2099 fprintf_filtered (struct ui_file *stream, const char *format, ...)
2100 {
2101   va_list args;
2102
2103   va_start (args, format);
2104   vfprintf_filtered (stream, format, args);
2105   va_end (args);
2106 }
2107
2108 void
2109 fprintf_unfiltered (struct ui_file *stream, const char *format, ...)
2110 {
2111   va_list args;
2112
2113   va_start (args, format);
2114   vfprintf_unfiltered (stream, format, args);
2115   va_end (args);
2116 }
2117
2118 /* Like fprintf_filtered, but prints its result indented.
2119    Called as fprintfi_filtered (spaces, stream, format, ...);  */
2120
2121 void
2122 fprintfi_filtered (int spaces, struct ui_file *stream, const char *format,
2123                    ...)
2124 {
2125   va_list args;
2126
2127   va_start (args, format);
2128   print_spaces_filtered (spaces, stream);
2129
2130   vfprintf_filtered (stream, format, args);
2131   va_end (args);
2132 }
2133
2134
2135 void
2136 printf_filtered (const char *format, ...)
2137 {
2138   va_list args;
2139
2140   va_start (args, format);
2141   vfprintf_filtered (gdb_stdout, format, args);
2142   va_end (args);
2143 }
2144
2145
2146 void
2147 printf_unfiltered (const char *format, ...)
2148 {
2149   va_list args;
2150
2151   va_start (args, format);
2152   vfprintf_unfiltered (gdb_stdout, format, args);
2153   va_end (args);
2154 }
2155
2156 /* Like printf_filtered, but prints it's result indented.
2157    Called as printfi_filtered (spaces, format, ...);  */
2158
2159 void
2160 printfi_filtered (int spaces, const char *format, ...)
2161 {
2162   va_list args;
2163
2164   va_start (args, format);
2165   print_spaces_filtered (spaces, gdb_stdout);
2166   vfprintf_filtered (gdb_stdout, format, args);
2167   va_end (args);
2168 }
2169
2170 /* Easy -- but watch out!
2171
2172    This routine is *not* a replacement for puts()!  puts() appends a newline.
2173    This one doesn't, and had better not!  */
2174
2175 void
2176 puts_filtered (const char *string)
2177 {
2178   fputs_filtered (string, gdb_stdout);
2179 }
2180
2181 void
2182 puts_unfiltered (const char *string)
2183 {
2184   fputs_unfiltered (string, gdb_stdout);
2185 }
2186
2187 /* Return a pointer to N spaces and a null.  The pointer is good
2188    until the next call to here.  */
2189 char *
2190 n_spaces (int n)
2191 {
2192   char *t;
2193   static char *spaces = 0;
2194   static int max_spaces = -1;
2195
2196   if (n > max_spaces)
2197     {
2198       if (spaces)
2199         xfree (spaces);
2200       spaces = (char *) xmalloc (n + 1);
2201       for (t = spaces + n; t != spaces;)
2202         *--t = ' ';
2203       spaces[n] = '\0';
2204       max_spaces = n;
2205     }
2206
2207   return spaces + max_spaces - n;
2208 }
2209
2210 /* Print N spaces.  */
2211 void
2212 print_spaces_filtered (int n, struct ui_file *stream)
2213 {
2214   fputs_filtered (n_spaces (n), stream);
2215 }
2216 \f
2217 /* C++/ObjC demangler stuff.  */
2218
2219 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2220    LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2221    If the name is not mangled, or the language for the name is unknown, or
2222    demangling is off, the name is printed in its "raw" form.  */
2223
2224 void
2225 fprintf_symbol_filtered (struct ui_file *stream, const char *name,
2226                          enum language lang, int arg_mode)
2227 {
2228   char *demangled;
2229
2230   if (name != NULL)
2231     {
2232       /* If user wants to see raw output, no problem.  */
2233       if (!demangle)
2234         {
2235           fputs_filtered (name, stream);
2236         }
2237       else
2238         {
2239           demangled = language_demangle (language_def (lang), name, arg_mode);
2240           fputs_filtered (demangled ? demangled : name, stream);
2241           if (demangled != NULL)
2242             {
2243               xfree (demangled);
2244             }
2245         }
2246     }
2247 }
2248
2249 /* Modes of operation for strncmp_iw_with_mode.  */
2250
2251 enum class strncmp_iw_mode
2252 {
2253   /* Work like strncmp, while ignoring whitespace.  */
2254   NORMAL,
2255
2256   /* Like NORMAL, but also apply the strcmp_iw hack.  I.e.,
2257      string1=="FOO(PARAMS)" matches string2=="FOO".  */
2258   MATCH_PARAMS,
2259 };
2260
2261 /* Helper for strncmp_iw and strcmp_iw.  */
2262
2263 static int
2264 strncmp_iw_with_mode (const char *string1, const char *string2,
2265                       size_t string2_len, strncmp_iw_mode mode)
2266 {
2267   const char *end_str2 = string2 + string2_len;
2268
2269   while (1)
2270     {
2271       while (isspace (*string1))
2272         string1++;
2273       while (string2 < end_str2 && isspace (*string2))
2274         string2++;
2275       if (*string1 == '\0' || string2 == end_str2)
2276         break;
2277       if (case_sensitivity == case_sensitive_on && *string1 != *string2)
2278         break;
2279       if (case_sensitivity == case_sensitive_off
2280           && (tolower ((unsigned char) *string1)
2281               != tolower ((unsigned char) *string2)))
2282         break;
2283
2284       string1++;
2285       string2++;
2286     }
2287
2288   if (string2 == end_str2)
2289     {
2290       if (mode == strncmp_iw_mode::NORMAL)
2291         return 0;
2292       else
2293         return (*string1 != '\0' && *string1 != '(');
2294     }
2295   else
2296     return 1;
2297 }
2298
2299 /* See utils.h.  */
2300
2301 int
2302 strncmp_iw (const char *string1, const char *string2, size_t string2_len)
2303 {
2304   return strncmp_iw_with_mode (string1, string2, string2_len,
2305                                strncmp_iw_mode::NORMAL);
2306 }
2307
2308 /* See utils.h.  */
2309
2310 int
2311 strcmp_iw (const char *string1, const char *string2)
2312 {
2313   return strncmp_iw_with_mode (string1, string2, strlen (string2),
2314                                strncmp_iw_mode::MATCH_PARAMS);
2315 }
2316
2317 /* This is like strcmp except that it ignores whitespace and treats
2318    '(' as the first non-NULL character in terms of ordering.  Like
2319    strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2320    STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2321    according to that ordering.
2322
2323    If a list is sorted according to this function and if you want to
2324    find names in the list that match some fixed NAME according to
2325    strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2326    where this function would put NAME.
2327
2328    This function must be neutral to the CASE_SENSITIVITY setting as the user
2329    may choose it during later lookup.  Therefore this function always sorts
2330    primarily case-insensitively and secondarily case-sensitively.
2331
2332    Here are some examples of why using strcmp to sort is a bad idea:
2333
2334    Whitespace example:
2335
2336    Say your partial symtab contains: "foo<char *>", "goo".  Then, if
2337    we try to do a search for "foo<char*>", strcmp will locate this
2338    after "foo<char *>" and before "goo".  Then lookup_partial_symbol
2339    will start looking at strings beginning with "goo", and will never
2340    see the correct match of "foo<char *>".
2341
2342    Parenthesis example:
2343
2344    In practice, this is less like to be an issue, but I'll give it a
2345    shot.  Let's assume that '$' is a legitimate character to occur in
2346    symbols.  (Which may well even be the case on some systems.)  Then
2347    say that the partial symbol table contains "foo$" and "foo(int)".
2348    strcmp will put them in this order, since '$' < '('.  Now, if the
2349    user searches for "foo", then strcmp will sort "foo" before "foo$".
2350    Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2351    "foo") is false, so it won't proceed to the actual match of
2352    "foo(int)" with "foo".  */
2353
2354 int
2355 strcmp_iw_ordered (const char *string1, const char *string2)
2356 {
2357   const char *saved_string1 = string1, *saved_string2 = string2;
2358   enum case_sensitivity case_pass = case_sensitive_off;
2359
2360   for (;;)
2361     {
2362       /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2363          Provide stub characters if we are already at the end of one of the
2364          strings.  */
2365       char c1 = 'X', c2 = 'X';
2366
2367       while (*string1 != '\0' && *string2 != '\0')
2368         {
2369           while (isspace (*string1))
2370             string1++;
2371           while (isspace (*string2))
2372             string2++;
2373
2374           switch (case_pass)
2375           {
2376             case case_sensitive_off:
2377               c1 = tolower ((unsigned char) *string1);
2378               c2 = tolower ((unsigned char) *string2);
2379               break;
2380             case case_sensitive_on:
2381               c1 = *string1;
2382               c2 = *string2;
2383               break;
2384           }
2385           if (c1 != c2)
2386             break;
2387
2388           if (*string1 != '\0')
2389             {
2390               string1++;
2391               string2++;
2392             }
2393         }
2394
2395       switch (*string1)
2396         {
2397           /* Characters are non-equal unless they're both '\0'; we want to
2398              make sure we get the comparison right according to our
2399              comparison in the cases where one of them is '\0' or '('.  */
2400         case '\0':
2401           if (*string2 == '\0')
2402             break;
2403           else
2404             return -1;
2405         case '(':
2406           if (*string2 == '\0')
2407             return 1;
2408           else
2409             return -1;
2410         default:
2411           if (*string2 == '\0' || *string2 == '(')
2412             return 1;
2413           else if (c1 > c2)
2414             return 1;
2415           else if (c1 < c2)
2416             return -1;
2417           /* PASSTHRU */
2418         }
2419
2420       if (case_pass == case_sensitive_on)
2421         return 0;
2422       
2423       /* Otherwise the strings were equal in case insensitive way, make
2424          a more fine grained comparison in a case sensitive way.  */
2425
2426       case_pass = case_sensitive_on;
2427       string1 = saved_string1;
2428       string2 = saved_string2;
2429     }
2430 }
2431
2432 /* A simple comparison function with opposite semantics to strcmp.  */
2433
2434 int
2435 streq (const char *lhs, const char *rhs)
2436 {
2437   return !strcmp (lhs, rhs);
2438 }
2439 \f
2440
2441 /*
2442    ** subset_compare()
2443    **    Answer whether string_to_compare is a full or partial match to
2444    **    template_string.  The partial match must be in sequence starting
2445    **    at index 0.
2446  */
2447 int
2448 subset_compare (const char *string_to_compare, const char *template_string)
2449 {
2450   int match;
2451
2452   if (template_string != (char *) NULL && string_to_compare != (char *) NULL
2453       && strlen (string_to_compare) <= strlen (template_string))
2454     match =
2455       (startswith (template_string, string_to_compare));
2456   else
2457     match = 0;
2458   return match;
2459 }
2460
2461 static void
2462 show_debug_timestamp (struct ui_file *file, int from_tty,
2463                       struct cmd_list_element *c, const char *value)
2464 {
2465   fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"),
2466                     value);
2467 }
2468 \f
2469
2470 void
2471 initialize_utils (void)
2472 {
2473   add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
2474 Set number of characters where GDB should wrap lines of its output."), _("\
2475 Show number of characters where GDB should wrap lines of its output."), _("\
2476 This affects where GDB wraps its output to fit the screen width.\n\
2477 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
2478                             set_width_command,
2479                             show_chars_per_line,
2480                             &setlist, &showlist);
2481
2482   add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\
2483 Set number of lines in a page for GDB output pagination."), _("\
2484 Show number of lines in a page for GDB output pagination."), _("\
2485 This affects the number of lines after which GDB will pause\n\
2486 its output and ask you whether to continue.\n\
2487 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
2488                             set_height_command,
2489                             show_lines_per_page,
2490                             &setlist, &showlist);
2491
2492   add_setshow_boolean_cmd ("pagination", class_support,
2493                            &pagination_enabled, _("\
2494 Set state of GDB output pagination."), _("\
2495 Show state of GDB output pagination."), _("\
2496 When pagination is ON, GDB pauses at end of each screenful of\n\
2497 its output and asks you whether to continue.\n\
2498 Turning pagination off is an alternative to \"set height unlimited\"."),
2499                            NULL,
2500                            show_pagination_enabled,
2501                            &setlist, &showlist);
2502
2503   add_setshow_boolean_cmd ("sevenbit-strings", class_support,
2504                            &sevenbit_strings, _("\
2505 Set printing of 8-bit characters in strings as \\nnn."), _("\
2506 Show printing of 8-bit characters in strings as \\nnn."), NULL,
2507                            NULL,
2508                            show_sevenbit_strings,
2509                            &setprintlist, &showprintlist);
2510
2511   add_setshow_boolean_cmd ("timestamp", class_maintenance,
2512                             &debug_timestamp, _("\
2513 Set timestamping of debugging messages."), _("\
2514 Show timestamping of debugging messages."), _("\
2515 When set, debugging messages will be marked with seconds and microseconds."),
2516                            NULL,
2517                            show_debug_timestamp,
2518                            &setdebuglist, &showdebuglist);
2519 }
2520
2521 const char *
2522 paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
2523 {
2524   /* Truncate address to the size of a target address, avoiding shifts
2525      larger or equal than the width of a CORE_ADDR.  The local
2526      variable ADDR_BIT stops the compiler reporting a shift overflow
2527      when it won't occur.  */
2528   /* NOTE: This assumes that the significant address information is
2529      kept in the least significant bits of ADDR - the upper bits were
2530      either zero or sign extended.  Should gdbarch_address_to_pointer or
2531      some ADDRESS_TO_PRINTABLE() be used to do the conversion?  */
2532
2533   int addr_bit = gdbarch_addr_bit (gdbarch);
2534
2535   if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2536     addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
2537   return hex_string (addr);
2538 }
2539
2540 /* This function is described in "defs.h".  */
2541
2542 const char *
2543 print_core_address (struct gdbarch *gdbarch, CORE_ADDR address)
2544 {
2545   int addr_bit = gdbarch_addr_bit (gdbarch);
2546
2547   if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2548     address &= ((CORE_ADDR) 1 << addr_bit) - 1;
2549
2550   /* FIXME: cagney/2002-05-03: Need local_address_string() function
2551      that returns the language localized string formatted to a width
2552      based on gdbarch_addr_bit.  */
2553   if (addr_bit <= 32)
2554     return hex_string_custom (address, 8);
2555   else
2556     return hex_string_custom (address, 16);
2557 }
2558
2559 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex.  */
2560
2561 hashval_t
2562 core_addr_hash (const void *ap)
2563 {
2564   const CORE_ADDR *addrp = (const CORE_ADDR *) ap;
2565
2566   return *addrp;
2567 }
2568
2569 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex.  */
2570
2571 int
2572 core_addr_eq (const void *ap, const void *bp)
2573 {
2574   const CORE_ADDR *addr_ap = (const CORE_ADDR *) ap;
2575   const CORE_ADDR *addr_bp = (const CORE_ADDR *) bp;
2576
2577   return *addr_ap == *addr_bp;
2578 }
2579
2580 /* Convert a string back into a CORE_ADDR.  */
2581 CORE_ADDR
2582 string_to_core_addr (const char *my_string)
2583 {
2584   CORE_ADDR addr = 0;
2585
2586   if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
2587     {
2588       /* Assume that it is in hex.  */
2589       int i;
2590
2591       for (i = 2; my_string[i] != '\0'; i++)
2592         {
2593           if (isdigit (my_string[i]))
2594             addr = (my_string[i] - '0') + (addr * 16);
2595           else if (isxdigit (my_string[i]))
2596             addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
2597           else
2598             error (_("invalid hex \"%s\""), my_string);
2599         }
2600     }
2601   else
2602     {
2603       /* Assume that it is in decimal.  */
2604       int i;
2605
2606       for (i = 0; my_string[i] != '\0'; i++)
2607         {
2608           if (isdigit (my_string[i]))
2609             addr = (my_string[i] - '0') + (addr * 10);
2610           else
2611             error (_("invalid decimal \"%s\""), my_string);
2612         }
2613     }
2614
2615   return addr;
2616 }
2617
2618 gdb::unique_xmalloc_ptr<char>
2619 gdb_realpath (const char *filename)
2620 {
2621 /* On most hosts, we rely on canonicalize_file_name to compute
2622    the FILENAME's realpath.
2623
2624    But the situation is slightly more complex on Windows, due to some
2625    versions of GCC which were reported to generate paths where
2626    backlashes (the directory separator) were doubled.  For instance:
2627       c:\\some\\double\\slashes\\dir
2628    ... instead of ...
2629       c:\some\double\slashes\dir
2630    Those double-slashes were getting in the way when comparing paths,
2631    for instance when trying to insert a breakpoint as follow:
2632       (gdb) b c:/some/double/slashes/dir/foo.c:4
2633       No source file named c:/some/double/slashes/dir/foo.c:4.
2634       (gdb) b c:\some\double\slashes\dir\foo.c:4
2635       No source file named c:\some\double\slashes\dir\foo.c:4.
2636    To prevent this from happening, we need this function to always
2637    strip those extra backslashes.  While canonicalize_file_name does
2638    perform this simplification, it only works when the path is valid.
2639    Since the simplification would be useful even if the path is not
2640    valid (one can always set a breakpoint on a file, even if the file
2641    does not exist locally), we rely instead on GetFullPathName to
2642    perform the canonicalization.  */
2643
2644 #if defined (_WIN32)
2645   {
2646     char buf[MAX_PATH];
2647     DWORD len = GetFullPathName (filename, MAX_PATH, buf, NULL);
2648
2649     /* The file system is case-insensitive but case-preserving.
2650        So it is important we do not lowercase the path.  Otherwise,
2651        we might not be able to display the original casing in a given
2652        path.  */
2653     if (len > 0 && len < MAX_PATH)
2654       return gdb::unique_xmalloc_ptr<char> (xstrdup (buf));
2655   }
2656 #else
2657   {
2658     char *rp = canonicalize_file_name (filename);
2659
2660     if (rp != NULL)
2661       return gdb::unique_xmalloc_ptr<char> (rp);
2662   }
2663 #endif
2664
2665   /* This system is a lost cause, just dup the buffer.  */
2666   return gdb::unique_xmalloc_ptr<char> (xstrdup (filename));
2667 }
2668
2669 #if GDB_SELF_TEST
2670
2671 static void
2672 gdb_realpath_check_trailer (const char *input, const char *trailer)
2673 {
2674   gdb::unique_xmalloc_ptr<char> result = gdb_realpath (input);
2675
2676   size_t len = strlen (result.get ());
2677   size_t trail_len = strlen (trailer);
2678
2679   SELF_CHECK (len >= trail_len
2680               && strcmp (result.get () + len - trail_len, trailer) == 0);
2681 }
2682
2683 static void
2684 gdb_realpath_tests ()
2685 {
2686   /* A file which contains a directory prefix.  */
2687   gdb_realpath_check_trailer ("./xfullpath.exp", "/xfullpath.exp");
2688   /* A file which contains a directory prefix.  */
2689   gdb_realpath_check_trailer ("../../defs.h", "/defs.h");
2690   /* A one-character filename.  */
2691   gdb_realpath_check_trailer ("./a", "/a");
2692   /* A file in the root directory.  */
2693   gdb_realpath_check_trailer ("/root_file_which_should_exist",
2694                               "/root_file_which_should_exist");
2695   /* A file which does not have a directory prefix.  */
2696   gdb_realpath_check_trailer ("xfullpath.exp", "xfullpath.exp");
2697   /* A one-char filename without any directory prefix.  */
2698   gdb_realpath_check_trailer ("a", "a");
2699   /* An empty filename.  */
2700   gdb_realpath_check_trailer ("", "");
2701 }
2702
2703 #endif /* GDB_SELF_TEST */
2704
2705 /* Return a copy of FILENAME, with its directory prefix canonicalized
2706    by gdb_realpath.  */
2707
2708 gdb::unique_xmalloc_ptr<char>
2709 gdb_realpath_keepfile (const char *filename)
2710 {
2711   const char *base_name = lbasename (filename);
2712   char *dir_name;
2713   char *result;
2714
2715   /* Extract the basename of filename, and return immediately 
2716      a copy of filename if it does not contain any directory prefix.  */
2717   if (base_name == filename)
2718     return gdb::unique_xmalloc_ptr<char> (xstrdup (filename));
2719
2720   dir_name = (char *) alloca ((size_t) (base_name - filename + 2));
2721   /* Allocate enough space to store the dir_name + plus one extra
2722      character sometimes needed under Windows (see below), and
2723      then the closing \000 character.  */
2724   strncpy (dir_name, filename, base_name - filename);
2725   dir_name[base_name - filename] = '\000';
2726
2727 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2728   /* We need to be careful when filename is of the form 'd:foo', which
2729      is equivalent of d:./foo, which is totally different from d:/foo.  */
2730   if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':')
2731     {
2732       dir_name[2] = '.';
2733       dir_name[3] = '\000';
2734     }
2735 #endif
2736
2737   /* Canonicalize the directory prefix, and build the resulting
2738      filename.  If the dirname realpath already contains an ending
2739      directory separator, avoid doubling it.  */
2740   gdb::unique_xmalloc_ptr<char> path_storage = gdb_realpath (dir_name);
2741   const char *real_path = path_storage.get ();
2742   if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
2743     result = concat (real_path, base_name, (char *) NULL);
2744   else
2745     result = concat (real_path, SLASH_STRING, base_name, (char *) NULL);
2746
2747   return gdb::unique_xmalloc_ptr<char> (result);
2748 }
2749
2750 /* Return PATH in absolute form, performing tilde-expansion if necessary.
2751    PATH cannot be NULL or the empty string.
2752    This does not resolve symlinks however, use gdb_realpath for that.  */
2753
2754 gdb::unique_xmalloc_ptr<char>
2755 gdb_abspath (const char *path)
2756 {
2757   gdb_assert (path != NULL && path[0] != '\0');
2758
2759   if (path[0] == '~')
2760     return gdb::unique_xmalloc_ptr<char> (tilde_expand (path));
2761
2762   if (IS_ABSOLUTE_PATH (path))
2763     return gdb::unique_xmalloc_ptr<char> (xstrdup (path));
2764
2765   /* Beware the // my son, the Emacs barfs, the botch that catch...  */
2766   return gdb::unique_xmalloc_ptr<char>
2767     (concat (current_directory,
2768              IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1])
2769              ? "" : SLASH_STRING,
2770              path, (char *) NULL));
2771 }
2772
2773 ULONGEST
2774 align_up (ULONGEST v, int n)
2775 {
2776   /* Check that N is really a power of two.  */
2777   gdb_assert (n && (n & (n-1)) == 0);
2778   return (v + n - 1) & -n;
2779 }
2780
2781 ULONGEST
2782 align_down (ULONGEST v, int n)
2783 {
2784   /* Check that N is really a power of two.  */
2785   gdb_assert (n && (n & (n-1)) == 0);
2786   return (v & -n);
2787 }
2788
2789 /* Allocation function for the libiberty hash table which uses an
2790    obstack.  The obstack is passed as DATA.  */
2791
2792 void *
2793 hashtab_obstack_allocate (void *data, size_t size, size_t count)
2794 {
2795   size_t total = size * count;
2796   void *ptr = obstack_alloc ((struct obstack *) data, total);
2797
2798   memset (ptr, 0, total);
2799   return ptr;
2800 }
2801
2802 /* Trivial deallocation function for the libiberty splay tree and hash
2803    table - don't deallocate anything.  Rely on later deletion of the
2804    obstack.  DATA will be the obstack, although it is not needed
2805    here.  */
2806
2807 void
2808 dummy_obstack_deallocate (void *object, void *data)
2809 {
2810   return;
2811 }
2812
2813 /* Simple, portable version of dirname that does not modify its
2814    argument.  */
2815
2816 std::string
2817 ldirname (const char *filename)
2818 {
2819   std::string dirname;
2820   const char *base = lbasename (filename);
2821
2822   while (base > filename && IS_DIR_SEPARATOR (base[-1]))
2823     --base;
2824
2825   if (base == filename)
2826     return dirname;
2827
2828   dirname = std::string (filename, base - filename);
2829
2830   /* On DOS based file systems, convert "d:foo" to "d:.", so that we
2831      create "d:./bar" later instead of the (different) "d:/bar".  */
2832   if (base - filename == 2 && IS_ABSOLUTE_PATH (base)
2833       && !IS_DIR_SEPARATOR (filename[0]))
2834     dirname[base++ - filename] = '.';
2835
2836   return dirname;
2837 }
2838
2839 /* See utils.h.  */
2840
2841 void
2842 gdb_argv::reset (const char *s)
2843 {
2844   char **argv = buildargv (s);
2845
2846   if (s != NULL && argv == NULL)
2847     malloc_failure (0);
2848
2849   freeargv (m_argv);
2850   m_argv = argv;
2851 }
2852
2853 int
2854 compare_positive_ints (const void *ap, const void *bp)
2855 {
2856   /* Because we know we're comparing two ints which are positive,
2857      there's no danger of overflow here.  */
2858   return * (int *) ap - * (int *) bp;
2859 }
2860
2861 /* String compare function for qsort.  */
2862
2863 int
2864 compare_strings (const void *arg1, const void *arg2)
2865 {
2866   const char **s1 = (const char **) arg1;
2867   const char **s2 = (const char **) arg2;
2868
2869   return strcmp (*s1, *s2);
2870 }
2871
2872 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
2873 #define AMBIGUOUS_MESS2 \
2874   ".\nUse \"set gnutarget format-name\" to specify the format."
2875
2876 const char *
2877 gdb_bfd_errmsg (bfd_error_type error_tag, char **matching)
2878 {
2879   char *ret, *retp;
2880   int ret_len;
2881   char **p;
2882
2883   /* Check if errmsg just need simple return.  */
2884   if (error_tag != bfd_error_file_ambiguously_recognized || matching == NULL)
2885     return bfd_errmsg (error_tag);
2886
2887   ret_len = strlen (bfd_errmsg (error_tag)) + strlen (AMBIGUOUS_MESS1)
2888             + strlen (AMBIGUOUS_MESS2);
2889   for (p = matching; *p; p++)
2890     ret_len += strlen (*p) + 1;
2891   ret = (char *) xmalloc (ret_len + 1);
2892   retp = ret;
2893   make_cleanup (xfree, ret);
2894
2895   strcpy (retp, bfd_errmsg (error_tag));
2896   retp += strlen (retp);
2897
2898   strcpy (retp, AMBIGUOUS_MESS1);
2899   retp += strlen (retp);
2900
2901   for (p = matching; *p; p++)
2902     {
2903       sprintf (retp, " %s", *p);
2904       retp += strlen (retp);
2905     }
2906   xfree (matching);
2907
2908   strcpy (retp, AMBIGUOUS_MESS2);
2909
2910   return ret;
2911 }
2912
2913 /* Return ARGS parsed as a valid pid, or throw an error.  */
2914
2915 int
2916 parse_pid_to_attach (const char *args)
2917 {
2918   unsigned long pid;
2919   char *dummy;
2920
2921   if (!args)
2922     error_no_arg (_("process-id to attach"));
2923
2924   dummy = (char *) args;
2925   pid = strtoul (args, &dummy, 0);
2926   /* Some targets don't set errno on errors, grrr!  */
2927   if ((pid == 0 && dummy == args) || dummy != &args[strlen (args)])
2928     error (_("Illegal process-id: %s."), args);
2929
2930   return pid;
2931 }
2932
2933 /* Helper for make_bpstat_clear_actions_cleanup.  */
2934
2935 static void
2936 do_bpstat_clear_actions_cleanup (void *unused)
2937 {
2938   bpstat_clear_actions ();
2939 }
2940
2941 /* Call bpstat_clear_actions for the case an exception is throw.  You should
2942    discard_cleanups if no exception is caught.  */
2943
2944 struct cleanup *
2945 make_bpstat_clear_actions_cleanup (void)
2946 {
2947   return make_cleanup (do_bpstat_clear_actions_cleanup, NULL);
2948 }
2949
2950
2951 /* Helper for make_cleanup_free_char_ptr_vec.  */
2952
2953 static void
2954 do_free_char_ptr_vec (void *arg)
2955 {
2956   VEC (char_ptr) *char_ptr_vec = (VEC (char_ptr) *) arg;
2957
2958   free_char_ptr_vec (char_ptr_vec);
2959 }
2960
2961 /* Make cleanup handler calling xfree for each element of CHAR_PTR_VEC and
2962    final VEC_free for CHAR_PTR_VEC itself.
2963
2964    You must not modify CHAR_PTR_VEC after this cleanup registration as the
2965    CHAR_PTR_VEC base address may change on its updates.  Contrary to VEC_free
2966    this function does not (cannot) clear the pointer.  */
2967
2968 struct cleanup *
2969 make_cleanup_free_char_ptr_vec (VEC (char_ptr) *char_ptr_vec)
2970 {
2971   return make_cleanup (do_free_char_ptr_vec, char_ptr_vec);
2972 }
2973
2974 /* Substitute all occurences of string FROM by string TO in *STRINGP.  *STRINGP
2975    must come from xrealloc-compatible allocator and it may be updated.  FROM
2976    needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
2977    located at the start or end of *STRINGP.  */
2978
2979 void
2980 substitute_path_component (char **stringp, const char *from, const char *to)
2981 {
2982   char *string = *stringp, *s;
2983   const size_t from_len = strlen (from);
2984   const size_t to_len = strlen (to);
2985
2986   for (s = string;;)
2987     {
2988       s = strstr (s, from);
2989       if (s == NULL)
2990         break;
2991
2992       if ((s == string || IS_DIR_SEPARATOR (s[-1])
2993            || s[-1] == DIRNAME_SEPARATOR)
2994           && (s[from_len] == '\0' || IS_DIR_SEPARATOR (s[from_len])
2995               || s[from_len] == DIRNAME_SEPARATOR))
2996         {
2997           char *string_new;
2998
2999           string_new
3000             = (char *) xrealloc (string, (strlen (string) + to_len + 1));
3001
3002           /* Relocate the current S pointer.  */
3003           s = s - string + string_new;
3004           string = string_new;
3005
3006           /* Replace from by to.  */
3007           memmove (&s[to_len], &s[from_len], strlen (&s[from_len]) + 1);
3008           memcpy (s, to, to_len);
3009
3010           s += to_len;
3011         }
3012       else
3013         s++;
3014     }
3015
3016   *stringp = string;
3017 }
3018
3019 #ifdef HAVE_WAITPID
3020
3021 #ifdef SIGALRM
3022
3023 /* SIGALRM handler for waitpid_with_timeout.  */
3024
3025 static void
3026 sigalrm_handler (int signo)
3027 {
3028   /* Nothing to do.  */
3029 }
3030
3031 #endif
3032
3033 /* Wrapper to wait for child PID to die with TIMEOUT.
3034    TIMEOUT is the time to stop waiting in seconds.
3035    If TIMEOUT is zero, pass WNOHANG to waitpid.
3036    Returns PID if it was successfully waited for, otherwise -1.
3037
3038    Timeouts are currently implemented with alarm and SIGALRM.
3039    If the host does not support them, this waits "forever".
3040    It would be odd though for a host to have waitpid and not SIGALRM.  */
3041
3042 pid_t
3043 wait_to_die_with_timeout (pid_t pid, int *status, int timeout)
3044 {
3045   pid_t waitpid_result;
3046
3047   gdb_assert (pid > 0);
3048   gdb_assert (timeout >= 0);
3049
3050   if (timeout > 0)
3051     {
3052 #ifdef SIGALRM
3053 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3054       struct sigaction sa, old_sa;
3055
3056       sa.sa_handler = sigalrm_handler;
3057       sigemptyset (&sa.sa_mask);
3058       sa.sa_flags = 0;
3059       sigaction (SIGALRM, &sa, &old_sa);
3060 #else
3061       sighandler_t ofunc;
3062
3063       ofunc = signal (SIGALRM, sigalrm_handler);
3064 #endif
3065
3066       alarm (timeout);
3067 #endif
3068
3069       waitpid_result = waitpid (pid, status, 0);
3070
3071 #ifdef SIGALRM
3072       alarm (0);
3073 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3074       sigaction (SIGALRM, &old_sa, NULL);
3075 #else
3076       signal (SIGALRM, ofunc);
3077 #endif
3078 #endif
3079     }
3080   else
3081     waitpid_result = waitpid (pid, status, WNOHANG);
3082
3083   if (waitpid_result == pid)
3084     return pid;
3085   else
3086     return -1;
3087 }
3088
3089 #endif /* HAVE_WAITPID */
3090
3091 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3092    Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3093
3094    It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3095    HAVE_CASE_INSENSITIVE_FILE_SYSTEM.  */
3096
3097 int
3098 gdb_filename_fnmatch (const char *pattern, const char *string, int flags)
3099 {
3100   gdb_assert ((flags & FNM_FILE_NAME) != 0);
3101
3102   /* It is unclear how '\' escaping vs. directory separator should coexist.  */
3103   gdb_assert ((flags & FNM_NOESCAPE) != 0);
3104
3105 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3106   {
3107     char *pattern_slash, *string_slash;
3108
3109     /* Replace '\' by '/' in both strings.  */
3110
3111     pattern_slash = (char *) alloca (strlen (pattern) + 1);
3112     strcpy (pattern_slash, pattern);
3113     pattern = pattern_slash;
3114     for (; *pattern_slash != 0; pattern_slash++)
3115       if (IS_DIR_SEPARATOR (*pattern_slash))
3116         *pattern_slash = '/';
3117
3118     string_slash = (char *) alloca (strlen (string) + 1);
3119     strcpy (string_slash, string);
3120     string = string_slash;
3121     for (; *string_slash != 0; string_slash++)
3122       if (IS_DIR_SEPARATOR (*string_slash))
3123         *string_slash = '/';
3124   }
3125 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3126
3127 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3128   flags |= FNM_CASEFOLD;
3129 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3130
3131   return fnmatch (pattern, string, flags);
3132 }
3133
3134 /* Return the number of path elements in PATH.
3135    / = 1
3136    /foo = 2
3137    /foo/ = 2
3138    foo/bar = 2
3139    foo/ = 1  */
3140
3141 int
3142 count_path_elements (const char *path)
3143 {
3144   int count = 0;
3145   const char *p = path;
3146
3147   if (HAS_DRIVE_SPEC (p))
3148     {
3149       p = STRIP_DRIVE_SPEC (p);
3150       ++count;
3151     }
3152
3153   while (*p != '\0')
3154     {
3155       if (IS_DIR_SEPARATOR (*p))
3156         ++count;
3157       ++p;
3158     }
3159
3160   /* Backup one if last character is /, unless it's the only one.  */
3161   if (p > path + 1 && IS_DIR_SEPARATOR (p[-1]))
3162     --count;
3163
3164   /* Add one for the file name, if present.  */
3165   if (p > path && !IS_DIR_SEPARATOR (p[-1]))
3166     ++count;
3167
3168   return count;
3169 }
3170
3171 /* Remove N leading path elements from PATH.
3172    N must be non-negative.
3173    If PATH has more than N path elements then return NULL.
3174    If PATH has exactly N path elements then return "".
3175    See count_path_elements for a description of how we do the counting.  */
3176
3177 const char *
3178 strip_leading_path_elements (const char *path, int n)
3179 {
3180   int i = 0;
3181   const char *p = path;
3182
3183   gdb_assert (n >= 0);
3184
3185   if (n == 0)
3186     return p;
3187
3188   if (HAS_DRIVE_SPEC (p))
3189     {
3190       p = STRIP_DRIVE_SPEC (p);
3191       ++i;
3192     }
3193
3194   while (i < n)
3195     {
3196       while (*p != '\0' && !IS_DIR_SEPARATOR (*p))
3197         ++p;
3198       if (*p == '\0')
3199         {
3200           if (i + 1 == n)
3201             return "";
3202           return NULL;
3203         }
3204       ++p;
3205       ++i;
3206     }
3207
3208   return p;
3209 }
3210
3211 void
3212 _initialize_utils (void)
3213 {
3214   add_internal_problem_command (&internal_error_problem);
3215   add_internal_problem_command (&internal_warning_problem);
3216   add_internal_problem_command (&demangler_warning_problem);
3217
3218 #if GDB_SELF_TEST
3219   selftests::register_test ("gdb_realpath", gdb_realpath_tests);
3220 #endif
3221 }