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) (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) (char *args, int from_tty, struct cmd_list_element * c);
 116       }
 117     function;
 118 #define NO_FUNCTION ((void (*) (char *args, int from_tty)) 0)
 119
 120     /* Documentation of this command (or help topic).
 121        First line is brief documentation; remaining lines form, with it,
 122        the full documentation.  First line should end with a period.
 123        Entire string should also end with a period, not a newline.  */
 124     char *doc;
 125
 126     /* flags : a bitfield
 127
 128        bit 0: (LSB) CMD_DEPRECATED, when 1 indicated that this command
 129        is deprecated. It may be removed from gdb's command set in the
 130        future.
 131
 132        bit 1: DEPRECATED_WARN_USER, the user needs to be warned that
 133        this is a deprecated command.  The user should only be warned
 134        the first time a command is used.
 135
 136        bit 2: MALLOCED_REPLACEMENT, when functions are deprecated at
 137        compile time (this is the way it should, in general, be done)
 138        the memory containing the replacement string is statically
 139        allocated.  In some cases it makes sense to deprecate commands
 140        at runtime (the testsuite is one example).  In this case the
 141        memory for replacement is malloc'ed.  When a command is
 142        undeprecated or re-deprecated at runtime we don't want to risk
 143        calling free on statically allocated memory, so we check this
 144        flag.
 145      */
 146     int flags;
 147
 148     /* if this command is deprecated, this is the replacement name */
 149     char *replacement;
 150
 151     /* Hook for another command to be executed before this command.  */
 152     struct cmd_list_element *hook;
 153
 154     /* Nonzero identifies a prefix command.  For them, the address
 155        of the variable containing the list of subcommands.  */
 156     struct cmd_list_element **prefixlist;
 157
 158     /* For prefix commands only:
 159        String containing prefix commands to get here: this one
 160        plus any others needed to get to it.  Should end in a space.
 161        It is used before the word "command" in describing the
 162        commands reached through this prefix.  */
 163     char *prefixname;
 164
 165     /* For prefix commands only:
 166        nonzero means do not get an error if subcommand is not
 167        recognized; call the prefix's own function in that case.  */
 168     char allow_unknown;
 169
 170     /* Nonzero says this is an abbreviation, and should not
 171        be mentioned in lists of commands.
 172        This allows "br<tab>" to complete to "break", which it
 173        otherwise wouldn't.  */
 174     char abbrev_flag;
 175
 176     /* Completion routine for this command.  TEXT is the text beyond
 177        what was matched for the command itself (leading whitespace is
 178        skipped).  It stops where we are supposed to stop completing
 179        (rl_point) and is '\0' terminated.
 180
 181        Return value is a malloc'd vector of pointers to possible completions
 182        terminated with NULL.  If there are no completions, returning a pointer
 183        to a NULL would work but returning NULL itself is also valid.
 184        WORD points in the same buffer as TEXT, and completions should be
 185        returned relative to this position.  For example, suppose TEXT is "foo"
 186        and we want to complete to "foobar".  If WORD is "oo", return
 187        "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
 188     char **(*completer) (char *text, char *word);
 189
 190     /* Type of "set" or "show" command (or SET_NOT_SET if not "set"
 191        or "show").  */
 192     cmd_types type;
 193
 194     /* Pointer to variable affected by "set" and "show".  Doesn't matter
 195        if type is not_set.  */
 196     void *var;
 197
 198     /* What kind of variable is *VAR?  */
 199     var_types var_type;
 200
 201     /* Pointer to NULL terminated list of enumerated values (like argv).  */
 202     const char **enums;
 203
 204     /* Pointer to command strings of user-defined commands */
 205     struct command_line *user_commands;
 206
 207     /* Pointer to command that is hooked by this one,
 208        so the hook can be removed when this one is deleted.  */
 209     struct cmd_list_element *hookee;
 210
 211     /* Pointer to command that is aliased by this one, so the
 212        aliased command can be located in case it has been hooked.  */
 213     struct cmd_list_element *cmd_pointer;
 214   };
 215
 216 /* Forward-declarations of the entry-points of command.c.  */
 217
 218 extern struct cmd_list_element *add_cmd (char *, enum command_class,
 219                                          void (*fun) (char *, int), char *,
 220                                          struct cmd_list_element **);
 221
 222 extern struct cmd_list_element *add_alias_cmd (char *, char *,
 223                                                enum command_class, int,
 224                                                struct cmd_list_element **);
 225
 226 extern struct cmd_list_element *add_prefix_cmd (char *, enum command_class,
 227                                                 void (*fun) (char *, int),
 228                                                 char *,
 229                                                 struct cmd_list_element **,
 230                                                 char *, int,
 231                                                 struct cmd_list_element **);
 232
 233 extern struct cmd_list_element *add_abbrev_prefix_cmd (char *,
 234                                                        enum command_class,
 235                                                        void (*fun) (char *,
 236                                                                     int),
 237                                                        char *,
 238                                                        struct cmd_list_element
 239                                                        **, char *, int,
 240                                                        struct cmd_list_element
 241                                                        **);
 242
 243 extern struct cmd_list_element *lookup_cmd (char **,
 244                                             struct cmd_list_element *, char *,
 245                                             int, int);
 246
 247 extern struct cmd_list_element *lookup_cmd_1 (char **,
 248                                               struct cmd_list_element *,
 249                                               struct cmd_list_element **,
 250                                               int);
 251
 252 extern struct cmd_list_element *
 253   deprecate_cmd (struct cmd_list_element *, char * );
 254
 255 extern void
 256   deprecated_cmd_warning (char **);
 257
 258 extern int
 259   lookup_cmd_composition (char *text,
 260                         struct cmd_list_element **alias,
 261                         struct cmd_list_element **prefix_cmd,
 262                         struct cmd_list_element **cmd);
 263
 264 extern struct cmd_list_element *add_com (char *, enum command_class,
 265                                          void (*fun) (char *, int), char *);
 266
 267 extern struct cmd_list_element *add_com_alias (char *, char *,
 268                                                enum command_class, int);
 269
 270 extern struct cmd_list_element *add_info (char *, void (*fun) (char *, int),
 271                                           char *);
 272
 273 extern struct cmd_list_element *add_info_alias (char *, char *, int);
 274
 275 extern char **complete_on_cmdlist (struct cmd_list_element *, char *, char *);
 276
 277 extern char **complete_on_enum (const char *enumlist[], char *, char *);
 278
 279 extern void delete_cmd (char *, struct cmd_list_element **);
 280
 281 extern void help_cmd (char *, struct ui_file *);
 282
 283 extern void help_list (struct cmd_list_element *, char *,
 284                        enum command_class, struct ui_file *);
 285
 286 extern void help_cmd_list (struct cmd_list_element *, enum command_class,
 287                            char *, int, struct ui_file *);
 288
 289 extern struct cmd_list_element *add_set_cmd (char *name, enum
 290                                              command_class class,
 291                                              var_types var_type, void *var,
 292                                              char *doc,
 293                                              struct cmd_list_element **list);
 294
 295 extern struct cmd_list_element *add_set_enum_cmd (char *name,
 296                                                   enum command_class class,
 297                                                   const char *enumlist[],
 298                                                   const char **var,
 299                                                   char *doc,
 300                                                   struct cmd_list_element **list);
 301
 302 extern struct cmd_list_element *add_show_from_set (struct cmd_list_element *,
 303                                                    struct cmd_list_element
 304                                                    **);
 305
 306 /* Do a "set" or "show" command.  ARG is NULL if no argument, or the text
 307    of the argument, and FROM_TTY is nonzero if this command is being entered
 308    directly by the user (i.e. these are just like any other
 309    command).  C is the command list element for the command.  */
 310
 311 extern void do_setshow_command (char *, int, struct cmd_list_element *);
 312
 313 /* Do a "show" command for each thing on a command list.  */
 314
 315 extern void cmd_show_list (struct cmd_list_element *, int, char *);
 316
 317 extern void error_no_arg (char *);
 318
 319 extern void dont_repeat (void);
 320
 321 /* Used to mark commands that don't do anything.  If we just leave the
 322    function field NULL, the command is interpreted as a help topic, or
 323    as a class of commands.  */
 324
 325 extern void not_just_help_class_command (char *, int);
 326
 327 #endif /* !defined (COMMAND_H) */