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