OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [top.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Top level stuff for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4
   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5
   2008 Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "gdbcmd.h"
24
#include "call-cmds.h"
25
#include "cli/cli-cmds.h"
26
#include "cli/cli-script.h"
27
#include "cli/cli-setshow.h"
28
#include "cli/cli-decode.h"
29
#include "symtab.h"
30
#include "inferior.h"
31
#include "exceptions.h"
32
#include <signal.h>
33
#include "target.h"
34
#include "breakpoint.h"
35
#include "gdbtypes.h"
36
#include "expression.h"
37
#include "value.h"
38
#include "language.h"
39
#include "terminal.h"           /* For job_control.  */
40
#include "annotate.h"
41
#include "completer.h"
42
#include "top.h"
43
#include "version.h"
44
#include "serial.h"
45
#include "doublest.h"
46
#include "gdb_assert.h"
47
#include "main.h"
48
#include "event-loop.h"
49
 
50
/* readline include files */
51
#include "readline/readline.h"
52
#include "readline/history.h"
53
 
54
/* readline defines this.  */
55
#undef savestring
56
 
57
#include <sys/types.h>
58
 
59
#include "event-top.h"
60
#include "gdb_string.h"
61
#include "gdb_stat.h"
62
#include <ctype.h>
63
#include "ui-out.h"
64
#include "cli-out.h"
65
 
66
/* Default command line prompt.  This is overriden in some configs. */
67
 
68
#ifndef DEFAULT_PROMPT
69
#define DEFAULT_PROMPT  "(gdb) "
70
#endif
71
 
72
/* Initialization file name for gdb.  This is overridden in some configs.  */
73
 
74
#ifndef PATH_MAX
75
# ifdef FILENAME_MAX
76
#  define PATH_MAX FILENAME_MAX
77
# else
78
#  define PATH_MAX 512
79
# endif
80
#endif
81
 
82
#ifndef GDBINIT_FILENAME
83
#define GDBINIT_FILENAME        ".gdbinit"
84
#endif
85
char gdbinit[PATH_MAX + 1] = GDBINIT_FILENAME;
86
 
87
int inhibit_gdbinit = 0;
88
 
89
/* If nonzero, and GDB has been configured to be able to use windows,
90
   attempt to open them upon startup.  */
91
 
92
int use_windows = 0;
93
 
94
extern char lang_frame_mismatch_warn[];         /* language.c */
95
 
96
/* Flag for whether we want all the "from_tty" gubbish printed.  */
97
 
98
int caution = 1;                /* Default is yes, sigh. */
99
static void
100
show_caution (struct ui_file *file, int from_tty,
101
              struct cmd_list_element *c, const char *value)
102
{
103
  fprintf_filtered (file, _("\
104
Whether to confirm potentially dangerous operations is %s.\n"),
105
                    value);
106
}
107
 
108
/* stdio stream that command input is being read from.  Set to stdin normally.
109
   Set by source_command to the file we are sourcing.  Set to NULL if we are
110
   executing a user-defined command or interacting via a GUI.  */
111
 
112
FILE *instream;
113
 
114
/* Flag to indicate whether a user defined command is currently running.  */
115
 
116
int in_user_command;
117
 
118
/* Current working directory.  */
119
 
120
char *current_directory;
121
 
122
/* The directory name is actually stored here (usually).  */
123
char gdb_dirbuf[1024];
124
 
125
/* Function to call before reading a command, if nonzero.
126
   The function receives two args: an input stream,
127
   and a prompt string.  */
128
 
129
void (*window_hook) (FILE *, char *);
130
 
131
int epoch_interface;
132
int xgdb_verbose;
133
 
134
/* gdb prints this when reading a command interactively */
135
static char *gdb_prompt_string; /* the global prompt string */
136
 
137
/* Buffer used for reading command lines, and the size
138
   allocated for it so far.  */
139
 
140
char *line;
141
int linesize = 100;
142
 
143
/* Nonzero if the current command is modified by "server ".  This
144
   affects things like recording into the command history, commands
145
   repeating on RETURN, etc.  This is so a user interface (emacs, GUI,
146
   whatever) can issue its own commands and also send along commands
147
   from the user, and have the user not notice that the user interface
148
   is issuing commands too.  */
149
int server_command;
150
 
151
/* Baud rate specified for talking to serial target systems.  Default
152
   is left as -1, so targets can choose their own defaults.  */
153
/* FIXME: This means that "show remotebaud" and gr_files_info can print -1
154
   or (unsigned int)-1.  This is a Bad User Interface.  */
155
 
156
int baud_rate = -1;
157
 
158
/* Timeout limit for response from target. */
159
 
160
/* The default value has been changed many times over the years.  It
161
   was originally 5 seconds.  But that was thought to be a long time
162
   to sit and wait, so it was changed to 2 seconds.  That was thought
163
   to be plenty unless the connection was going through some terminal
164
   server or multiplexer or other form of hairy serial connection.
165
 
166
   In mid-1996, remote_timeout was moved from remote.c to top.c and
167
   it began being used in other remote-* targets.  It appears that the
168
   default was changed to 20 seconds at that time, perhaps because the
169
   Renesas E7000 ICE didn't always respond in a timely manner.
170
 
171
   But if 5 seconds is a long time to sit and wait for retransmissions,
172
   20 seconds is far worse.  This demonstrates the difficulty of using
173
   a single variable for all protocol timeouts.
174
 
175
   As remote.c is used much more than remote-e7000.c, it was changed
176
   back to 2 seconds in 1999. */
177
 
178
int remote_timeout = 2;
179
 
180
/* Non-zero tells remote* modules to output debugging info.  */
181
 
182
int remote_debug = 0;
183
 
184
/* Non-zero means the target is running. Note: this is different from
185
   saying that there is an active target and we are stopped at a
186
   breakpoint, for instance. This is a real indicator whether the
187
   target is off and running, which gdb is doing something else. */
188
int target_executing = 0;
189
 
190
/* Sbrk location on entry to main.  Used for statistics only.  */
191
#ifdef HAVE_SBRK
192
char *lim_at_start;
193
#endif
194
 
195
/* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT.  */
196
 
197
#ifndef STOP_SIGNAL
198
#ifdef SIGTSTP
199
#define STOP_SIGNAL SIGTSTP
200
static void stop_sig (int);
201
#endif
202
#endif
203
 
204
/* Hooks for alternate command interfaces.  */
205
 
206
/* Called after most modules have been initialized, but before taking users
207
   command file.
208
 
209
   If the UI fails to initialize and it wants GDB to continue
210
   using the default UI, then it should clear this hook before returning. */
211
 
212
void (*deprecated_init_ui_hook) (char *argv0);
213
 
214
/* This hook is called from within gdb's many mini-event loops which could
215
   steal control from a real user interface's event loop. It returns
216
   non-zero if the user is requesting a detach, zero otherwise. */
217
 
218
int (*deprecated_ui_loop_hook) (int);
219
 
220
/* Called instead of command_loop at top level.  Can be invoked via
221
   throw_exception().  */
222
 
223
void (*deprecated_command_loop_hook) (void);
224
 
225
 
226
/* Called from print_frame_info to list the line we stopped in.  */
227
 
228
void (*deprecated_print_frame_info_listing_hook) (struct symtab * s, int line,
229
                                                  int stopline, int noerror);
230
/* Replaces most of query.  */
231
 
232
int (*deprecated_query_hook) (const char *, va_list);
233
 
234
/* Replaces most of warning.  */
235
 
236
void (*deprecated_warning_hook) (const char *, va_list);
237
 
238
/* These three functions support getting lines of text from the user.
239
   They are used in sequence.  First deprecated_readline_begin_hook is
240
   called with a text string that might be (for example) a message for
241
   the user to type in a sequence of commands to be executed at a
242
   breakpoint.  If this function calls back to a GUI, it might take
243
   this opportunity to pop up a text interaction window with this
244
   message.  Next, deprecated_readline_hook is called with a prompt
245
   that is emitted prior to collecting the user input.  It can be
246
   called multiple times.  Finally, deprecated_readline_end_hook is
247
   called to notify the GUI that we are done with the interaction
248
   window and it can close it.  */
249
 
250
void (*deprecated_readline_begin_hook) (char *, ...);
251
char *(*deprecated_readline_hook) (char *);
252
void (*deprecated_readline_end_hook) (void);
253
 
254
/* Called as appropriate to notify the interface of the specified breakpoint
255
   conditions.  */
256
 
257
void (*deprecated_create_breakpoint_hook) (struct breakpoint * bpt);
258
void (*deprecated_delete_breakpoint_hook) (struct breakpoint * bpt);
259
void (*deprecated_modify_breakpoint_hook) (struct breakpoint * bpt);
260
 
261
/* Called as appropriate to notify the interface that we have attached
262
   to or detached from an already running process. */
263
 
264
void (*deprecated_attach_hook) (void);
265
void (*deprecated_detach_hook) (void);
266
 
267
/* Called during long calculations to allow GUI to repair window damage, and to
268
   check for stop buttons, etc... */
269
 
270
void (*deprecated_interactive_hook) (void);
271
 
272
/* Tell the GUI someone changed the register REGNO. -1 means
273
   that the caller does not know which register changed or
274
   that several registers have changed (see value_assign). */
275
void (*deprecated_register_changed_hook) (int regno);
276
 
277
/* Tell the GUI someone changed LEN bytes of memory at ADDR */
278
void (*deprecated_memory_changed_hook) (CORE_ADDR addr, int len);
279
 
280
/* Called when going to wait for the target.  Usually allows the GUI to run
281
   while waiting for target events.  */
282
 
283
ptid_t (*deprecated_target_wait_hook) (ptid_t ptid,
284
                                       struct target_waitstatus * status);
285
 
286
/* Used by UI as a wrapper around command execution.  May do various things
287
   like enabling/disabling buttons, etc...  */
288
 
289
void (*deprecated_call_command_hook) (struct cmd_list_element * c, char *cmd,
290
                                      int from_tty);
291
 
292
/* Called after a `set' command has finished.  Is only run if the
293
   `set' command succeeded.  */
294
 
295
void (*deprecated_set_hook) (struct cmd_list_element * c);
296
 
297
/* Called when the current thread changes.  Argument is thread id.  */
298
 
299
void (*deprecated_context_hook) (int id);
300
 
301
/* Takes control from error ().  Typically used to prevent longjmps out of the
302
   middle of the GUI.  Usually used in conjunction with a catch routine.  */
303
 
304
void (*deprecated_error_hook) (void);
305
 
306
/* Handler for SIGHUP.  */
307
 
308
#ifdef SIGHUP
309
/* NOTE 1999-04-29: This function will be static again, once we modify
310
   gdb to use the event loop as the default command loop and we merge
311
   event-top.c into this file, top.c */
312
/* static */ int
313
quit_cover (void *s)
314
{
315
  caution = 0;                   /* Throw caution to the wind -- we're exiting.
316
                                   This prevents asking the user dumb questions.  */
317
  quit_command ((char *) 0, 0);
318
  return 0;
319
}
320
#endif /* defined SIGHUP */
321
 
322
/* Line number we are currently in in a file which is being sourced.  */
323
/* NOTE 1999-04-29: This variable will be static again, once we modify
324
   gdb to use the event loop as the default command loop and we merge
325
   event-top.c into this file, top.c */
326
/* static */ int source_line_number;
327
 
328
/* Name of the file we are sourcing.  */
329
/* NOTE 1999-04-29: This variable will be static again, once we modify
330
   gdb to use the event loop as the default command loop and we merge
331
   event-top.c into this file, top.c */
332
/* static */ char *source_file_name;
333
 
334
/* Clean up on error during a "source" command (or execution of a
335
   user-defined command).  */
336
 
337
void
338
do_restore_instream_cleanup (void *stream)
339
{
340
  /* Restore the previous input stream.  */
341
  instream = stream;
342
}
343
 
344
/* Read commands from STREAM.  */
345
void
346
read_command_file (FILE *stream)
347
{
348
  struct cleanup *cleanups;
349
 
350
  cleanups = make_cleanup (do_restore_instream_cleanup, instream);
351
  instream = stream;
352
  command_loop ();
353
  do_cleanups (cleanups);
354
}
355
 
356
void (*pre_init_ui_hook) (void);
357
 
358
#ifdef __MSDOS__
359
void
360
do_chdir_cleanup (void *old_dir)
361
{
362
  chdir (old_dir);
363
  xfree (old_dir);
364
}
365
#endif
366
 
367
/* Execute the line P as a command.
368
   Pass FROM_TTY as second argument to the defining function.  */
369
 
370
void
371
execute_command (char *p, int from_tty)
372
{
373
  struct cmd_list_element *c;
374
  enum language flang;
375
  static int warned = 0;
376
  char *line;
377
 
378
  free_all_values ();
379
 
380
  /* Force cleanup of any alloca areas if using C alloca instead of
381
     a builtin alloca.  */
382
  alloca (0);
383
 
384
  /* This can happen when command_line_input hits end of file.  */
385
  if (p == NULL)
386
    return;
387
 
388
  target_log_command (p);
389
 
390
  while (*p == ' ' || *p == '\t')
391
    p++;
392
  if (*p)
393
    {
394
      char *arg;
395
      line = p;
396
 
397
      /* If trace-commands is set then this will print this command.  */
398
      print_command_trace (p);
399
 
400
      c = lookup_cmd (&p, cmdlist, "", 0, 1);
401
 
402
      /* If the target is running, we allow only a limited set of
403
         commands. */
404
      if (target_can_async_p () && target_executing)
405
        if (strcmp (c->name, "help") != 0
406
            && strcmp (c->name, "pwd") != 0
407
            && strcmp (c->name, "show") != 0
408
            && strcmp (c->name, "stop") != 0)
409
          error (_("Cannot execute this command while the target is running."));
410
 
411
      /* Pass null arg rather than an empty one.  */
412
      arg = *p ? p : 0;
413
 
414
      /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
415
         while the is_complete_command(cfunc) test is just plain
416
         bogus.  They should both be replaced by a test of the form
417
         c->strip_trailing_white_space_p.  */
418
      /* NOTE: cagney/2002-02-02: The function.cfunc in the below
419
         can't be replaced with func.  This is because it is the
420
         cfunc, and not the func, that has the value that the
421
         is_complete_command hack is testing for.  */
422
      /* Clear off trailing whitespace, except for set and complete
423
         command.  */
424
      if (arg
425
          && c->type != set_cmd
426
          && !is_complete_command (c))
427
        {
428
          p = arg + strlen (arg) - 1;
429
          while (p >= arg && (*p == ' ' || *p == '\t'))
430
            p--;
431
          *(p + 1) = '\0';
432
        }
433
 
434
      /* If this command has been pre-hooked, run the hook first. */
435
      execute_cmd_pre_hook (c);
436
 
437
      if (c->flags & DEPRECATED_WARN_USER)
438
        deprecated_cmd_warning (&line);
439
 
440
      if (c->class == class_user)
441
        execute_user_command (c, arg);
442
      else if (c->type == set_cmd || c->type == show_cmd)
443
        do_setshow_command (arg, from_tty & caution, c);
444
      else if (!cmd_func_p (c))
445
        error (_("That is not a command, just a help topic."));
446
      else if (deprecated_call_command_hook)
447
        deprecated_call_command_hook (c, arg, from_tty & caution);
448
      else
449
        cmd_func (c, arg, from_tty & caution);
450
 
451
      /* If this command has been post-hooked, run the hook last. */
452
      execute_cmd_post_hook (c);
453
 
454
    }
455
 
456
  /* Tell the user if the language has changed (except first time).  */
457
  if (current_language != expected_language)
458
    {
459
      if (language_mode == language_mode_auto)
460
        {
461
          language_info (1);    /* Print what changed.  */
462
        }
463
      warned = 0;
464
    }
465
 
466
  /* Warn the user if the working language does not match the
467
     language of the current frame.  Only warn the user if we are
468
     actually running the program, i.e. there is a stack. */
469
  /* FIXME:  This should be cacheing the frame and only running when
470
     the frame changes.  */
471
 
472
  if (target_has_stack)
473
    {
474
      flang = get_frame_language ();
475
      if (!warned
476
          && flang != language_unknown
477
          && flang != current_language->la_language)
478
        {
479
          printf_filtered ("%s\n", lang_frame_mismatch_warn);
480
          warned = 1;
481
        }
482
    }
483
}
484
 
485
/* Read commands from `instream' and execute them
486
   until end of file or error reading instream.  */
487
 
488
void
489
command_loop (void)
490
{
491
  struct cleanup *old_chain;
492
  char *command;
493
  int stdin_is_tty = ISATTY (stdin);
494
  long time_at_cmd_start;
495
#ifdef HAVE_SBRK
496
  long space_at_cmd_start = 0;
497
#endif
498
  extern int display_time;
499
  extern int display_space;
500
 
501
  while (instream && !feof (instream))
502
    {
503
      if (window_hook && instream == stdin)
504
        (*window_hook) (instream, get_prompt ());
505
 
506
      quit_flag = 0;
507
      if (instream == stdin && stdin_is_tty)
508
        reinitialize_more_filter ();
509
      old_chain = make_cleanup (null_cleanup, 0);
510
 
511
      /* Get a command-line. This calls the readline package. */
512
      command = command_line_input (instream == stdin ?
513
                                    get_prompt () : (char *) NULL,
514
                                    instream == stdin, "prompt");
515
      if (command == 0)
516
        return;
517
 
518
      time_at_cmd_start = get_run_time ();
519
 
520
      if (display_space)
521
        {
522
#ifdef HAVE_SBRK
523
          char *lim = (char *) sbrk (0);
524
          space_at_cmd_start = lim - lim_at_start;
525
#endif
526
        }
527
 
528
      execute_command (command, instream == stdin);
529
      /* Do any commands attached to breakpoint we stopped at.  */
530
      bpstat_do_actions (&stop_bpstat);
531
      do_cleanups (old_chain);
532
 
533
      if (display_time)
534
        {
535
          long cmd_time = get_run_time () - time_at_cmd_start;
536
 
537
          printf_unfiltered (_("Command execution time: %ld.%06ld\n"),
538
                             cmd_time / 1000000, cmd_time % 1000000);
539
        }
540
 
541
      if (display_space)
542
        {
543
#ifdef HAVE_SBRK
544
          char *lim = (char *) sbrk (0);
545
          long space_now = lim - lim_at_start;
546
          long space_diff = space_now - space_at_cmd_start;
547
 
548
          printf_unfiltered (_("Space used: %ld (%s%ld for this command)\n"),
549
                             space_now,
550
                             (space_diff >= 0 ? "+" : ""),
551
                             space_diff);
552
#endif
553
        }
554
    }
555
}
556
 
557
/* Read commands from `instream' and execute them until end of file or
558
   error reading instream. This command loop doesnt care about any
559
   such things as displaying time and space usage. If the user asks
560
   for those, they won't work. */
561
void
562
simplified_command_loop (char *(*read_input_func) (char *),
563
                         void (*execute_command_func) (char *, int))
564
{
565
  struct cleanup *old_chain;
566
  char *command;
567
  int stdin_is_tty = ISATTY (stdin);
568
 
569
  while (instream && !feof (instream))
570
    {
571
      quit_flag = 0;
572
      if (instream == stdin && stdin_is_tty)
573
        reinitialize_more_filter ();
574
      old_chain = make_cleanup (null_cleanup, 0);
575
 
576
      /* Get a command-line. */
577
      command = (*read_input_func) (instream == stdin ?
578
                                    get_prompt () : (char *) NULL);
579
 
580
      if (command == 0)
581
        return;
582
 
583
      (*execute_command_func) (command, instream == stdin);
584
 
585
      /* Do any commands attached to breakpoint we stopped at.  */
586
      bpstat_do_actions (&stop_bpstat);
587
 
588
      do_cleanups (old_chain);
589
    }
590
}
591
 
592
/* Commands call this if they do not want to be repeated by null lines.  */
593
 
594
void
595
dont_repeat (void)
596
{
597
  if (server_command)
598
    return;
599
 
600
  /* If we aren't reading from standard input, we are saving the last
601
     thing read from stdin in line and don't want to delete it.  Null lines
602
     won't repeat here in any case.  */
603
  if (instream == stdin)
604
    *line = 0;
605
}
606
 
607
/* Read a line from the stream "instream" without command line editing.
608
 
609
   It prints PROMPT_ARG once at the start.
610
   Action is compatible with "readline", e.g. space for the result is
611
   malloc'd and should be freed by the caller.
612
 
613
   A NULL return means end of file.  */
614
char *
615
gdb_readline (char *prompt_arg)
616
{
617
  int c;
618
  char *result;
619
  int input_index = 0;
620
  int result_size = 80;
621
 
622
  if (prompt_arg)
623
    {
624
      /* Don't use a _filtered function here.  It causes the assumed
625
         character position to be off, since the newline we read from
626
         the user is not accounted for.  */
627
      fputs_unfiltered (prompt_arg, gdb_stdout);
628
      gdb_flush (gdb_stdout);
629
    }
630
 
631
  result = (char *) xmalloc (result_size);
632
 
633
  while (1)
634
    {
635
      /* Read from stdin if we are executing a user defined command.
636
         This is the right thing for prompt_for_continue, at least.  */
637
      c = fgetc (instream ? instream : stdin);
638
 
639
      if (c == EOF)
640
        {
641
          if (input_index > 0)
642
            /* The last line does not end with a newline.  Return it, and
643
               if we are called again fgetc will still return EOF and
644
               we'll return NULL then.  */
645
            break;
646
          xfree (result);
647
          return NULL;
648
        }
649
 
650
      if (c == '\n')
651
        {
652
          if (input_index > 0 && result[input_index - 1] == '\r')
653
            input_index--;
654
          break;
655
        }
656
 
657
      result[input_index++] = c;
658
      while (input_index >= result_size)
659
        {
660
          result_size *= 2;
661
          result = (char *) xrealloc (result, result_size);
662
        }
663
    }
664
 
665
  result[input_index++] = '\0';
666
  return result;
667
}
668
 
669
/* Variables which control command line editing and history
670
   substitution.  These variables are given default values at the end
671
   of this file.  */
672
static int command_editing_p;
673
 
674
/* NOTE 1999-04-29: This variable will be static again, once we modify
675
   gdb to use the event loop as the default command loop and we merge
676
   event-top.c into this file, top.c */
677
 
678
/* static */ int history_expansion_p;
679
 
680
static int write_history_p;
681
static void
682
show_write_history_p (struct ui_file *file, int from_tty,
683
                      struct cmd_list_element *c, const char *value)
684
{
685
  fprintf_filtered (file, _("Saving of the history record on exit is %s.\n"),
686
                    value);
687
}
688
 
689
static int history_size;
690
static void
691
show_history_size (struct ui_file *file, int from_tty,
692
                   struct cmd_list_element *c, const char *value)
693
{
694
  fprintf_filtered (file, _("The size of the command history is %s.\n"),
695
                    value);
696
}
697
 
698
static char *history_filename;
699
static void
700
show_history_filename (struct ui_file *file, int from_tty,
701
                       struct cmd_list_element *c, const char *value)
702
{
703
  fprintf_filtered (file, _("\
704
The filename in which to record the command history is \"%s\".\n"),
705
                    value);
706
}
707
 
708
/* This is like readline(), but it has some gdb-specific behavior.
709
   gdb may want readline in both the synchronous and async modes during
710
   a single gdb invocation.  At the ordinary top-level prompt we might
711
   be using the async readline.  That means we can't use
712
   rl_pre_input_hook, since it doesn't work properly in async mode.
713
   However, for a secondary prompt (" >", such as occurs during a
714
   `define'), gdb wants a synchronous response.
715
 
716
   We used to call readline() directly, running it in synchronous
717
   mode.  But mixing modes this way is not supported, and as of
718
   readline 5.x it no longer works; the arrow keys come unbound during
719
   the synchronous call.  So we make a nested call into the event
720
   loop.  That's what gdb_readline_wrapper is for.  */
721
 
722
/* A flag set as soon as gdb_readline_wrapper_line is called; we can't
723
   rely on gdb_readline_wrapper_result, which might still be NULL if
724
   the user types Control-D for EOF.  */
725
static int gdb_readline_wrapper_done;
726
 
727
/* The result of the current call to gdb_readline_wrapper, once a newline
728
   is seen.  */
729
static char *gdb_readline_wrapper_result;
730
 
731
/* Any intercepted hook.  Operate-and-get-next sets this, expecting it
732
   to be called after the newline is processed (which will redisplay
733
   the prompt).  But in gdb_readline_wrapper we will not get a new
734
   prompt until the next call, or until we return to the event loop.
735
   So we disable this hook around the newline and restore it before we
736
   return.  */
737
static void (*saved_after_char_processing_hook) (void);
738
 
739
/* This function is called when readline has seen a complete line of
740
   text.  */
741
 
742
static void
743
gdb_readline_wrapper_line (char *line)
744
{
745
  gdb_assert (!gdb_readline_wrapper_done);
746
  gdb_readline_wrapper_result = line;
747
  gdb_readline_wrapper_done = 1;
748
 
749
  /* Prevent operate-and-get-next from acting too early.  */
750
  saved_after_char_processing_hook = after_char_processing_hook;
751
  after_char_processing_hook = NULL;
752
 
753
  /* Prevent parts of the prompt from being redisplayed if annotations
754
     are enabled, and readline's state getting out of sync.  */
755
  if (async_command_editing_p)
756
    rl_callback_handler_remove ();
757
}
758
 
759
struct gdb_readline_wrapper_cleanup
760
  {
761
    void (*handler_orig) (char *);
762
    int already_prompted_orig;
763
  };
764
 
765
static void
766
gdb_readline_wrapper_cleanup (void *arg)
767
{
768
  struct gdb_readline_wrapper_cleanup *cleanup = arg;
769
 
770
  rl_already_prompted = cleanup->already_prompted_orig;
771
 
772
  gdb_assert (input_handler == gdb_readline_wrapper_line);
773
  input_handler = cleanup->handler_orig;
774
  gdb_readline_wrapper_result = NULL;
775
  gdb_readline_wrapper_done = 0;
776
 
777
  after_char_processing_hook = saved_after_char_processing_hook;
778
  saved_after_char_processing_hook = NULL;
779
 
780
  xfree (cleanup);
781
}
782
 
783
char *
784
gdb_readline_wrapper (char *prompt)
785
{
786
  struct cleanup *back_to;
787
  struct gdb_readline_wrapper_cleanup *cleanup;
788
  char *retval;
789
 
790
  cleanup = xmalloc (sizeof (*cleanup));
791
  cleanup->handler_orig = input_handler;
792
  input_handler = gdb_readline_wrapper_line;
793
 
794
  cleanup->already_prompted_orig = rl_already_prompted;
795
 
796
  back_to = make_cleanup (gdb_readline_wrapper_cleanup, cleanup);
797
 
798
  /* Display our prompt and prevent double prompt display.  */
799
  display_gdb_prompt (prompt);
800
  rl_already_prompted = 1;
801
 
802
  if (after_char_processing_hook)
803
    (*after_char_processing_hook) ();
804
  gdb_assert (after_char_processing_hook == NULL);
805
 
806
  /* gdb_do_one_event argument is unused.  */
807
  while (gdb_do_one_event (NULL) >= 0)
808
    if (gdb_readline_wrapper_done)
809
      break;
810
 
811
  retval = gdb_readline_wrapper_result;
812
  do_cleanups (back_to);
813
  return retval;
814
}
815
 
816
 
817
#ifdef STOP_SIGNAL
818
static void
819
stop_sig (int signo)
820
{
821
#if STOP_SIGNAL == SIGTSTP
822
  signal (SIGTSTP, SIG_DFL);
823
#if HAVE_SIGPROCMASK
824
  {
825
    sigset_t zero;
826
 
827
    sigemptyset (&zero);
828
    sigprocmask (SIG_SETMASK, &zero, 0);
829
  }
830
#elif HAVE_SIGSETMASK
831
  sigsetmask (0);
832
#endif
833
  kill (getpid (), SIGTSTP);
834
  signal (SIGTSTP, stop_sig);
835
#else
836
  signal (STOP_SIGNAL, stop_sig);
837
#endif
838
  printf_unfiltered ("%s", get_prompt ());
839
  gdb_flush (gdb_stdout);
840
 
841
  /* Forget about any previous command -- null line now will do nothing.  */
842
  dont_repeat ();
843
}
844
#endif /* STOP_SIGNAL */
845
 
846
/* Initialize signal handlers. */
847
static void
848
float_handler (int signo)
849
{
850
  /* This message is based on ANSI C, section 4.7.  Note that integer
851
     divide by zero causes this, so "float" is a misnomer.  */
852
  signal (SIGFPE, float_handler);
853
  error (_("Erroneous arithmetic operation."));
854
}
855
 
856
static void
857
do_nothing (int signo)
858
{
859
  /* Under System V the default disposition of a signal is reinstated after
860
     the signal is caught and delivered to an application process.  On such
861
     systems one must restore the replacement signal handler if one wishes
862
     to continue handling the signal in one's program.  On BSD systems this
863
     is not needed but it is harmless, and it simplifies the code to just do
864
     it unconditionally. */
865
  signal (signo, do_nothing);
866
}
867
 
868
/* The current saved history number from operate-and-get-next.
869
   This is -1 if not valid.  */
870
static int operate_saved_history = -1;
871
 
872
/* This is put on the appropriate hook and helps operate-and-get-next
873
   do its work.  */
874
static void
875
gdb_rl_operate_and_get_next_completion (void)
876
{
877
  int delta = where_history () - operate_saved_history;
878
  /* The `key' argument to rl_get_previous_history is ignored.  */
879
  rl_get_previous_history (delta, 0);
880
  operate_saved_history = -1;
881
 
882
  /* readline doesn't automatically update the display for us.  */
883
  rl_redisplay ();
884
 
885
  after_char_processing_hook = NULL;
886
  rl_pre_input_hook = NULL;
887
}
888
 
889
/* This is a gdb-local readline command handler.  It accepts the
890
   current command line (like RET does) and, if this command was taken
891
   from the history, arranges for the next command in the history to
892
   appear on the command line when the prompt returns.
893
   We ignore the arguments.  */
894
static int
895
gdb_rl_operate_and_get_next (int count, int key)
896
{
897
  int where;
898
 
899
  /* Use the async hook.  */
900
  after_char_processing_hook = gdb_rl_operate_and_get_next_completion;
901
 
902
  /* Find the current line, and find the next line to use.  */
903
  where = where_history();
904
 
905
  /* FIXME: kettenis/20020817: max_input_history is renamed into
906
     history_max_entries in readline-4.2.  When we do a new readline
907
     import, we should probably change it here too, even though
908
     readline maintains backwards compatibility for now by still
909
     defining max_input_history.  */
910
  if ((history_is_stifled () && (history_length >= max_input_history)) ||
911
      (where >= history_length - 1))
912
    operate_saved_history = where;
913
  else
914
    operate_saved_history = where + 1;
915
 
916
  return rl_newline (1, key);
917
}
918
 
919
/* Read one line from the command input stream `instream'
920
   into the local static buffer `linebuffer' (whose current length
921
   is `linelength').
922
   The buffer is made bigger as necessary.
923
   Returns the address of the start of the line.
924
 
925
   NULL is returned for end of file.
926
 
927
   *If* the instream == stdin & stdin is a terminal, the line read
928
   is copied into the file line saver (global var char *line,
929
   length linesize) so that it can be duplicated.
930
 
931
   This routine either uses fancy command line editing or
932
   simple input as the user has requested.  */
933
 
934
char *
935
command_line_input (char *prompt_arg, int repeat, char *annotation_suffix)
936
{
937
  static char *linebuffer = 0;
938
  static unsigned linelength = 0;
939
  char *p;
940
  char *p1;
941
  char *rl;
942
  char *local_prompt = prompt_arg;
943
  char *nline;
944
  char got_eof = 0;
945
 
946
  /* The annotation suffix must be non-NULL.  */
947
  if (annotation_suffix == NULL)
948
    annotation_suffix = "";
949
 
950
  if (annotation_level > 1 && instream == stdin)
951
    {
952
      local_prompt = alloca ((prompt_arg == NULL ? 0 : strlen (prompt_arg))
953
                             + strlen (annotation_suffix) + 40);
954
      if (prompt_arg == NULL)
955
        local_prompt[0] = '\0';
956
      else
957
        strcpy (local_prompt, prompt_arg);
958
      strcat (local_prompt, "\n\032\032");
959
      strcat (local_prompt, annotation_suffix);
960
      strcat (local_prompt, "\n");
961
    }
962
 
963
  if (linebuffer == 0)
964
    {
965
      linelength = 80;
966
      linebuffer = (char *) xmalloc (linelength);
967
    }
968
 
969
  p = linebuffer;
970
 
971
  /* Control-C quits instantly if typed while in this loop
972
     since it should not wait until the user types a newline.  */
973
  immediate_quit++;
974
#ifdef STOP_SIGNAL
975
  if (job_control)
976
    signal (STOP_SIGNAL, handle_stop_sig);
977
#endif
978
 
979
  while (1)
980
    {
981
      /* Make sure that all output has been output.  Some machines may let
982
         you get away with leaving out some of the gdb_flush, but not all.  */
983
      wrap_here ("");
984
      gdb_flush (gdb_stdout);
985
      gdb_flush (gdb_stderr);
986
 
987
      if (source_file_name != NULL)
988
        ++source_line_number;
989
 
990
      if (annotation_level > 1 && instream == stdin)
991
        {
992
          puts_unfiltered ("\n\032\032pre-");
993
          puts_unfiltered (annotation_suffix);
994
          puts_unfiltered ("\n");
995
        }
996
 
997
      /* Don't use fancy stuff if not talking to stdin.  */
998
      if (deprecated_readline_hook && input_from_terminal_p ())
999
        {
1000
          rl = (*deprecated_readline_hook) (local_prompt);
1001
        }
1002
      else if (command_editing_p && input_from_terminal_p ())
1003
        {
1004
          rl = gdb_readline_wrapper (local_prompt);
1005
        }
1006
      else
1007
        {
1008
          rl = gdb_readline (local_prompt);
1009
        }
1010
 
1011
      if (annotation_level > 1 && instream == stdin)
1012
        {
1013
          puts_unfiltered ("\n\032\032post-");
1014
          puts_unfiltered (annotation_suffix);
1015
          puts_unfiltered ("\n");
1016
        }
1017
 
1018
      if (!rl || rl == (char *) EOF)
1019
        {
1020
          got_eof = 1;
1021
          break;
1022
        }
1023
      if (strlen (rl) + 1 + (p - linebuffer) > linelength)
1024
        {
1025
          linelength = strlen (rl) + 1 + (p - linebuffer);
1026
          nline = (char *) xrealloc (linebuffer, linelength);
1027
          p += nline - linebuffer;
1028
          linebuffer = nline;
1029
        }
1030
      p1 = rl;
1031
      /* Copy line.  Don't copy null at end.  (Leaves line alone
1032
         if this was just a newline)  */
1033
      while (*p1)
1034
        *p++ = *p1++;
1035
 
1036
      xfree (rl);               /* Allocated in readline.  */
1037
 
1038
      if (p == linebuffer || *(p - 1) != '\\')
1039
        break;
1040
 
1041
      p--;                      /* Put on top of '\'.  */
1042
      local_prompt = (char *) 0;
1043
    }
1044
 
1045
#ifdef STOP_SIGNAL
1046
  if (job_control)
1047
    signal (STOP_SIGNAL, SIG_DFL);
1048
#endif
1049
  immediate_quit--;
1050
 
1051
  if (got_eof)
1052
    return NULL;
1053
 
1054
#define SERVER_COMMAND_LENGTH 7
1055
  server_command =
1056
    (p - linebuffer > SERVER_COMMAND_LENGTH)
1057
    && strncmp (linebuffer, "server ", SERVER_COMMAND_LENGTH) == 0;
1058
  if (server_command)
1059
    {
1060
      /* Note that we don't set `line'.  Between this and the check in
1061
         dont_repeat, this insures that repeating will still do the
1062
         right thing.  */
1063
      *p = '\0';
1064
      return linebuffer + SERVER_COMMAND_LENGTH;
1065
    }
1066
 
1067
  /* Do history expansion if that is wished.  */
1068
  if (history_expansion_p && instream == stdin
1069
      && ISATTY (instream))
1070
    {
1071
      char *history_value;
1072
      int expanded;
1073
 
1074
      *p = '\0';                /* Insert null now.  */
1075
      expanded = history_expand (linebuffer, &history_value);
1076
      if (expanded)
1077
        {
1078
          /* Print the changes.  */
1079
          printf_unfiltered ("%s\n", history_value);
1080
 
1081
          /* If there was an error, call this function again.  */
1082
          if (expanded < 0)
1083
            {
1084
              xfree (history_value);
1085
              return command_line_input (prompt_arg, repeat, annotation_suffix);
1086
            }
1087
          if (strlen (history_value) > linelength)
1088
            {
1089
              linelength = strlen (history_value) + 1;
1090
              linebuffer = (char *) xrealloc (linebuffer, linelength);
1091
            }
1092
          strcpy (linebuffer, history_value);
1093
          p = linebuffer + strlen (linebuffer);
1094
        }
1095
      xfree (history_value);
1096
    }
1097
 
1098
  /* If we just got an empty line, and that is supposed
1099
     to repeat the previous command, return the value in the
1100
     global buffer.  */
1101
  if (repeat && p == linebuffer)
1102
    return line;
1103
  for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++);
1104
  if (repeat && !*p1)
1105
    return line;
1106
 
1107
  *p = 0;
1108
 
1109
  /* Add line to history if appropriate.  */
1110
  if (instream == stdin
1111
      && ISATTY (stdin) && *linebuffer)
1112
    add_history (linebuffer);
1113
 
1114
  /* Note: lines consisting solely of comments are added to the command
1115
     history.  This is useful when you type a command, and then
1116
     realize you don't want to execute it quite yet.  You can comment
1117
     out the command and then later fetch it from the value history
1118
     and remove the '#'.  The kill ring is probably better, but some
1119
     people are in the habit of commenting things out.  */
1120
  if (*p1 == '#')
1121
    *p1 = '\0';                 /* Found a comment. */
1122
 
1123
  /* Save into global buffer if appropriate.  */
1124
  if (repeat)
1125
    {
1126
      if (linelength > linesize)
1127
        {
1128
          line = xrealloc (line, linelength);
1129
          linesize = linelength;
1130
        }
1131
      strcpy (line, linebuffer);
1132
      return line;
1133
    }
1134
 
1135
  return linebuffer;
1136
}
1137
 
1138
/* Print the GDB banner. */
1139
void
1140
print_gdb_version (struct ui_file *stream)
1141
{
1142
  /* From GNU coding standards, first line is meant to be easy for a
1143
     program to parse, and is just canonical program name and version
1144
     number, which starts after last space. */
1145
 
1146
  fprintf_filtered (stream, "GNU gdb %s\n", version);
1147
 
1148
  /* Second line is a copyright notice. */
1149
 
1150
  fprintf_filtered (stream, "Copyright (C) 2008 Free Software Foundation, Inc.\n");
1151
 
1152
  /* Following the copyright is a brief statement that the program is
1153
     free software, that users are free to copy and change it on
1154
     certain conditions, that it is covered by the GNU GPL, and that
1155
     there is no warranty. */
1156
 
1157
  fprintf_filtered (stream, "\
1158
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n\
1159
This is free software: you are free to change and redistribute it.\n\
1160
There is NO WARRANTY, to the extent permitted by law.  Type \"show copying\"\n\
1161
and \"show warranty\" for details.\n");
1162
 
1163
  /* After the required info we print the configuration information. */
1164
 
1165
  fprintf_filtered (stream, "This GDB was configured as \"");
1166
  if (strcmp (host_name, target_name) != 0)
1167
    {
1168
      fprintf_filtered (stream, "--host=%s --target=%s", host_name, target_name);
1169
    }
1170
  else
1171
    {
1172
      fprintf_filtered (stream, "%s", host_name);
1173
    }
1174
  fprintf_filtered (stream, "\".");
1175
}
1176
 
1177
/* get_prompt: access method for the GDB prompt string.  */
1178
 
1179
char *
1180
get_prompt (void)
1181
{
1182
  return PROMPT (0);
1183
}
1184
 
1185
void
1186
set_prompt (char *s)
1187
{
1188
/* ??rehrauer: I don't know why this fails, since it looks as though
1189
   assignments to prompt are wrapped in calls to savestring...
1190
   if (prompt != NULL)
1191
   xfree (prompt);
1192
 */
1193
  PROMPT (0) = savestring (s, strlen (s));
1194
}
1195
 
1196
 
1197
/* If necessary, make the user confirm that we should quit.  Return
1198
   non-zero if we should quit, zero if we shouldn't.  */
1199
 
1200
int
1201
quit_confirm (void)
1202
{
1203
  if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
1204
    {
1205
      char *s;
1206
 
1207
      /* This is something of a hack.  But there's no reliable way to
1208
         see if a GUI is running.  The `use_windows' variable doesn't
1209
         cut it.  */
1210
      if (deprecated_init_ui_hook)
1211
        s = "A debugging session is active.\nDo you still want to close the debugger?";
1212
      else if (attach_flag)
1213
        s = "The program is running.  Quit anyway (and detach it)? ";
1214
      else
1215
        s = "The program is running.  Exit anyway? ";
1216
 
1217
      if (!query ("%s", s))
1218
        return 0;
1219
    }
1220
 
1221
  return 1;
1222
}
1223
 
1224
/* Helper routine for quit_force that requires error handling.  */
1225
 
1226
struct qt_args
1227
{
1228
  char *args;
1229
  int from_tty;
1230
};
1231
 
1232
static int
1233
quit_target (void *arg)
1234
{
1235
  struct qt_args *qt = (struct qt_args *)arg;
1236
 
1237
  if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
1238
    {
1239
      if (attach_flag)
1240
        target_detach (qt->args, qt->from_tty);
1241
      else
1242
        target_kill ();
1243
    }
1244
 
1245
  /* UDI wants this, to kill the TIP.  */
1246
  target_close (&current_target, 1);
1247
 
1248
  /* Save the history information if it is appropriate to do so.  */
1249
  if (write_history_p && history_filename)
1250
    write_history (history_filename);
1251
 
1252
  do_final_cleanups (ALL_CLEANUPS);     /* Do any final cleanups before exiting */
1253
 
1254
  return 0;
1255
}
1256
 
1257
/* Quit without asking for confirmation.  */
1258
 
1259
void
1260
quit_force (char *args, int from_tty)
1261
{
1262
  int exit_code = 0;
1263
  struct qt_args qt;
1264
 
1265
  /* An optional expression may be used to cause gdb to terminate with the
1266
     value of that expression. */
1267
  if (args)
1268
    {
1269
      struct value *val = parse_and_eval (args);
1270
 
1271
      exit_code = (int) value_as_long (val);
1272
    }
1273
  else if (return_child_result)
1274
    exit_code = return_child_result_value;
1275
 
1276
  qt.args = args;
1277
  qt.from_tty = from_tty;
1278
 
1279
  /* We want to handle any quit errors and exit regardless.  */
1280
  catch_errors (quit_target, &qt,
1281
                "Quitting: ", RETURN_MASK_ALL);
1282
 
1283
  exit (exit_code);
1284
}
1285
 
1286
/* Returns whether GDB is running on a terminal and input is
1287
   currently coming from that terminal.  */
1288
 
1289
int
1290
input_from_terminal_p (void)
1291
{
1292
  if (gdb_has_a_terminal () && instream == stdin)
1293
    return 1;
1294
 
1295
  /* If INSTREAM is unset, and we are not in a user command, we
1296
     must be in Insight.  That's like having a terminal, for our
1297
     purposes.  */
1298
  if (instream == NULL && !in_user_command)
1299
    return 1;
1300
 
1301
  return 0;
1302
}
1303
 
1304
static void
1305
dont_repeat_command (char *ignored, int from_tty)
1306
{
1307
  *line = 0;                     /* Can't call dont_repeat here because we're not
1308
                                   necessarily reading from stdin.  */
1309
}
1310
 
1311
/* Functions to manipulate command line editing control variables.  */
1312
 
1313
/* Number of commands to print in each call to show_commands.  */
1314
#define Hist_print 10
1315
void
1316
show_commands (char *args, int from_tty)
1317
{
1318
  /* Index for history commands.  Relative to history_base.  */
1319
  int offset;
1320
 
1321
  /* Number of the history entry which we are planning to display next.
1322
     Relative to history_base.  */
1323
  static int num = 0;
1324
 
1325
  /* The first command in the history which doesn't exist (i.e. one more
1326
     than the number of the last command).  Relative to history_base.  */
1327
  int hist_len;
1328
 
1329
  /* Print out some of the commands from the command history.  */
1330
  /* First determine the length of the history list.  */
1331
  hist_len = history_size;
1332
  for (offset = 0; offset < history_size; offset++)
1333
    {
1334
      if (!history_get (history_base + offset))
1335
        {
1336
          hist_len = offset;
1337
          break;
1338
        }
1339
    }
1340
 
1341
  if (args)
1342
    {
1343
      if (args[0] == '+' && args[1] == '\0')
1344
        /* "info editing +" should print from the stored position.  */
1345
        ;
1346
      else
1347
        /* "info editing <exp>" should print around command number <exp>.  */
1348
        num = (parse_and_eval_long (args) - history_base) - Hist_print / 2;
1349
    }
1350
  /* "show commands" means print the last Hist_print commands.  */
1351
  else
1352
    {
1353
      num = hist_len - Hist_print;
1354
    }
1355
 
1356
  if (num < 0)
1357
    num = 0;
1358
 
1359
  /* If there are at least Hist_print commands, we want to display the last
1360
     Hist_print rather than, say, the last 6.  */
1361
  if (hist_len - num < Hist_print)
1362
    {
1363
      num = hist_len - Hist_print;
1364
      if (num < 0)
1365
        num = 0;
1366
    }
1367
 
1368
  for (offset = num; offset < num + Hist_print && offset < hist_len; offset++)
1369
    {
1370
      printf_filtered ("%5d  %s\n", history_base + offset,
1371
                       (history_get (history_base + offset))->line);
1372
    }
1373
 
1374
  /* The next command we want to display is the next one that we haven't
1375
     displayed yet.  */
1376
  num += Hist_print;
1377
 
1378
  /* If the user repeats this command with return, it should do what
1379
     "show commands +" does.  This is unnecessary if arg is null,
1380
     because "show commands +" is not useful after "show commands".  */
1381
  if (from_tty && args)
1382
    {
1383
      args[0] = '+';
1384
      args[1] = '\0';
1385
    }
1386
}
1387
 
1388
/* Called by do_setshow_command.  */
1389
static void
1390
set_history_size_command (char *args, int from_tty, struct cmd_list_element *c)
1391
{
1392
  if (history_size == INT_MAX)
1393
    unstifle_history ();
1394
  else if (history_size >= 0)
1395
    stifle_history (history_size);
1396
  else
1397
    {
1398
      history_size = INT_MAX;
1399
      error (_("History size must be non-negative"));
1400
    }
1401
}
1402
 
1403
void
1404
set_history (char *args, int from_tty)
1405
{
1406
  printf_unfiltered (_("\"set history\" must be followed by the name of a history subcommand.\n"));
1407
  help_list (sethistlist, "set history ", -1, gdb_stdout);
1408
}
1409
 
1410
void
1411
show_history (char *args, int from_tty)
1412
{
1413
  cmd_show_list (showhistlist, from_tty, "");
1414
}
1415
 
1416
int info_verbose = 0;            /* Default verbose msgs off */
1417
 
1418
/* Called by do_setshow_command.  An elaborate joke.  */
1419
void
1420
set_verbose (char *args, int from_tty, struct cmd_list_element *c)
1421
{
1422
  char *cmdname = "verbose";
1423
  struct cmd_list_element *showcmd;
1424
 
1425
  showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
1426
 
1427
  if (info_verbose)
1428
    {
1429
      c->doc = "Set verbose printing of informational messages.";
1430
      showcmd->doc = "Show verbose printing of informational messages.";
1431
    }
1432
  else
1433
    {
1434
      c->doc = "Set verbosity.";
1435
      showcmd->doc = "Show verbosity.";
1436
    }
1437
}
1438
 
1439
/* Init the history buffer.  Note that we are called after the init file(s)
1440
 * have been read so that the user can change the history file via his
1441
 * .gdbinit file (for instance).  The GDBHISTFILE environment variable
1442
 * overrides all of this.
1443
 */
1444
 
1445
void
1446
init_history (void)
1447
{
1448
  char *tmpenv;
1449
 
1450
  tmpenv = getenv ("HISTSIZE");
1451
  if (tmpenv)
1452
    history_size = atoi (tmpenv);
1453
  else if (!history_size)
1454
    history_size = 256;
1455
 
1456
  stifle_history (history_size);
1457
 
1458
  tmpenv = getenv ("GDBHISTFILE");
1459
  if (tmpenv)
1460
    history_filename = savestring (tmpenv, strlen (tmpenv));
1461
  else if (!history_filename)
1462
    {
1463
      /* We include the current directory so that if the user changes
1464
         directories the file written will be the same as the one
1465
         that was read.  */
1466
#ifdef __MSDOS__
1467
      /* No leading dots in file names are allowed on MSDOS.  */
1468
      history_filename = concat (current_directory, "/_gdb_history",
1469
                                 (char *)NULL);
1470
#else
1471
      history_filename = concat (current_directory, "/.gdb_history",
1472
                                 (char *)NULL);
1473
#endif
1474
    }
1475
  read_history (history_filename);
1476
}
1477
 
1478
static void
1479
show_new_async_prompt (struct ui_file *file, int from_tty,
1480
                       struct cmd_list_element *c, const char *value)
1481
{
1482
  fprintf_filtered (file, _("Gdb's prompt is \"%s\".\n"), value);
1483
}
1484
 
1485
static void
1486
show_async_command_editing_p (struct ui_file *file, int from_tty,
1487
                              struct cmd_list_element *c, const char *value)
1488
{
1489
  fprintf_filtered (file, _("\
1490
Editing of command lines as they are typed is %s.\n"),
1491
                    value);
1492
}
1493
 
1494
static void
1495
show_annotation_level (struct ui_file *file, int from_tty,
1496
                       struct cmd_list_element *c, const char *value)
1497
{
1498
  fprintf_filtered (file, _("Annotation_level is %s.\n"), value);
1499
}
1500
 
1501
static void
1502
show_exec_done_display_p (struct ui_file *file, int from_tty,
1503
                          struct cmd_list_element *c, const char *value)
1504
{
1505
  fprintf_filtered (file, _("\
1506
Notification of completion for asynchronous execution commands is %s.\n"),
1507
                    value);
1508
}
1509
static void
1510
init_main (void)
1511
{
1512
  struct cmd_list_element *c;
1513
 
1514
  /* initialize the prompt stack to a simple "(gdb) " prompt or to
1515
     whatever the DEFAULT_PROMPT is.  */
1516
  the_prompts.top = 0;
1517
  PREFIX (0) = "";
1518
  PROMPT (0) = savestring (DEFAULT_PROMPT, strlen (DEFAULT_PROMPT));
1519
  SUFFIX (0) = "";
1520
  /* Set things up for annotation_level > 1, if the user ever decides
1521
     to use it.  */
1522
  async_annotation_suffix = "prompt";
1523
  /* Set the variable associated with the setshow prompt command.  */
1524
  new_async_prompt = savestring (PROMPT (0), strlen (PROMPT (0)));
1525
 
1526
  /* If gdb was started with --annotate=2, this is equivalent to the
1527
     user entering the command 'set annotate 2' at the gdb prompt, so
1528
     we need to do extra processing.  */
1529
  if (annotation_level > 1)
1530
    set_async_annotation_level (NULL, 0, NULL);
1531
 
1532
  /* Set the important stuff up for command editing.  */
1533
  command_editing_p = 1;
1534
  history_expansion_p = 0;
1535
  write_history_p = 0;
1536
 
1537
  /* Setup important stuff for command line editing.  */
1538
  rl_completion_entry_function = readline_line_completion_function;
1539
  rl_completer_word_break_characters = default_word_break_characters ();
1540
  rl_completer_quote_characters = get_gdb_completer_quote_characters ();
1541
  rl_readline_name = "gdb";
1542
  rl_terminal_name = getenv ("TERM");
1543
 
1544
  /* The name for this defun comes from Bash, where it originated.
1545
     15 is Control-o, the same binding this function has in Bash.  */
1546
  rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next, 15);
1547
 
1548
  add_setshow_string_cmd ("prompt", class_support,
1549
                          &new_async_prompt, _("\
1550
Set gdb's prompt"), _("\
1551
Show gdb's prompt"), NULL,
1552
                          set_async_prompt,
1553
                          show_new_async_prompt,
1554
                          &setlist, &showlist);
1555
 
1556
  add_com ("dont-repeat", class_support, dont_repeat_command, _("\
1557
Don't repeat this command.\n\
1558
Primarily used inside of user-defined commands that should not be repeated when\n\
1559
hitting return."));
1560
 
1561
  add_setshow_boolean_cmd ("editing", class_support,
1562
                           &async_command_editing_p, _("\
1563
Set editing of command lines as they are typed."), _("\
1564
Show editing of command lines as they are typed."), _("\
1565
Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1566
Without an argument, command line editing is enabled.  To edit, use\n\
1567
EMACS-like or VI-like commands like control-P or ESC."),
1568
                           set_async_editing_command,
1569
                           show_async_command_editing_p,
1570
                           &setlist, &showlist);
1571
 
1572
  add_setshow_boolean_cmd ("save", no_class, &write_history_p, _("\
1573
Set saving of the history record on exit."), _("\
1574
Show saving of the history record on exit."), _("\
1575
Use \"on\" to enable the saving, and \"off\" to disable it.\n\
1576
Without an argument, saving is enabled."),
1577
                           NULL,
1578
                           show_write_history_p,
1579
                           &sethistlist, &showhistlist);
1580
 
1581
  add_setshow_integer_cmd ("size", no_class, &history_size, _("\
1582
Set the size of the command history,"), _("\
1583
Show the size of the command history,"), _("\
1584
ie. the number of previous commands to keep a record of."),
1585
                           set_history_size_command,
1586
                           show_history_size,
1587
                           &sethistlist, &showhistlist);
1588
 
1589
  add_setshow_filename_cmd ("filename", no_class, &history_filename, _("\
1590
Set the filename in which to record the command history"), _("\
1591
Show the filename in which to record the command history"), _("\
1592
(the list of previous commands of which a record is kept)."),
1593
                            NULL,
1594
                            show_history_filename,
1595
                            &sethistlist, &showhistlist);
1596
 
1597
  add_setshow_boolean_cmd ("confirm", class_support, &caution, _("\
1598
Set whether to confirm potentially dangerous operations."), _("\
1599
Show whether to confirm potentially dangerous operations."), NULL,
1600
                           NULL,
1601
                           show_caution,
1602
                           &setlist, &showlist);
1603
 
1604
  add_setshow_zinteger_cmd ("annotate", class_obscure, &annotation_level, _("\
1605
Set annotation_level."), _("\
1606
Show annotation_level."), _("\
1607
 
1608
2 == output annotated suitably for use by programs that control GDB."),
1609
                            set_async_annotation_level,
1610
                            show_annotation_level,
1611
                            &setlist, &showlist);
1612
 
1613
  add_setshow_boolean_cmd ("exec-done-display", class_support,
1614
                           &exec_done_display_p, _("\
1615
Set notification of completion for asynchronous execution commands."), _("\
1616
Show notification of completion for asynchronous execution commands."), _("\
1617
Use \"on\" to enable the notification, and \"off\" to disable it."),
1618
                           NULL,
1619
                           show_exec_done_display_p,
1620
                           &setlist, &showlist);
1621
}
1622
 
1623 131 jeremybenn
/* JPB: Some picky Ubuntu GCC compilers don't like the result of getcwd being
1624
   ignored (even if you cast it to void). So capture the value and ignore
1625
   THAT. */
1626 24 jeremybenn
void
1627
gdb_init (char *argv0)
1628
{
1629 131 jeremybenn
  char *res;                    /* For getcwd result */
1630 24 jeremybenn
  if (pre_init_ui_hook)
1631
    pre_init_ui_hook ();
1632
 
1633
  /* Run the init function of each source file */
1634
 
1635 131 jeremybenn
  res = getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));       /* JPB */
1636 24 jeremybenn
  current_directory = gdb_dirbuf;
1637
 
1638
#ifdef __MSDOS__
1639
  /* Make sure we return to the original directory upon exit, come
1640
     what may, since the OS doesn't do that for us.  */
1641
  make_final_cleanup (do_chdir_cleanup, xstrdup (current_directory));
1642
#endif
1643
 
1644
  init_cmd_lists ();            /* This needs to be done first */
1645
  initialize_targets ();        /* Setup target_terminal macros for utils.c */
1646
  initialize_utils ();          /* Make errors and warnings possible */
1647
  initialize_all_files ();
1648
  initialize_current_architecture ();
1649
  init_cli_cmds();
1650
  init_main ();                 /* But that omits this file!  Do it now */
1651
 
1652
  initialize_stdin_serial ();
1653
 
1654
  async_init_signals ();
1655
 
1656
  /* We need a default language for parsing expressions, so simple things like
1657
     "set width 0" won't fail if no language is explicitly set in a config file
1658
     or implicitly set by reading an executable during startup. */
1659
  set_language (language_c);
1660
  expected_language = current_language;         /* don't warn about the change.  */
1661
 
1662
  /* Allow another UI to initialize. If the UI fails to initialize,
1663
     and it wants GDB to revert to the CLI, it should clear
1664
     deprecated_init_ui_hook.  */
1665
  if (deprecated_init_ui_hook)
1666
    deprecated_init_ui_hook (argv0);
1667
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.