gdb/command.h

   1 /* Header file for command-reading library command.c.
   2    Copyright (C) 1986, 1989, 1990, 2000 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 59 Temple Place - Suite 330,
  17    Boston, MA 02111-1307, USA.  */
  18
  19 #if !defined (COMMAND_H)
  20 #define COMMAND_H 1
  21
  22 /* Command classes are top-level categories into which commands are broken
  23    down for "help" purposes.
  24    Notes on classes: class_alias is for alias commands which are not
  25    abbreviations of the original command.  class-pseudo is for
  26    commands which are not really commands nor help topics ("stop").  */
  27
  28 enum command_class
  29 {
  30   /* Special args to help_list */
  31   class_deprecated, all_classes = -2, all_commands = -1,
  32   /* Classes of commands */
  33   no_class = -1, class_run = 0, class_vars, class_stack,
  34   class_files, class_support, class_info, class_breakpoint, class_trace,
  35   class_alias, class_obscure, class_user, class_maintenance,
  36   class_pseudo, class_tui, class_xdb
  37 };
  38
  39 /* Not a set/show command.  Note that some commands which begin with
  40    "set" or "show" might be in this category, if their syntax does
  41    not fall into one of the following categories.  */
  42 typedef enum cmd_types
  43   {
  44     not_set_cmd,
  45     set_cmd,
  46     show_cmd
  47   }
  48 cmd_types;
  49
  50 /* Types of "set" or "show" command.  */
  51 typedef enum var_types
  52   {
  53     /* "on" or "off".  *VAR is an integer which is nonzero for on,
  54        zero for off.  */
  55     var_boolean,
  56     /* Unsigned Integer.  *VAR is an unsigned int.  The user can type 0
  57        to mean "unlimited", which is stored in *VAR as UINT_MAX.  */
  58     var_uinteger,
  59
  60     /* Like var_uinteger but signed.  *VAR is an int.  The user can type 0
  61        to mean "unlimited", which is stored in *VAR as INT_MAX.  */
  62     var_integer,
  63
  64     /* String which the user enters with escapes (e.g. the user types \n and
  65        it is a real newline in the stored string).
  66        *VAR is a malloc'd string, or NULL if the string is empty.  */
  67     var_string,
  68     /* String which stores what the user types verbatim.
  69        *VAR is a malloc'd string, or NULL if the string is empty.  */
  70     var_string_noescape,
  71     /* String which stores a filename.
  72        *VAR is a malloc'd string, or NULL if the string is empty.  */
  73     var_filename,
  74     /* ZeroableInteger.  *VAR is an int.  Like Unsigned Integer except
  75        that zero really means zero.  */
  76     var_zinteger,
  77     /* Enumerated type.  Can only have one of the specified values.  *VAR is a
  78        char pointer to the name of the element that we find.  */
  79     var_enum
  80   }
  81 var_types;
  82
  83 /* This structure records one command'd definition.  */
  84
  85
  86 /* This flag is used by the code executing commands to warn the user
  87    the first time a deprecated command is used, see the 'flags' field in
  88    the following struct.
  89 */
  90 #define CMD_DEPRECATED            0x1
  91 #define DEPRECATED_WARN_USER      0x2
  92 #define MALLOCED_REPLACEMENT      0x4
  93
  94 struct cmd_list_element
  95   {
  96     /* Points to next command in this list.  */
  97     struct cmd_list_element *next;
  98
  99     /* Name of this command.  */
 100     char *name;
 101
 102     /* Command class; class values are chosen by application program.  */
 103     enum command_class class;
 104
 105     /* Function definition of this command.
 106        NO_FUNCTION for command class names and for help topics that
 107        are not really commands.  */
 108     union
 109       {
 110         /* If type is not_set_cmd, call it like this:  */
 111         void (*cfunc) PARAMS ((char *args, int from_tty));
 112
 113         /* If type is cmd_set or show_cmd, first set the variables, and
 114            then call this.  */
 115         void (*sfunc) PARAMS ((char *args, int from_tty,
 116                                struct cmd_list_element * c));
 117       }
 118     function;
 119 #define NO_FUNCTION ((void (*) PARAMS((char *args, int from_tty))) 0)
 120
 121     /* Documentation of this command (or help topic).
 122        First line is brief documentation; remaining lines form, with it,
 123        the full documentation.  First line should end with a period.
 124        Entire string should also end with a period, not a newline.  */
 125     char *doc;
 126
 127     /* flags : a bitfield
 128
 129        bit 0: (LSB) CMD_DEPRECATED, when 1 indicated that this command
 130        is deprecated. It may be removed from gdb's command set in the
 131        future.
 132
 133        bit 1: DEPRECATED_WARN_USER, the user needs to be warned that
 134        this is a deprecated command.  The user should only be warned
 135        the first time a command is used.
 136
 137        bit 2: MALLOCED_REPLACEMENT, when functions are deprecated at
 138        compile time (this is the way it should, in general, be done)
 139        the memory containing the replacement string is statically
 140        allocated.  In some cases it makes sense to deprecate commands
 141        at runtime (the testsuite is one example).  In this case the
 142        memory for replacement is malloc'ed.  When a command is
 143        undeprecated or re-deprecated at runtime we don't want to risk
 144        calling free on statically allocated memory, so we check this
 145        flag.
 146      */
 147     int flags;
 148
 149     /* if this command is deprecated, this is the replacement name */
 150     char *replacement;
 151
 152     /* Hook for another command to be executed before this command.  */
 153     struct cmd_list_element *hook;
 154
 155     /* Nonzero identifies a prefix command.  For them, the address
 156        of the variable containing the list of subcommands.  */
 157     struct cmd_list_element **prefixlist;
 158
 159     /* For prefix commands only:
 160        String containing prefix commands to get here: this one
 161        plus any others needed to get to it.  Should end in a space.
 162        It is used before the word "command" in describing the
 163        commands reached through this prefix.  */
 164     char *prefixname;
 165
 166     /* For prefix commands only:
 167        nonzero means do not get an error if subcommand is not
 168        recognized; call the prefix's own function in that case.  */
 169     char allow_unknown;
 170
 171     /* Nonzero says this is an abbreviation, and should not
 172        be mentioned in lists of commands.
 173        This allows "br<tab>" to complete to "break", which it
 174        otherwise wouldn't.  */
 175     char abbrev_flag;
 176
 177     /* Completion routine for this command.  TEXT is the text beyond
 178        what was matched for the command itself (leading whitespace is
 179        skipped).  It stops where we are supposed to stop completing
 180        (rl_point) and is '\0' terminated.
 181
 182        Return value is a malloc'd vector of pointers to possible completions
 183        terminated with NULL.  If there are no completions, returning a pointer
 184        to a NULL would work but returning NULL itself is also valid.
 185        WORD points in the same buffer as TEXT, and completions should be
 186        returned relative to this position.  For example, suppose TEXT is "foo"
 187        and we want to complete to "foobar".  If WORD is "oo", return
 188        "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
 189     char **(*completer) PARAMS ((char *text, char *word));
 190
 191     /* Type of "set" or "show" command (or SET_NOT_SET if not "set"
 192        or "show").  */
 193     cmd_types type;
 194
 195     /* Pointer to variable affected by "set" and "show".  Doesn't matter
 196        if type is not_set.  */
 197     void *var;
 198
 199     /* What kind of variable is *VAR?  */
 200     var_types var_type;
 201
 202     /* Pointer to NULL terminated list of enumerated values (like argv).  */
 203     char **enums;
 204
 205     /* Pointer to command strings of user-defined commands */
 206     struct command_line *user_commands;
 207
 208     /* Pointer to command that is hooked by this one,
 209        so the hook can be removed when this one is deleted.  */
 210     struct cmd_list_element *hookee;
 211
 212     /* Pointer to command that is aliased by this one, so the
 213        aliased command can be located in case it has been hooked.  */
 214     struct cmd_list_element *cmd_pointer;
 215   };
 216
 217 /* Forward-declarations of the entry-points of command.c.  */
 218
 219 extern struct cmd_list_element *add_cmd (char *, enum command_class,
 220                                          void (*fun) (char *, int), char *,
 221                                          struct cmd_list_element **);
 222
 223 extern struct cmd_list_element *add_alias_cmd (char *, char *,
 224                                                enum command_class, int,
 225                                                struct cmd_list_element **);
 226
 227 extern struct cmd_list_element *add_prefix_cmd (char *, enum command_class,
 228                                                 void (*fun) (char *, int),
 229                                                 char *,
 230                                                 struct cmd_list_element **,
 231                                                 char *, int,
 232                                                 struct cmd_list_element **);
 233
 234 extern struct cmd_list_element *add_abbrev_prefix_cmd (char *,
 235                                                        enum command_class,
 236                                                        void (*fun) (char *,
 237                                                                     int),
 238                                                        char *,
 239                                                        struct cmd_list_element
 240                                                        **, char *, int,
 241                                                        struct cmd_list_element
 242                                                        **);
 243
 244 extern struct cmd_list_element *lookup_cmd (char **,
 245                                             struct cmd_list_element *, char *,
 246                                             int, int);
 247
 248 extern struct cmd_list_element *lookup_cmd_1 (char **,
 249                                               struct cmd_list_element *,
 250                                               struct cmd_list_element **,
 251                                               int);
 252
 253 extern struct cmd_list_element *
 254   deprecate_cmd (struct cmd_list_element *, char * );
 255
 256 extern void
 257   deprecated_cmd_warning (char **);
 258
 259 extern int
 260   lookup_cmd_composition (char *text,
 261                         struct cmd_list_element **alias,
 262                         struct cmd_list_element **prefix_cmd,
 263                         struct cmd_list_element **cmd);
 264
 265 extern struct cmd_list_element *add_com (char *, enum command_class,
 266                                          void (*fun) (char *, int), char *);
 267
 268 extern struct cmd_list_element *add_com_alias (char *, char *,
 269                                                enum command_class, int);
 270
 271 extern struct cmd_list_element *add_info (char *, void (*fun) (char *, int),
 272                                           char *);
 273
 274 extern struct cmd_list_element *add_info_alias (char *, char *, int);
 275
 276 extern char **complete_on_cmdlist (struct cmd_list_element *, char *, char *);
 277
 278 extern char **complete_on_enum (char **enumlist, char *, char *);
 279
 280 extern void delete_cmd (char *, struct cmd_list_element **);
 281
 282 extern void help_cmd (char *, struct ui_file *);
 283
 284 extern void help_list (struct cmd_list_element *, char *,
 285                        enum command_class, struct ui_file *);
 286
 287 extern void help_cmd_list (struct cmd_list_element *, enum command_class,
 288                            char *, int, struct ui_file *);
 289
 290 extern struct cmd_list_element *add_set_cmd (char *name, enum
 291                                              command_class class,
 292                                              var_types var_type, void *var,
 293                                              char *doc,
 294                                              struct cmd_list_element **list);
 295
 296 extern struct cmd_list_element *add_set_enum_cmd (char *name,
 297                                                   enum command_class class,
 298                                                   char *enumlist[],
 299                                                   char **var,
 300                                                   char *doc,
 301                                                   struct cmd_list_element **list);
 302
 303 extern struct cmd_list_element *add_show_from_set (struct cmd_list_element *,
 304                                                    struct cmd_list_element
 305                                                    **);
 306
 307 /* Do a "set" or "show" command.  ARG is NULL if no argument, or the text
 308    of the argument, and FROM_TTY is nonzero if this command is being entered
 309    directly by the user (i.e. these are just like any other
 310    command).  C is the command list element for the command.  */
 311
 312 extern void do_setshow_command (char *, int, struct cmd_list_element *);
 313
 314 /* Do a "show" command for each thing on a command list.  */
 315
 316 extern void cmd_show_list (struct cmd_list_element *, int, char *);
 317
 318 extern void error_no_arg (char *);
 319
 320 extern void dont_repeat (void);
 321
 322 /* Used to mark commands that don't do anything.  If we just leave the
 323    function field NULL, the command is interpreted as a help topic, or
 324    as a class of commands.  */
 325
 326 extern void not_just_help_class_command (char *, int);
 327
 328 #endif /* !defined (COMMAND_H) */