ex_cmds_defs.h

Go to the documentation of this file.

#ifndef NVIM_EX_CMDS_DEFS_H
#define NVIM_EX_CMDS_DEFS_H
 
#include <stdbool.h>
#include <stdint.h>
 
#include "nvim/eval/typval.h"
#include "nvim/normal.h"
#include "nvim/pos.h"      // for linenr_T
#include "nvim/regexp_defs.h"
 
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "ex_cmds_enum.generated.h"
#endif
 
// When adding an Ex command:
// 1. Add an entry to the table in src/nvim/ex_cmds.lua.  Keep it sorted on the
//    shortest version of the command name that works.  If it doesn't start with
//    a lower case letter, add it at the end.
//
//    Each table entry is a table with the following keys:
//
//      Key     | Description
//      ------- | -------------------------------------------------------------
//      command | Name of the command. Required.
//      enum    | Name of the enum entry. If not set defaults to CMD_{command}.
//      flags   | A set of the flags from below list joined by bitwise or.
//      func    | Name of the function containing the implementation.
//
//    Referenced function should be either non-static one or defined in
//    ex_docmd.c and be coercible to ex_func_T type from below.
//
//    All keys not described in the above table are reserved for future use.
//
// 2. Add a "case: CMD_xxx" in the big switch in ex_docmd.c.
// 3. Add an entry in the index for Ex commands at ":help ex-cmd-index".
// 4. Add documentation in ../doc/xxx.txt.  Add a tag for both the short and
//    long name of the command.
 
#define EX_RANGE           0x001  // allow a linespecs
#define EX_BANG            0x002  // allow a ! after the command name
#define EX_EXTRA           0x004  // allow extra args after command name
#define EX_XFILE           0x008  // expand wildcards in extra part
#define EX_NOSPC           0x010  // no spaces allowed in the extra part
#define EX_DFLALL          0x020  // default file range is 1,$
#define EX_WHOLEFOLD       0x040  // extend range to include whole fold also
                                  // when less than two numbers given
#define EX_NEEDARG         0x080  // argument required
#define EX_TRLBAR          0x100  // check for trailing vertical bar
#define EX_REGSTR          0x200  // allow "x for register designation
#define EX_COUNT           0x400  // allow count in argument, after command
#define EX_NOTRLCOM        0x800  // no trailing comment allowed
#define EX_ZEROR          0x1000  // zero line number allowed
#define EX_CTRLV          0x2000  // do not remove CTRL-V from argument
#define EX_CMDARG         0x4000  // allow "+command" argument
#define EX_BUFNAME        0x8000  // accepts buffer name
#define EX_BUFUNL        0x10000  // accepts unlisted buffer too
#define EX_ARGOPT        0x20000  // allow "++opt=val" argument
#define EX_SBOXOK        0x40000  // allowed in the sandbox
#define EX_CMDWIN        0x80000  // allowed in cmdline window; when missing
                                  // disallows editing another buffer when
                                  // current buffer is locked
#define EX_MODIFY       0x100000  // forbidden in non-'modifiable' buffer
#define EX_FLAGS        0x200000  // allow flags after count in argument
#define EX_KEEPSCRIPT  0x4000000  // keep sctx of where command was invoked
#define EX_FILES (EX_XFILE | EX_EXTRA)  // multiple extra files allowed
#define EX_FILE1 (EX_FILES | EX_NOSPC)  // 1 file, defaults to current file
#define EX_WORD1 (EX_EXTRA | EX_NOSPC)  // one extra word allowed
 
// values for cmd_addr_type
typedef enum {
  ADDR_LINES,           // buffer line numbers
  ADDR_WINDOWS,         // window number
  ADDR_ARGUMENTS,       // argument number
  ADDR_LOADED_BUFFERS,  // buffer number of loaded buffer
  ADDR_BUFFERS,         // buffer number
  ADDR_TABS,            // tab page number
  ADDR_TABS_RELATIVE,   // Tab page that only relative
  ADDR_QUICKFIX_VALID,  // quickfix list valid entry number
  ADDR_QUICKFIX,        // quickfix list entry number
  ADDR_UNSIGNED,        // positive count or zero, defaults to 1
  ADDR_OTHER,           // something else, use line number for '$', '%', etc.
  ADDR_NONE,  // no range used
} cmd_addr_T;
 
typedef struct exarg exarg_T;
 
// behavior for bad character, "++bad=" argument
#define BAD_REPLACE     '?'     // replace it with '?' (default)
#define BAD_KEEP        (-1)    // leave it
#define BAD_DROP        (-2)    // erase it
 
typedef void (*ex_func_T)(exarg_T *eap);
 
// NOTE: These possible could be removed and changed so that
// Callback could take a "command" style string, and simply
// execute that (instead of it being a function).
//
// But it's still a bit weird to do that.
//
// Another option would be that we just make a callback reference to
// "execute($INPUT)" or something like that, so whatever the user
// sends in via autocmds is just executed via this.
//
// However, that would probably have some performance cost (probably
// very marginal, but still some cost either way).
typedef enum {
  CALLABLE_NONE,
  CALLABLE_EX,
  CALLABLE_CB,
} AucmdExecutableType;
 
typedef struct aucmd_executable_t AucmdExecutable;
struct aucmd_executable_t {
  AucmdExecutableType type;
  union {
    char *cmd;
    Callback cb;
  } callable;
};
 
#define AUCMD_EXECUTABLE_INIT { .type = CALLABLE_NONE }
 
typedef char *(*LineGetter)(int, void *, int, bool);
 
typedef struct cmdname {
  char *cmd_name;    
  ex_func_T cmd_func;  
  uint32_t cmd_argt;     
  cmd_addr_T cmd_addr_type;  
} CommandDefinition;
 
// A list used for saving values of "emsg_silent".  Used by ex_try() to save the
// value of "emsg_silent" if it was non-zero.  When this is done, the CSF_SILENT
// flag below is set.
typedef struct eslist_elem eslist_T;
struct eslist_elem {
  int saved_emsg_silent;  // saved value of "emsg_silent"
  eslist_T *next;         // next element on the list
};
 
// For conditional commands a stack is kept of nested conditionals.
// When cs_idx < 0, there is no conditional command.
enum {
  CSTACK_LEN = 50,
};
 
typedef struct {
  int cs_flags[CSTACK_LEN];         // CSF_ flags
  char cs_pending[CSTACK_LEN];      // CSTP_: what's pending in ":finally"
  union {
    void *csp_rv[CSTACK_LEN];       // return typeval for pending return
    void *csp_ex[CSTACK_LEN];       // exception for pending throw
  } cs_pend;
  void *cs_forinfo[CSTACK_LEN];     // info used by ":for"
  int cs_line[CSTACK_LEN];          // line nr of ":while"/":for" line
  int cs_idx;                       // current entry, or -1 if none
  int cs_looplevel;                 // nr of nested ":while"s and ":for"s
  int cs_trylevel;                  // nr of nested ":try"s
  eslist_T *cs_emsg_silent_list;    // saved values of "emsg_silent"
  int cs_lflags;                    // loop flags: CSL_ flags
} cstack_T;
#define cs_rettv       cs_pend.csp_rv
#define cs_exception   cs_pend.csp_ex
 
// Flags for the cs_lflags item in cstack_T.
enum {
  CSL_HAD_LOOP = 1,  // just found ":while" or ":for"
  CSL_HAD_ENDLOOP = 2,  // just found ":endwhile" or ":endfor"
  CSL_HAD_CONT = 4,  // just found ":continue"
  CSL_HAD_FINA = 8,  // just found ":finally"
};
 
struct exarg {
  char *arg;                    
  char **args;                  
  size_t *arglens;              
  size_t argc;                  
  char *nextcmd;                
  char *cmd;                    
  char **cmdlinep;              
  cmdidx_T cmdidx;              
  uint32_t argt;                
  int skip;                     
  int forceit;                  
  int addr_count;               
  linenr_T line1;               
  linenr_T line2;               
  cmd_addr_T addr_type;         
  int flags;                    
  char *do_ecmd_cmd;            
  linenr_T do_ecmd_lnum;        
  int append;                   
  int usefilter;                
  int amount;                   
  int regname;                  
  int force_bin;                
  int read_edit;                
  int force_ff;                 
  int force_enc;                
  int bad_char;                 
  int useridx;                  
  char *errmsg;                 
  LineGetter getline;           
  void *cookie;                 
  cstack_T *cstack;             
  long verbose_save;            
  int save_msg_silent;          
  int did_esilent;              
  bool did_sandbox;             
};
 
#define FORCE_BIN 1             // ":edit ++bin file"
#define FORCE_NOBIN 2           // ":edit ++nobin file"
 
// Values for "flags"
#define EXFLAG_LIST     0x01    // 'l': list
#define EXFLAG_NR       0x02    // '#': number
#define EXFLAG_PRINT    0x04    // 'p': print
 
// used for completion on the command line
struct expand {
  char *xp_pattern;             // start of item to expand
  int xp_context;               // type of expansion
  size_t xp_pattern_len;        // bytes in xp_pattern before cursor
  char *xp_arg;                 // completion function
  LuaRef xp_luaref;             // Ref to Lua completion function
  sctx_T xp_script_ctx;         // SCTX for completion function
  int xp_backslash;             // one of the XP_BS_ values
#ifndef BACKSLASH_IN_FILENAME
  int xp_shell;                 // TRUE for a shell command, more
                                // characters need to be escaped
#endif
  int xp_numfiles;              // number of files found by file name completion
  int xp_col;                   // cursor position in line
  char **xp_files;              // list of files
  char *xp_line;                // text being completed
};
 
// values for xp_backslash
#define XP_BS_NONE      0       // nothing special for backslashes
#define XP_BS_ONE       1       // uses one backslash before a space
#define XP_BS_THREE     2       // uses three backslashes before a space
 
typedef struct {
  int split;                   
  int tab;                     
  bool browse;                 
  bool confirm;                
  bool hide;                   
  bool keepalt;                
  bool keepjumps;              
  bool keepmarks;              
  bool keeppatterns;           
  bool lockmarks;              
  bool noswapfile;             
  char *save_ei;               
  regmatch_T filter_regmatch;  
  bool filter_force;           
} cmdmod_T;
 
typedef struct {
  bool silent;
  bool emsg_silent;
  bool sandbox;
  bool noautocmd;
  long verbose;
  cmdmod_T cmdmod;
  struct {
    bool file;
    bool bar;
  } magic;
} CmdParseInfo;
 
#endif  // NVIM_EX_CMDS_DEFS_H