GDB (xrefs)

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