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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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