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