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