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