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