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