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