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