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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [cli/] [cli-cmds.c] - Blame information for rev 227

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* GDB CLI commands.
2
 
3
   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
#include "exceptions.h"
23
#include "arch-utils.h"
24
#include "readline/readline.h"
25
#include "readline/tilde.h"
26
#include "completer.h"
27
#include "target.h"      /* For baud_rate, remote_debug and remote_timeout */
28
#include "gdb_wait.h"           /* For shell escape implementation */
29
#include "gdb_regex.h"          /* Used by apropos_command */
30
#include "gdb_string.h"
31
#include "gdb_vfork.h"
32
#include "linespec.h"
33
#include "expression.h"
34
#include "frame.h"
35
#include "value.h"
36
#include "language.h"
37
#include "filenames.h"          /* for DOSish file names */
38
#include "objfiles.h"
39
#include "source.h"
40
#include "disasm.h"
41
extern void disconnect_or_stop_tracing (int from_tty);
42
 
43
#include "ui-out.h"
44
 
45
#include "top.h"
46
#include "cli/cli-decode.h"
47
#include "cli/cli-script.h"
48
#include "cli/cli-setshow.h"
49
#include "cli/cli-cmds.h"
50
 
51
#include "python/python.h"
52
 
53
#ifdef TUI
54
#include "tui/tui.h"            /* For tui_active et.al.   */
55
#endif
56
 
57
#include <fcntl.h>
58
 
59
/* Prototypes for local command functions */
60
 
61
static void complete_command (char *, int);
62
 
63
static void echo_command (char *, int);
64
 
65
static void pwd_command (char *, int);
66
 
67
static void show_version (char *, int);
68
 
69
static void help_command (char *, int);
70
 
71
static void show_command (char *, int);
72
 
73
static void info_command (char *, int);
74
 
75
static void show_debug (char *, int);
76
 
77
static void set_debug (char *, int);
78
 
79
static void show_user (char *, int);
80
 
81
static void make_command (char *, int);
82
 
83
static void shell_escape (char *, int);
84
 
85
static void edit_command (char *, int);
86
 
87
static void list_command (char *, int);
88
 
89
void apropos_command (char *, int);
90
 
91
/* Prototypes for local utility functions */
92
 
93
static void ambiguous_line_spec (struct symtabs_and_lines *);
94
 
95
/* Limit the call depth of user-defined commands */
96
int max_user_call_depth;
97
 
98
/* Define all cmd_list_elements.  */
99
 
100
/* Chain containing all defined commands.  */
101
 
102
struct cmd_list_element *cmdlist;
103
 
104
/* Chain containing all defined info subcommands.  */
105
 
106
struct cmd_list_element *infolist;
107
 
108
/* Chain containing all defined enable subcommands. */
109
 
110
struct cmd_list_element *enablelist;
111
 
112
/* Chain containing all defined disable subcommands. */
113
 
114
struct cmd_list_element *disablelist;
115
 
116
/* Chain containing all defined toggle subcommands. */
117
 
118
struct cmd_list_element *togglelist;
119
 
120
/* Chain containing all defined stop subcommands. */
121
 
122
struct cmd_list_element *stoplist;
123
 
124
/* Chain containing all defined delete subcommands. */
125
 
126
struct cmd_list_element *deletelist;
127
 
128
/* Chain containing all defined detach subcommands. */
129
 
130
struct cmd_list_element *detachlist;
131
 
132
/* Chain containing all defined kill subcommands. */
133
 
134
struct cmd_list_element *killlist;
135
 
136
/* Chain containing all defined "enable breakpoint" subcommands. */
137
 
138
struct cmd_list_element *enablebreaklist;
139
 
140
/* Chain containing all defined set subcommands */
141
 
142
struct cmd_list_element *setlist;
143
 
144
/* Chain containing all defined unset subcommands */
145
 
146
struct cmd_list_element *unsetlist;
147
 
148
/* Chain containing all defined show subcommands.  */
149
 
150
struct cmd_list_element *showlist;
151
 
152
/* Chain containing all defined \"set history\".  */
153
 
154
struct cmd_list_element *sethistlist;
155
 
156
/* Chain containing all defined \"show history\".  */
157
 
158
struct cmd_list_element *showhistlist;
159
 
160
/* Chain containing all defined \"unset history\".  */
161
 
162
struct cmd_list_element *unsethistlist;
163
 
164
/* Chain containing all defined maintenance subcommands. */
165
 
166
struct cmd_list_element *maintenancelist;
167
 
168
/* Chain containing all defined "maintenance info" subcommands. */
169
 
170
struct cmd_list_element *maintenanceinfolist;
171
 
172
/* Chain containing all defined "maintenance print" subcommands. */
173
 
174
struct cmd_list_element *maintenanceprintlist;
175
 
176
struct cmd_list_element *setprintlist;
177
 
178
struct cmd_list_element *showprintlist;
179
 
180
struct cmd_list_element *setdebuglist;
181
 
182
struct cmd_list_element *showdebuglist;
183
 
184
struct cmd_list_element *setchecklist;
185
 
186
struct cmd_list_element *showchecklist;
187
 
188
/* Command tracing state.  */
189
 
190
int source_verbose = 0;
191
int trace_commands = 0;
192
 
193
/* 'script-extension' option support.  */
194
 
195
static const char script_ext_off[] = "off";
196
static const char script_ext_soft[] = "soft";
197
static const char script_ext_strict[] = "strict";
198
 
199
static const char *script_ext_enums[] = {
200
  script_ext_off,
201
  script_ext_soft,
202
  script_ext_strict,
203
  NULL
204
};
205
 
206
static const char *script_ext_mode = script_ext_soft;
207
 
208
/* Utility used everywhere when at least one argument is needed and
209
   none is supplied. */
210
 
211
void
212
error_no_arg (char *why)
213
{
214
  error (_("Argument required (%s)."), why);
215
}
216
 
217
/* The "info" command is defined as a prefix, with allow_unknown = 0.
218
   Therefore, its own definition is called only for "info" with no args.  */
219
 
220
static void
221
info_command (char *arg, int from_tty)
222
{
223
  printf_unfiltered (_("\"info\" must be followed by the name of an info command.\n"));
224
  help_list (infolist, "info ", -1, gdb_stdout);
225
}
226
 
227
/* The "show" command with no arguments shows all the settings.  */
228
 
229
static void
230
show_command (char *arg, int from_tty)
231
{
232
  cmd_show_list (showlist, from_tty, "");
233
}
234
 
235
/* Provide documentation on command or list given by COMMAND.  FROM_TTY
236
   is ignored.  */
237
 
238
static void
239
help_command (char *command, int from_tty)
240
{
241
  help_cmd (command, gdb_stdout);
242
}
243
 
244
/* String compare function for qsort.  */
245
static int
246
compare_strings (const void *arg1, const void *arg2)
247
{
248
  const char **s1 = (const char **) arg1;
249
  const char **s2 = (const char **) arg2;
250
  return strcmp (*s1, *s2);
251
}
252
 
253
/* The "complete" command is used by Emacs to implement completion.  */
254
 
255
static void
256
complete_command (char *arg, int from_tty)
257
{
258
  int i;
259
  int argpoint;
260
  char **completions, *point, *arg_prefix;
261
 
262
  dont_repeat ();
263
 
264
  if (arg == NULL)
265
    arg = "";
266
  argpoint = strlen (arg);
267
 
268
  /* complete_line assumes that its first argument is somewhere within,
269
     and except for filenames at the beginning of, the word to be completed.
270
     The following crude imitation of readline's word-breaking tries to
271
     accomodate this.  */
272
  point = arg + argpoint;
273
  while (point > arg)
274
    {
275
      if (strchr (rl_completer_word_break_characters, point[-1]) != 0)
276
        break;
277
      point--;
278
    }
279
 
280
  arg_prefix = alloca (point - arg + 1);
281
  memcpy (arg_prefix, arg, point - arg);
282
  arg_prefix[point - arg] = 0;
283
 
284
  completions = complete_line (point, arg, argpoint);
285
 
286
  if (completions)
287
    {
288
      int item, size;
289
 
290
      for (size = 0; completions[size]; ++size)
291
        ;
292
      qsort (completions, size, sizeof (char *), compare_strings);
293
 
294
      /* We do extra processing here since we only want to print each
295
         unique item once.  */
296
      item = 0;
297
      while (item < size)
298
        {
299
          int next_item;
300
          printf_unfiltered ("%s%s\n", arg_prefix, completions[item]);
301
          next_item = item + 1;
302
          while (next_item < size
303
                 && ! strcmp (completions[item], completions[next_item]))
304
            {
305
              xfree (completions[next_item]);
306
              ++next_item;
307
            }
308
 
309
          xfree (completions[item]);
310
          item = next_item;
311
        }
312
 
313
      xfree (completions);
314
    }
315
}
316
 
317
int
318
is_complete_command (struct cmd_list_element *c)
319
{
320
  return cmd_cfunc_eq (c, complete_command);
321
}
322
 
323
static void
324
show_version (char *args, int from_tty)
325
{
326
  immediate_quit++;
327
  print_gdb_version (gdb_stdout);
328
  printf_filtered ("\n");
329
  immediate_quit--;
330
}
331
 
332
/* Handle the quit command.  */
333
 
334
void
335
quit_command (char *args, int from_tty)
336
{
337
  if (!quit_confirm ())
338
    error (_("Not confirmed."));
339
 
340
  disconnect_or_stop_tracing (from_tty);
341
 
342
  quit_force (args, from_tty);
343
}
344
 
345
static void
346
pwd_command (char *args, int from_tty)
347
{
348
  if (args)
349
    error (_("The \"pwd\" command does not take an argument: %s"), args);
350
  if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
351
    error (_("Error finding name of working directory: %s"),
352
           safe_strerror (errno));
353
 
354
  if (strcmp (gdb_dirbuf, current_directory) != 0)
355
    printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
356
                       current_directory, gdb_dirbuf);
357
  else
358
    printf_unfiltered (_("Working directory %s.\n"), current_directory);
359
}
360
 
361
void
362
cd_command (char *dir, int from_tty)
363
{
364
  int len;
365
  /* Found something other than leading repetitions of "/..".  */
366
  int found_real_path;
367
  char *p;
368
 
369
  /* If the new directory is absolute, repeat is a no-op; if relative,
370
     repeat might be useful but is more likely to be a mistake.  */
371
  dont_repeat ();
372
 
373
  if (dir == 0)
374
    error_no_arg (_("new working directory"));
375
 
376
  dir = tilde_expand (dir);
377
  make_cleanup (xfree, dir);
378
 
379
  if (chdir (dir) < 0)
380
    perror_with_name (dir);
381
 
382
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
383
  /* There's too much mess with DOSish names like "d:", "d:.",
384
     "d:./foo" etc.  Instead of having lots of special #ifdef'ed code,
385
     simply get the canonicalized name of the current directory.  */
386
  dir = getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
387
#endif
388
 
389
  len = strlen (dir);
390
  if (IS_DIR_SEPARATOR (dir[len - 1]))
391
    {
392
      /* Remove the trailing slash unless this is a root directory
393
         (including a drive letter on non-Unix systems).  */
394
      if (!(len == 1)           /* "/" */
395
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
396
          && !(len == 3 && dir[1] == ':') /* "d:/" */
397
#endif
398
          )
399
        len--;
400
    }
401
 
402
  dir = savestring (dir, len);
403
  if (IS_ABSOLUTE_PATH (dir))
404
    current_directory = dir;
405
  else
406
    {
407
      if (IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1]))
408
        current_directory = concat (current_directory, dir, (char *)NULL);
409
      else
410
        current_directory = concat (current_directory, SLASH_STRING,
411
                                    dir, (char *)NULL);
412
      xfree (dir);
413
    }
414
 
415
  /* Now simplify any occurrences of `.' and `..' in the pathname.  */
416
 
417
  found_real_path = 0;
418
  for (p = current_directory; *p;)
419
    {
420
      if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.'
421
          && (p[2] == 0 || IS_DIR_SEPARATOR (p[2])))
422
        strcpy (p, p + 2);
423
      else if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.' && p[2] == '.'
424
               && (p[3] == 0 || IS_DIR_SEPARATOR (p[3])))
425
        {
426
          if (found_real_path)
427
            {
428
              /* Search backwards for the directory just before the "/.."
429
                 and obliterate it and the "/..".  */
430
              char *q = p;
431
              while (q != current_directory && !IS_DIR_SEPARATOR (q[-1]))
432
                --q;
433
 
434
              if (q == current_directory)
435
                /* current_directory is
436
                   a relative pathname ("can't happen"--leave it alone).  */
437
                ++p;
438
              else
439
                {
440
                  strcpy (q - 1, p + 3);
441
                  p = q - 1;
442
                }
443
            }
444
          else
445
            /* We are dealing with leading repetitions of "/..", for example
446
               "/../..", which is the Mach super-root.  */
447
            p += 3;
448
        }
449
      else
450
        {
451
          found_real_path = 1;
452
          ++p;
453
        }
454
    }
455
 
456
  forget_cached_source_info ();
457
 
458
  if (from_tty)
459
    pwd_command ((char *) 0, 1);
460
}
461
 
462
/* Show the current value of the 'script-extension' option.  */
463
 
464
static void
465
show_script_ext_mode (struct ui_file *file, int from_tty,
466
                     struct cmd_list_element *c, const char *value)
467
{
468
  fprintf_filtered (file, _("\
469
Script filename extension recognition is \"%s\".\n"),
470
                    value);
471
}
472
 
473
static int
474
find_and_open_script (int from_tty, char **filep, FILE **streamp,
475
                      struct cleanup **cleanupp)
476
{
477
  char *file = *filep;
478
  char *full_pathname = NULL;
479
  int fd;
480
  struct cleanup *old_cleanups;
481
 
482
  file = tilde_expand (file);
483
  old_cleanups = make_cleanup (xfree, file);
484
 
485
  /* Search for and open 'file' on the search path used for source
486
     files.  Put the full location in 'full_pathname'.  */
487
  fd = openp (source_path, OPF_TRY_CWD_FIRST,
488
              file, O_RDONLY, &full_pathname);
489
  make_cleanup (xfree, full_pathname);
490
 
491
  /* Use the full path name, if it is found.  */
492
  if (full_pathname != NULL && fd != -1)
493
    {
494
      file = full_pathname;
495
    }
496
 
497
  if (fd == -1)
498
    {
499
      if (from_tty)
500
        perror_with_name (file);
501
      else
502
        {
503
          do_cleanups (old_cleanups);
504
          return 0;
505
        }
506
    }
507
 
508
  *streamp = fdopen (fd, FOPEN_RT);
509
  *filep = file;
510
  *cleanupp = old_cleanups;
511
 
512
  return 1;
513
}
514
 
515
void
516
source_script (char *file, int from_tty)
517
{
518
  FILE *stream;
519
  struct cleanup *old_cleanups;
520
 
521
  if (file == NULL || *file == 0)
522
    {
523
      error (_("source command requires file name of file to source."));
524
    }
525
 
526
  if (!find_and_open_script (from_tty, &file, &stream, &old_cleanups))
527
    return;
528
 
529
  if (script_ext_mode != script_ext_off
530
      && strlen (file) > 3 && !strcmp (&file[strlen (file) - 3], ".py"))
531
    {
532
      volatile struct gdb_exception e;
533
 
534
      TRY_CATCH (e, RETURN_MASK_ERROR)
535
        {
536
          source_python_script (stream, file);
537
        }
538
      if (e.reason < 0)
539
        {
540
          /* Should we fallback to ye olde GDB script mode?  */
541
          if (script_ext_mode == script_ext_soft
542
              && e.reason == RETURN_ERROR && e.error == UNSUPPORTED_ERROR)
543
            {
544
              if (!find_and_open_script (from_tty, &file, &stream, &old_cleanups))
545
                return;
546
 
547
              script_from_file (stream, file);
548
            }
549
          else
550
            /* Nope, just punt.  */
551
            throw_exception (e);
552
        }
553
    }
554
  else
555
    script_from_file (stream, file);
556
 
557
  do_cleanups (old_cleanups);
558
}
559
 
560
/* Return the source_verbose global variable to its previous state
561
   on exit from the source command, by whatever means.  */
562
static void
563
source_verbose_cleanup (void *old_value)
564
{
565
  source_verbose = *(int *)old_value;
566
  xfree (old_value);
567
}
568
 
569
static void
570
source_command (char *args, int from_tty)
571
{
572
  struct cleanup *old_cleanups;
573
  char *file = args;
574
  int *old_source_verbose = xmalloc (sizeof(int));
575
 
576
  *old_source_verbose = source_verbose;
577
  old_cleanups = make_cleanup (source_verbose_cleanup, old_source_verbose);
578
 
579
  /* -v causes the source command to run in verbose mode.
580
     We still have to be able to handle filenames with spaces in a
581
     backward compatible way, so buildargv is not appropriate.  */
582
 
583
  if (args)
584
    {
585
      /* Make sure leading white space does not break the comparisons.  */
586
      while (isspace(args[0]))
587
        args++;
588
 
589
      /* Is -v the first thing in the string?  */
590
      if (args[0] == '-' && args[1] == 'v' && isspace (args[2]))
591
        {
592
          source_verbose = 1;
593
 
594
          /* Trim -v and whitespace from the filename.  */
595
          file = &args[3];
596
          while (isspace (file[0]))
597
            file++;
598
        }
599
    }
600
 
601
  source_script (file, from_tty);
602
}
603
 
604
 
605
static void
606
echo_command (char *text, int from_tty)
607
{
608
  char *p = text;
609
  int c;
610
 
611
  if (text)
612
    while ((c = *p++) != '\0')
613
      {
614
        if (c == '\\')
615
          {
616
            /* \ at end of argument is used after spaces
617
               so they won't be lost.  */
618
            if (*p == 0)
619
              return;
620
 
621
            c = parse_escape (&p);
622
            if (c >= 0)
623
              printf_filtered ("%c", c);
624
          }
625
        else
626
          printf_filtered ("%c", c);
627
      }
628
 
629
  /* Force this output to appear now.  */
630
  wrap_here ("");
631
  gdb_flush (gdb_stdout);
632
}
633
 
634
static void
635
shell_escape (char *arg, int from_tty)
636
{
637
#if defined(CANT_FORK) || \
638
      (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
639
  /* If ARG is NULL, they want an inferior shell, but `system' just
640
     reports if the shell is available when passed a NULL arg.  */
641
  int rc = system (arg ? arg : "");
642
 
643
  if (!arg)
644
    arg = "inferior shell";
645
 
646
  if (rc == -1)
647
    {
648
      fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", arg,
649
                          safe_strerror (errno));
650
      gdb_flush (gdb_stderr);
651
    }
652
  else if (rc)
653
    {
654
      fprintf_unfiltered (gdb_stderr, "%s exited with status %d\n", arg, rc);
655
      gdb_flush (gdb_stderr);
656
    }
657
#ifdef GLOBAL_CURDIR
658
  /* Make sure to return to the directory GDB thinks it is, in case the
659
     shell command we just ran changed it.  */
660
  chdir (current_directory);
661
#endif
662
#else /* Can fork.  */
663
  int rc, status, pid;
664
 
665
  if ((pid = vfork ()) == 0)
666
    {
667
      char *p, *user_shell;
668
 
669
      if ((user_shell = (char *) getenv ("SHELL")) == NULL)
670
        user_shell = "/bin/sh";
671
 
672
      /* Get the name of the shell for arg0 */
673
      if ((p = strrchr (user_shell, '/')) == NULL)
674
        p = user_shell;
675
      else
676
        p++;                    /* Get past '/' */
677
 
678
      if (!arg)
679
        execl (user_shell, p, (char *) 0);
680
      else
681
        execl (user_shell, p, "-c", arg, (char *) 0);
682
 
683
      fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", user_shell,
684
                          safe_strerror (errno));
685
      gdb_flush (gdb_stderr);
686
      _exit (0177);
687
    }
688
 
689
  if (pid != -1)
690
    while ((rc = wait (&status)) != pid && rc != -1)
691
      ;
692
  else
693
    error (_("Fork failed"));
694
#endif /* Can fork.  */
695
}
696
 
697
static void
698
edit_command (char *arg, int from_tty)
699
{
700
  struct symtabs_and_lines sals;
701
  struct symtab_and_line sal;
702
  struct symbol *sym;
703
  char *arg1;
704
  char *editor;
705
  char *p, *fn;
706
 
707
  /* Pull in the current default source line if necessary.  */
708
  if (arg == 0)
709
    {
710
      set_default_source_symtab_and_line ();
711
      sal = get_current_source_symtab_and_line ();
712
    }
713
 
714
  /* bare "edit" edits file with present line.  */
715
 
716
  if (arg == 0)
717
    {
718
      if (sal.symtab == 0)
719
        error (_("No default source file yet."));
720
      sal.line += get_lines_to_list () / 2;
721
    }
722
  else
723
    {
724
 
725
      /* Now should only be one argument -- decode it in SAL.  */
726
 
727
      arg1 = arg;
728
      sals = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
729
 
730
      if (! sals.nelts)
731
        {
732
          /*  C++  */
733
          return;
734
        }
735
      if (sals.nelts > 1)
736
        {
737
          ambiguous_line_spec (&sals);
738
          xfree (sals.sals);
739
          return;
740
        }
741
 
742
      sal = sals.sals[0];
743
      xfree (sals.sals);
744
 
745
      if (*arg1)
746
        error (_("Junk at end of line specification."));
747
 
748
      /* If line was specified by address,
749
         first print exactly which line, and which file.
750
         In this case, sal.symtab == 0 means address is outside
751
         of all known source files, not that user failed to give a filename.  */
752
      if (*arg == '*')
753
        {
754
          struct gdbarch *gdbarch;
755
          if (sal.symtab == 0)
756
            /* FIXME-32x64--assumes sal.pc fits in long.  */
757
            error (_("No source file for address %s."),
758
                   hex_string ((unsigned long) sal.pc));
759
 
760
          gdbarch = get_objfile_arch (sal.symtab->objfile);
761
          sym = find_pc_function (sal.pc);
762
          if (sym)
763
            printf_filtered ("%s is in %s (%s:%d).\n",
764
                             paddress (gdbarch, sal.pc),
765
                             SYMBOL_PRINT_NAME (sym),
766
                             sal.symtab->filename, sal.line);
767
          else
768
            printf_filtered ("%s is at %s:%d.\n",
769
                             paddress (gdbarch, sal.pc),
770
                             sal.symtab->filename, sal.line);
771
        }
772
 
773
      /* If what was given does not imply a symtab, it must be an undebuggable
774
         symbol which means no source code.  */
775
 
776
      if (sal.symtab == 0)
777
        error (_("No line number known for %s."), arg);
778
    }
779
 
780
  if ((editor = (char *) getenv ("EDITOR")) == NULL)
781
      editor = "/bin/ex";
782
 
783
  /* If we don't already know the full absolute file name of the
784
     source file, find it now.  */
785
  if (!sal.symtab->fullname)
786
    {
787
      fn = symtab_to_fullname (sal.symtab);
788
      if (!fn)
789
        fn = "unknown";
790
    }
791
  else
792
    fn = sal.symtab->fullname;
793
 
794
  /* Quote the file name, in case it has whitespace or other special
795
     characters.  */
796
  p = xstrprintf ("%s +%d \"%s\"", editor, sal.line, fn);
797
  shell_escape (p, from_tty);
798
  xfree (p);
799
}
800
 
801
static void
802
list_command (char *arg, int from_tty)
803
{
804
  struct symtabs_and_lines sals, sals_end;
805
  struct symtab_and_line sal = { 0 };
806
  struct symtab_and_line sal_end = { 0 };
807
  struct symtab_and_line cursal = { 0 };
808
  struct symbol *sym;
809
  char *arg1;
810
  int no_end = 1;
811
  int dummy_end = 0;
812
  int dummy_beg = 0;
813
  int linenum_beg = 0;
814
  char *p;
815
 
816
  /* Pull in the current default source line if necessary */
817
  if (arg == 0 || arg[0] == '+' || arg[0] == '-')
818
    {
819
      set_default_source_symtab_and_line ();
820
      cursal = get_current_source_symtab_and_line ();
821
    }
822
 
823
  /* "l" or "l +" lists next ten lines.  */
824
 
825
  if (arg == 0 || strcmp (arg, "+") == 0)
826
    {
827
      print_source_lines (cursal.symtab, cursal.line,
828
                          cursal.line + get_lines_to_list (), 0);
829
      return;
830
    }
831
 
832
  /* "l -" lists previous ten lines, the ones before the ten just listed.  */
833
  if (strcmp (arg, "-") == 0)
834
    {
835
      print_source_lines (cursal.symtab,
836
                          max (get_first_line_listed () - get_lines_to_list (), 1),
837
                          get_first_line_listed (), 0);
838
      return;
839
    }
840
 
841
  /* Now if there is only one argument, decode it in SAL
842
     and set NO_END.
843
     If there are two arguments, decode them in SAL and SAL_END
844
     and clear NO_END; however, if one of the arguments is blank,
845
     set DUMMY_BEG or DUMMY_END to record that fact.  */
846
 
847
  if (!have_full_symbols () && !have_partial_symbols ())
848
    error (_("No symbol table is loaded.  Use the \"file\" command."));
849
 
850
  arg1 = arg;
851
  if (*arg1 == ',')
852
    dummy_beg = 1;
853
  else
854
    {
855
      sals = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
856
 
857
      if (!sals.nelts)
858
        return;                 /*  C++  */
859
      if (sals.nelts > 1)
860
        {
861
          ambiguous_line_spec (&sals);
862
          xfree (sals.sals);
863
          return;
864
        }
865
 
866
      sal = sals.sals[0];
867
      xfree (sals.sals);
868
    }
869
 
870
  /* Record whether the BEG arg is all digits.  */
871
 
872
  for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++);
873
  linenum_beg = (p == arg1);
874
 
875
  while (*arg1 == ' ' || *arg1 == '\t')
876
    arg1++;
877
  if (*arg1 == ',')
878
    {
879
      no_end = 0;
880
      arg1++;
881
      while (*arg1 == ' ' || *arg1 == '\t')
882
        arg1++;
883
      if (*arg1 == 0)
884
        dummy_end = 1;
885
      else
886
        {
887
          if (dummy_beg)
888
            sals_end = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
889
          else
890
            sals_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line, 0, 0);
891
          if (sals_end.nelts == 0)
892
            return;
893
          if (sals_end.nelts > 1)
894
            {
895
              ambiguous_line_spec (&sals_end);
896
              xfree (sals_end.sals);
897
              return;
898
            }
899
          sal_end = sals_end.sals[0];
900
          xfree (sals_end.sals);
901
        }
902
    }
903
 
904
  if (*arg1)
905
    error (_("Junk at end of line specification."));
906
 
907
  if (!no_end && !dummy_beg && !dummy_end
908
      && sal.symtab != sal_end.symtab)
909
    error (_("Specified start and end are in different files."));
910
  if (dummy_beg && dummy_end)
911
    error (_("Two empty args do not say what lines to list."));
912
 
913
  /* if line was specified by address,
914
     first print exactly which line, and which file.
915
     In this case, sal.symtab == 0 means address is outside
916
     of all known source files, not that user failed to give a filename.  */
917
  if (*arg == '*')
918
    {
919
      struct gdbarch *gdbarch;
920
      if (sal.symtab == 0)
921
        /* FIXME-32x64--assumes sal.pc fits in long.  */
922
        error (_("No source file for address %s."),
923
               hex_string ((unsigned long) sal.pc));
924
 
925
      gdbarch = get_objfile_arch (sal.symtab->objfile);
926
      sym = find_pc_function (sal.pc);
927
      if (sym)
928
        printf_filtered ("%s is in %s (%s:%d).\n",
929
                         paddress (gdbarch, sal.pc),
930
                         SYMBOL_PRINT_NAME (sym),
931
                         sal.symtab->filename, sal.line);
932
      else
933
        printf_filtered ("%s is at %s:%d.\n",
934
                         paddress (gdbarch, sal.pc),
935
                         sal.symtab->filename, sal.line);
936
    }
937
 
938
  /* If line was not specified by just a line number,
939
     and it does not imply a symtab, it must be an undebuggable symbol
940
     which means no source code.  */
941
 
942
  if (!linenum_beg && sal.symtab == 0)
943
    error (_("No line number known for %s."), arg);
944
 
945
  /* If this command is repeated with RET,
946
     turn it into the no-arg variant.  */
947
 
948
  if (from_tty)
949
    *arg = 0;
950
 
951
  if (dummy_beg && sal_end.symtab == 0)
952
    error (_("No default source file yet.  Do \"help list\"."));
953
  if (dummy_beg)
954
    print_source_lines (sal_end.symtab,
955
                        max (sal_end.line - (get_lines_to_list () - 1), 1),
956
                        sal_end.line + 1, 0);
957
  else if (sal.symtab == 0)
958
    error (_("No default source file yet.  Do \"help list\"."));
959
  else if (no_end)
960
    {
961
      int first_line = sal.line - get_lines_to_list () / 2;
962
 
963
      if (first_line < 1) first_line = 1;
964
 
965
      print_source_lines (sal.symtab,
966
                          first_line,
967
                          first_line + get_lines_to_list (),
968
                          0);
969
    }
970
  else
971
    print_source_lines (sal.symtab, sal.line,
972
                        (dummy_end
973
                         ? sal.line + get_lines_to_list ()
974
                         : sal_end.line + 1),
975
                        0);
976
}
977
 
978
/* Subroutine of disassemble_command to simplify it.
979
   Perform the disassembly.
980
   NAME is the name of the function if known, or NULL.
981
   [LOW,HIGH) are the range of addresses to disassemble.
982
   MIXED is non-zero to print source with the assembler.  */
983
 
984
static void
985
print_disassembly (struct gdbarch *gdbarch, const char *name,
986
                   CORE_ADDR low, CORE_ADDR high, int flags)
987
{
988
#if defined(TUI)
989
  if (!tui_is_window_visible (DISASSEM_WIN))
990
#endif
991
    {
992
      printf_filtered ("Dump of assembler code ");
993
      if (name != NULL)
994
        printf_filtered ("for function %s:\n", name);
995
      else
996
        printf_filtered ("from %s to %s:\n",
997
                         paddress (gdbarch, low), paddress (gdbarch, high));
998
 
999
      /* Dump the specified range.  */
1000
      gdb_disassembly (gdbarch, uiout, 0, flags, -1, low, high);
1001
 
1002
      printf_filtered ("End of assembler dump.\n");
1003
      gdb_flush (gdb_stdout);
1004
    }
1005
#if defined(TUI)
1006
  else
1007
    {
1008
      tui_show_assembly (gdbarch, low);
1009
    }
1010
#endif
1011
}
1012
 
1013
/* Subroutine of disassemble_command to simplify it.
1014
   Print a disassembly of the current function according to FLAGS.  */
1015
 
1016
static void
1017
disassemble_current_function (int flags)
1018
{
1019
  struct frame_info *frame;
1020
  struct gdbarch *gdbarch;
1021
  CORE_ADDR low, high, pc;
1022
  char *name;
1023
 
1024
  frame = get_selected_frame (_("No frame selected."));
1025
  gdbarch = get_frame_arch (frame);
1026
  pc = get_frame_pc (frame);
1027
  if (find_pc_partial_function (pc, &name, &low, &high) == 0)
1028
    error (_("No function contains program counter for selected frame."));
1029
#if defined(TUI)
1030
  /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1031
     `tui_version'.  */
1032
  if (tui_active)
1033
    /* FIXME: cagney/2004-02-07: This should be an observer.  */
1034
    low = tui_get_low_disassembly_address (gdbarch, low, pc);
1035
#endif
1036
  low += gdbarch_deprecated_function_start_offset (gdbarch);
1037
 
1038
  print_disassembly (gdbarch, name, low, high, flags);
1039
}
1040
 
1041
/* Dump a specified section of assembly code.
1042
 
1043
   Usage:
1044
     disassemble [/mr]
1045
       - dump the assembly code for the function of the current pc
1046
     disassemble [/mr] addr
1047
       - dump the assembly code for the function at ADDR
1048
     disassemble [/mr] low high
1049
       - dump the assembly code in the range [LOW,HIGH)
1050
 
1051
   A /m modifier will include source code with the assembly.
1052
   A /r modifier will include raw instructions in hex with the assembly.  */
1053
 
1054
static void
1055
disassemble_command (char *arg, int from_tty)
1056
{
1057
  struct gdbarch *gdbarch = get_current_arch ();
1058
  CORE_ADDR low, high;
1059
  char *name;
1060
  CORE_ADDR pc, pc_masked;
1061
  int flags;
1062
 
1063
  name = NULL;
1064
  flags = 0;
1065
 
1066
  if (arg && *arg == '/')
1067
    {
1068
      ++arg;
1069
 
1070
      if (*arg == '\0')
1071
        error (_("Missing modifier."));
1072
 
1073
      while (*arg && ! isspace (*arg))
1074
        {
1075
          switch (*arg++)
1076
            {
1077
            case 'm':
1078
              flags |= DISASSEMBLY_SOURCE;
1079
              break;
1080
            case 'r':
1081
              flags |= DISASSEMBLY_RAW_INSN;
1082
              break;
1083
            default:
1084
              error (_("Invalid disassembly modifier."));
1085
            }
1086
        }
1087
 
1088
      while (isspace (*arg))
1089
        ++arg;
1090
    }
1091
 
1092
  if (! arg || ! *arg)
1093
    {
1094
      flags |= DISASSEMBLY_OMIT_FNAME;
1095
      disassemble_current_function (flags);
1096
      return;
1097
    }
1098
 
1099
  pc = value_as_address (parse_to_comma_and_eval (&arg));
1100
  if (arg[0] == ',')
1101
    ++arg;
1102
  if (arg[0] == '\0')
1103
    {
1104
      /* One argument.  */
1105
      if (find_pc_partial_function (pc, &name, &low, &high) == 0)
1106
        error (_("No function contains specified address."));
1107
#if defined(TUI)
1108
      /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1109
         `tui_version'.  */
1110
      if (tui_active)
1111
        /* FIXME: cagney/2004-02-07: This should be an observer.  */
1112
        low = tui_get_low_disassembly_address (gdbarch, low, pc);
1113
#endif
1114
      low += gdbarch_deprecated_function_start_offset (gdbarch);
1115
      flags |= DISASSEMBLY_OMIT_FNAME;
1116
    }
1117
  else
1118
    {
1119
      /* Two arguments.  */
1120
      low = pc;
1121
      high = parse_and_eval_address (arg);
1122
    }
1123
 
1124
  print_disassembly (gdbarch, name, low, high, flags);
1125
}
1126
 
1127
static void
1128
make_command (char *arg, int from_tty)
1129
{
1130
  char *p;
1131
 
1132
  if (arg == 0)
1133
    p = "make";
1134
  else
1135
    {
1136
      p = xmalloc (sizeof ("make ") + strlen (arg));
1137
      strcpy (p, "make ");
1138
      strcpy (p + sizeof ("make ") - 1, arg);
1139
    }
1140
 
1141
  shell_escape (p, from_tty);
1142
}
1143
 
1144
static void
1145
show_user (char *args, int from_tty)
1146
{
1147
  struct cmd_list_element *c;
1148
  extern struct cmd_list_element *cmdlist;
1149
 
1150
  if (args)
1151
    {
1152
      char *comname = args;
1153
      c = lookup_cmd (&comname, cmdlist, "", 0, 1);
1154
      if (c->class != class_user)
1155
        error (_("Not a user command."));
1156
      show_user_1 (c, "", args, gdb_stdout);
1157
    }
1158
  else
1159
    {
1160
      for (c = cmdlist; c; c = c->next)
1161
        {
1162
          if (c->class == class_user || c->prefixlist != NULL)
1163
            show_user_1 (c, "", c->name, gdb_stdout);
1164
        }
1165
    }
1166
}
1167
 
1168
/* Search through names of commands and documentations for a certain
1169
   regular expression.
1170
*/
1171
void
1172
apropos_command (char *searchstr, int from_tty)
1173
{
1174
  extern struct cmd_list_element *cmdlist; /*This is the main command list*/
1175
  regex_t pattern;
1176
  char *pattern_fastmap;
1177
  char errorbuffer[512];
1178
  pattern_fastmap = xcalloc (256, sizeof (char));
1179
  if (searchstr == NULL)
1180
      error (_("REGEXP string is empty"));
1181
 
1182
  if (regcomp(&pattern,searchstr,REG_ICASE) == 0)
1183
    {
1184
      pattern.fastmap=pattern_fastmap;
1185
      re_compile_fastmap(&pattern);
1186
      apropos_cmd (gdb_stdout,cmdlist,&pattern,"");
1187
    }
1188
  else
1189
    {
1190
      regerror(regcomp(&pattern,searchstr,REG_ICASE),NULL,errorbuffer,512);
1191
      error (_("Error in regular expression:%s"),errorbuffer);
1192
    }
1193
  xfree (pattern_fastmap);
1194
}
1195
 
1196
/* Print a list of files and line numbers which a user may choose from
1197
   in order to list a function which was specified ambiguously (as with
1198
   `list classname::overloadedfuncname', for example).  The vector in
1199
   SALS provides the filenames and line numbers.  */
1200
 
1201
static void
1202
ambiguous_line_spec (struct symtabs_and_lines *sals)
1203
{
1204
  int i;
1205
 
1206
  for (i = 0; i < sals->nelts; ++i)
1207
    printf_filtered (_("file: \"%s\", line number: %d\n"),
1208
                     sals->sals[i].symtab->filename, sals->sals[i].line);
1209
}
1210
 
1211
static void
1212
set_debug (char *arg, int from_tty)
1213
{
1214
  printf_unfiltered (_("\"set debug\" must be followed by the name of a debug subcommand.\n"));
1215
  help_list (setdebuglist, "set debug ", -1, gdb_stdout);
1216
}
1217
 
1218
static void
1219
show_debug (char *args, int from_tty)
1220
{
1221
  cmd_show_list (showdebuglist, from_tty, "");
1222
}
1223
 
1224
void
1225
init_cmd_lists (void)
1226
{
1227
  max_user_call_depth = 1024;
1228
 
1229
  cmdlist = NULL;
1230
  infolist = NULL;
1231
  enablelist = NULL;
1232
  disablelist = NULL;
1233
  togglelist = NULL;
1234
  stoplist = NULL;
1235
  deletelist = NULL;
1236
  detachlist = NULL;
1237
  enablebreaklist = NULL;
1238
  setlist = NULL;
1239
  unsetlist = NULL;
1240
  showlist = NULL;
1241
  sethistlist = NULL;
1242
  showhistlist = NULL;
1243
  unsethistlist = NULL;
1244
  maintenancelist = NULL;
1245
  maintenanceinfolist = NULL;
1246
  maintenanceprintlist = NULL;
1247
  setprintlist = NULL;
1248
  showprintlist = NULL;
1249
  setchecklist = NULL;
1250
  showchecklist = NULL;
1251
}
1252
 
1253
static void
1254
show_info_verbose (struct ui_file *file, int from_tty,
1255
                   struct cmd_list_element *c,
1256
                   const char *value)
1257
{
1258
  if (info_verbose)
1259
    fprintf_filtered (file, _("\
1260
Verbose printing of informational messages is %s.\n"), value);
1261
  else
1262
    fprintf_filtered (file, _("Verbosity is %s.\n"), value);
1263
}
1264
 
1265
static void
1266
show_history_expansion_p (struct ui_file *file, int from_tty,
1267
                          struct cmd_list_element *c, const char *value)
1268
{
1269
  fprintf_filtered (file, _("History expansion on command input is %s.\n"),
1270
                    value);
1271
}
1272
 
1273
static void
1274
show_baud_rate (struct ui_file *file, int from_tty,
1275
                struct cmd_list_element *c, const char *value)
1276
{
1277
  fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"),
1278
                    value);
1279
}
1280
 
1281
static void
1282
show_remote_debug (struct ui_file *file, int from_tty,
1283
                   struct cmd_list_element *c, const char *value)
1284
{
1285
  fprintf_filtered (file, _("Debugging of remote protocol is %s.\n"),
1286
                    value);
1287
}
1288
 
1289
static void
1290
show_remote_timeout (struct ui_file *file, int from_tty,
1291
                     struct cmd_list_element *c, const char *value)
1292
{
1293
  fprintf_filtered (file, _("\
1294
Timeout limit to wait for target to respond is %s.\n"),
1295
                    value);
1296
}
1297
 
1298
static void
1299
show_max_user_call_depth (struct ui_file *file, int from_tty,
1300
                          struct cmd_list_element *c, const char *value)
1301
{
1302
  fprintf_filtered (file, _("\
1303
The max call depth for user-defined commands is %s.\n"),
1304
                    value);
1305
}
1306
 
1307
 
1308
void
1309
init_cli_cmds (void)
1310
{
1311
  struct cmd_list_element *c;
1312
  char *source_help_text;
1313
 
1314
  /* Define the classes of commands.
1315
     They will appear in the help list in the reverse of this order.  */
1316
 
1317
  add_cmd ("internals", class_maintenance, NULL, _("\
1318
Maintenance commands.\n\
1319
Some gdb commands are provided just for use by gdb maintainers.\n\
1320
These commands are subject to frequent change, and may not be as\n\
1321
well documented as user commands."),
1322
           &cmdlist);
1323
  add_cmd ("obscure", class_obscure, NULL, _("Obscure features."), &cmdlist);
1324
  add_cmd ("aliases", class_alias, NULL, _("Aliases of other commands."), &cmdlist);
1325
  add_cmd ("user-defined", class_user, NULL, _("\
1326
User-defined commands.\n\
1327
The commands in this class are those defined by the user.\n\
1328
Use the \"define\" command to define a command."), &cmdlist);
1329
  add_cmd ("support", class_support, NULL, _("Support facilities."), &cmdlist);
1330
  if (!dbx_commands)
1331
    add_cmd ("status", class_info, NULL, _("Status inquiries."), &cmdlist);
1332
  add_cmd ("files", class_files, NULL, _("Specifying and examining files."),
1333
           &cmdlist);
1334
  add_cmd ("breakpoints", class_breakpoint, NULL,
1335
           _("Making program stop at certain points."), &cmdlist);
1336
  add_cmd ("data", class_vars, NULL, _("Examining data."), &cmdlist);
1337
  add_cmd ("stack", class_stack, NULL, _("\
1338
Examining the stack.\n\
1339
The stack is made up of stack frames.  Gdb assigns numbers to stack frames\n\
1340
counting from zero for the innermost (currently executing) frame.\n\n\
1341
At any time gdb identifies one frame as the \"selected\" frame.\n\
1342
Variable lookups are done with respect to the selected frame.\n\
1343
When the program being debugged stops, gdb selects the innermost frame.\n\
1344
The commands below can be used to select other frames by number or address."),
1345
           &cmdlist);
1346
  add_cmd ("running", class_run, NULL, _("Running the program."), &cmdlist);
1347
 
1348
  /* Define general commands. */
1349
 
1350
  add_com ("pwd", class_files, pwd_command, _("\
1351
Print working directory.  This is used for your program as well."));
1352
 
1353
  c = add_cmd ("cd", class_files, cd_command, _("\
1354
Set working directory to DIR for debugger and program being debugged.\n\
1355
The change does not take effect for the program being debugged\n\
1356
until the next time it is started."), &cmdlist);
1357
  set_cmd_completer (c, filename_completer);
1358
 
1359
  add_com ("echo", class_support, echo_command, _("\
1360
Print a constant string.  Give string as argument.\n\
1361
C escape sequences may be used in the argument.\n\
1362
No newline is added at the end of the argument;\n\
1363
use \"\\n\" if you want a newline to be printed.\n\
1364
Since leading and trailing whitespace are ignored in command arguments,\n\
1365
if you want to print some you must use \"\\\" before leading whitespace\n\
1366
to be printed or after trailing whitespace."));
1367
  add_com ("document", class_support, document_command, _("\
1368
Document a user-defined command.\n\
1369
Give command name as argument.  Give documentation on following lines.\n\
1370
End with a line of just \"end\"."));
1371
  add_com ("define", class_support, define_command, _("\
1372
Define a new command name.  Command name is argument.\n\
1373
Definition appears on following lines, one command per line.\n\
1374
End with a line of just \"end\".\n\
1375
Use the \"document\" command to give documentation for the new command.\n\
1376
Commands defined in this way may have up to ten arguments."));
1377
 
1378
  source_help_text = xstrprintf (_("\
1379
Read commands from a file named FILE.\n\
1380
Optional -v switch (before the filename) causes each command in\n\
1381
FILE to be echoed as it is executed.\n\
1382
Note that the file \"%s\" is read automatically in this way\n\
1383
when GDB is started."), gdbinit);
1384
  c = add_cmd ("source", class_support, source_command,
1385
               source_help_text, &cmdlist);
1386
  set_cmd_completer (c, filename_completer);
1387
 
1388
  add_setshow_enum_cmd ("script-extension", class_support,
1389
                        script_ext_enums, &script_ext_mode, _("\
1390
Set mode for script filename extension recognition."), _("\
1391
Show mode for script filename extension recognition."), _("\
1392
off  == no filename extension recognition (all sourced files are GDB scripts)\n\
1393
soft == evaluate script according to filename extension, fallback to GDB script"
1394
  "\n\
1395
strict == evaluate script according to filename extension, error if not supported"
1396
  ),
1397
                        NULL,
1398
                        show_script_ext_mode,
1399
                        &setlist, &showlist);
1400
 
1401
  add_com ("quit", class_support, quit_command, _("Exit gdb."));
1402
  c = add_com ("help", class_support, help_command,
1403
               _("Print list of commands."));
1404
  set_cmd_completer (c, command_completer);
1405
  add_com_alias ("q", "quit", class_support, 1);
1406
  add_com_alias ("h", "help", class_support, 1);
1407
 
1408
  add_setshow_boolean_cmd ("verbose", class_support, &info_verbose, _("\
1409
Set verbosity."), _("\
1410
Show verbosity."), NULL,
1411
                           set_verbose,
1412
                           show_info_verbose,
1413
                           &setlist, &showlist);
1414
 
1415
  add_prefix_cmd ("history", class_support, set_history,
1416
                  _("Generic command for setting command history parameters."),
1417
                  &sethistlist, "set history ", 0, &setlist);
1418
  add_prefix_cmd ("history", class_support, show_history,
1419
                  _("Generic command for showing command history parameters."),
1420
                  &showhistlist, "show history ", 0, &showlist);
1421
 
1422
  add_setshow_boolean_cmd ("expansion", no_class, &history_expansion_p, _("\
1423
Set history expansion on command input."), _("\
1424
Show history expansion on command input."), _("\
1425
Without an argument, history expansion is enabled."),
1426
                           NULL,
1427
                           show_history_expansion_p,
1428
                           &sethistlist, &showhistlist);
1429
 
1430
  add_prefix_cmd ("info", class_info, info_command, _("\
1431
Generic command for showing things about the program being debugged."),
1432
                  &infolist, "info ", 0, &cmdlist);
1433
  add_com_alias ("i", "info", class_info, 1);
1434
  add_com_alias ("inf", "info", class_info, 1);
1435
 
1436
  add_com ("complete", class_obscure, complete_command,
1437
           _("List the completions for the rest of the line as a command."));
1438
 
1439
  add_prefix_cmd ("show", class_info, show_command, _("\
1440
Generic command for showing things about the debugger."),
1441
                  &showlist, "show ", 0, &cmdlist);
1442
  /* Another way to get at the same thing.  */
1443
  add_info ("set", show_command, _("Show all GDB settings."));
1444
 
1445
  add_cmd ("commands", no_class, show_commands, _("\
1446
Show the history of commands you typed.\n\
1447
You can supply a command number to start with, or a `+' to start after\n\
1448
the previous command number shown."),
1449
           &showlist);
1450
 
1451
  add_cmd ("version", no_class, show_version,
1452
           _("Show what version of GDB this is."), &showlist);
1453
 
1454
  add_com ("while", class_support, while_command, _("\
1455
Execute nested commands WHILE the conditional expression is non zero.\n\
1456
The conditional expression must follow the word `while' and must in turn be\n\
1457
followed by a new line.  The nested commands must be entered one per line,\n\
1458
and should be terminated by the word `end'."));
1459
 
1460
  add_com ("if", class_support, if_command, _("\
1461
Execute nested commands once IF the conditional expression is non zero.\n\
1462
The conditional expression must follow the word `if' and must in turn be\n\
1463
followed by a new line.  The nested commands must be entered one per line,\n\
1464
and should be terminated by the word 'else' or `end'.  If an else clause\n\
1465
is used, the same rules apply to its nested commands as to the first ones."));
1466
 
1467
  /* If target is open when baud changes, it doesn't take effect until the
1468
     next open (I think, not sure).  */
1469
  add_setshow_zinteger_cmd ("remotebaud", no_class, &baud_rate, _("\
1470
Set baud rate for remote serial I/O."), _("\
1471
Show baud rate for remote serial I/O."), _("\
1472
This value is used to set the speed of the serial port when debugging\n\
1473
using remote targets."),
1474
                            NULL,
1475
                            show_baud_rate,
1476
                            &setlist, &showlist);
1477
 
1478
  add_setshow_zinteger_cmd ("remote", no_class, &remote_debug, _("\
1479
Set debugging of remote protocol."), _("\
1480
Show debugging of remote protocol."), _("\
1481
When enabled, each packet sent or received with the remote target\n\
1482
is displayed."),
1483
                            NULL,
1484
                            show_remote_debug,
1485
                            &setdebuglist, &showdebuglist);
1486
 
1487
  add_setshow_integer_cmd ("remotetimeout", no_class, &remote_timeout, _("\
1488
Set timeout limit to wait for target to respond."), _("\
1489
Show timeout limit to wait for target to respond."), _("\
1490
This value is used to set the time limit for gdb to wait for a response\n\
1491
from the target."),
1492
                           NULL,
1493
                           show_remote_timeout,
1494
                           &setlist, &showlist);
1495
 
1496
  add_prefix_cmd ("debug", no_class, set_debug,
1497
                  _("Generic command for setting gdb debugging flags"),
1498
                  &setdebuglist, "set debug ", 0, &setlist);
1499
 
1500
  add_prefix_cmd ("debug", no_class, show_debug,
1501
                  _("Generic command for showing gdb debugging flags"),
1502
                  &showdebuglist, "show debug ", 0, &showlist);
1503
 
1504
  c = add_com ("shell", class_support, shell_escape, _("\
1505
Execute the rest of the line as a shell command.\n\
1506
With no arguments, run an inferior shell."));
1507
  set_cmd_completer (c, filename_completer);
1508
 
1509
  c = add_com ("edit", class_files, edit_command, _("\
1510
Edit specified file or function.\n\
1511
With no argument, edits file containing most recent line listed.\n\
1512
Editing targets can be specified in these ways:\n\
1513
  FILE:LINENUM, to edit at that line in that file,\n\
1514
  FUNCTION, to edit at the beginning of that function,\n\
1515
  FILE:FUNCTION, to distinguish among like-named static functions.\n\
1516
  *ADDRESS, to edit at the line containing that address.\n\
1517
Uses EDITOR environment variable contents as editor (or ex as default)."));
1518
 
1519
  c->completer = location_completer;
1520
 
1521
  add_com ("list", class_files, list_command, _("\
1522
List specified function or line.\n\
1523
With no argument, lists ten more lines after or around previous listing.\n\
1524
\"list -\" lists the ten lines before a previous ten-line listing.\n\
1525
One argument specifies a line, and ten lines are listed around that line.\n\
1526
Two arguments with comma between specify starting and ending lines to list.\n\
1527
Lines can be specified in these ways:\n\
1528
  LINENUM, to list around that line in current file,\n\
1529
  FILE:LINENUM, to list around that line in that file,\n\
1530
  FUNCTION, to list around beginning of that function,\n\
1531
  FILE:FUNCTION, to distinguish among like-named static functions.\n\
1532
  *ADDRESS, to list around the line containing that address.\n\
1533
With two args if one is empty it stands for ten lines away from the other arg."));
1534
 
1535
  if (!xdb_commands)
1536
    add_com_alias ("l", "list", class_files, 1);
1537
  else
1538
    add_com_alias ("v", "list", class_files, 1);
1539
 
1540
  if (dbx_commands)
1541
    add_com_alias ("file", "list", class_files, 1);
1542
 
1543
  c = add_com ("disassemble", class_vars, disassemble_command, _("\
1544
Disassemble a specified section of memory.\n\
1545
Default is the function surrounding the pc of the selected frame.\n\
1546
With a /m modifier, source lines are included (if available).\n\
1547
With a /r modifier, raw instructions in hex are included.\n\
1548
With a single argument, the function surrounding that address is dumped.\n\
1549
Two arguments (separated by a comma) are taken as a range of memory to dump."));
1550
  set_cmd_completer (c, location_completer);
1551
  if (xdb_commands)
1552
    add_com_alias ("va", "disassemble", class_xdb, 0);
1553
 
1554
  /* NOTE: cagney/2000-03-20: Being able to enter ``(gdb) !ls'' would
1555
     be a really useful feature.  Unfortunately, the below wont do
1556
     this.  Instead it adds support for the form ``(gdb) ! ls''
1557
     (i.e. the space is required).  If the ``!'' command below is
1558
     added the complains about no ``!'' command would be replaced by
1559
     complains about how the ``!'' command is broken :-) */
1560
  if (xdb_commands)
1561
    add_com_alias ("!", "shell", class_support, 0);
1562
 
1563
  c = add_com ("make", class_support, make_command, _("\
1564
Run the ``make'' program using the rest of the line as arguments."));
1565
  set_cmd_completer (c, filename_completer);
1566
  add_cmd ("user", no_class, show_user, _("\
1567
Show definitions of user defined commands.\n\
1568
Argument is the name of the user defined command.\n\
1569
With no argument, show definitions of all user defined commands."), &showlist);
1570
  add_com ("apropos", class_support, apropos_command,
1571
           _("Search for commands matching a REGEXP"));
1572
 
1573
  add_setshow_integer_cmd ("max-user-call-depth", no_class,
1574
                           &max_user_call_depth, _("\
1575
Set the max call depth for user-defined commands."), _("\
1576
Show the max call depth for user-defined commands."), NULL,
1577
                           NULL,
1578
                           show_max_user_call_depth,
1579
                           &setlist, &showlist);
1580
 
1581
  add_setshow_boolean_cmd ("trace-commands", no_class, &trace_commands, _("\
1582
Set tracing of GDB CLI commands."), _("\
1583
Show state of GDB CLI command tracing."), _("\
1584
When 'on', each command is displayed as it is executed."),
1585
                           NULL,
1586
                           NULL,
1587
                           &setlist, &showlist);
1588
}

powered by: WebSVN 2.1.0

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