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