rz_cmd.h

Go to the documentation of this file.

#ifndef RZ_CMD_H
#define RZ_CMD_H
 
#include <rz_types.h>
#include <rz_util.h>
#include <rz_bind.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct rz_core_t RzCore;
 
// RZ_LIB_VERSION_HEADER (rz_cmd);
 
#define MACRO_LIMIT   1024
#define MACRO_LABELS  20
#define RZ_CMD_MAXLEN 4096
 
typedef enum rz_cmd_status_t {
    RZ_CMD_STATUS_OK = 0, 
    RZ_CMD_STATUS_WRONG_ARGS, 
    RZ_CMD_STATUS_ERROR, 
    RZ_CMD_STATUS_INVALID, 
    RZ_CMD_STATUS_NONEXISTINGCMD, 
    RZ_CMD_STATUS_EXIT, 
} RzCmdStatus;
 
typedef enum rz_cmd_arg_type_t {
    RZ_CMD_ARG_TYPE_FAKE, 
    RZ_CMD_ARG_TYPE_NUM, 
    RZ_CMD_ARG_TYPE_RZNUM, 
    RZ_CMD_ARG_TYPE_STRING, 
    RZ_CMD_ARG_TYPE_ENV, 
    RZ_CMD_ARG_TYPE_CHOICES, 
    RZ_CMD_ARG_TYPE_FCN, 
    RZ_CMD_ARG_TYPE_FILE, 
    RZ_CMD_ARG_TYPE_OPTION, 
    RZ_CMD_ARG_TYPE_CMD, 
    RZ_CMD_ARG_TYPE_MACRO, 
    RZ_CMD_ARG_TYPE_EVAL_KEY, 
    RZ_CMD_ARG_TYPE_EVAL_FULL, 
    RZ_CMD_ARG_TYPE_FCN_VAR, 
    RZ_CMD_ARG_TYPE_FLAG, 
    RZ_CMD_ARG_TYPE_ENUM_TYPE, 
    RZ_CMD_ARG_TYPE_STRUCT_TYPE, 
    RZ_CMD_ARG_TYPE_UNION_TYPE, 
    RZ_CMD_ARG_TYPE_ALIAS_TYPE, 
    RZ_CMD_ARG_TYPE_CLASS_TYPE, 
    RZ_CMD_ARG_TYPE_ANY_TYPE, 
    RZ_CMD_ARG_TYPE_GLOBAL_VAR, 
    RZ_CMD_ARG_TYPE_REG_FILTER, 
    RZ_CMD_ARG_TYPE_REG_TYPE, 
} RzCmdArgType;
 
#define RZ_CMD_ARG_FLAG_LAST (1 << 0)
#define RZ_CMD_ARG_FLAG_ARRAY (1 << 1)
#define RZ_CMD_ARG_FLAG_OPTION (1 << 2)
 
typedef enum rz_cmd_escape_t {
    RZ_CMD_ESCAPE_ONE_ARG, 
    RZ_CMD_ESCAPE_MULTI_ARG, 
    RZ_CMD_ESCAPE_PF_ARG, 
    RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG, 
    RZ_CMD_ESCAPE_SINGLE_QUOTED_ARG, 
} RzCmdEscape;
 
typedef struct rz_cmd_state_output_t {
    RzOutputMode mode;
    union {
        PJ *pj;
        RzTable *t;
    } d;
} RzCmdStateOutput;
 
typedef int (*RzCmdCb)(void *user, const char *input);
typedef RzCmdStatus (*RzCmdArgvCb)(RzCore *core, int argc, const char **argv);
typedef RzCmdStatus (*RzCmdArgvModesCb)(RzCore *core, int argc, const char **argv, RzOutputMode mode);
typedef RzCmdStatus (*RzCmdArgvStateCb)(RzCore *core, int argc, const char **argv, RzCmdStateOutput *state);
typedef int (*RzCmdNullCb)(void *user);
 
typedef struct rz_cmd_parsed_args_t {
    int argc;
    char **argv;
    bool has_space_after_cmd;
    char *extra; 
} RzCmdParsedArgs;
 
typedef struct rz_cmd_macro_label_t {
    char name[80];
    char *ptr;
} RzCmdMacroLabel;
 
typedef struct rz_cmd_macro_item_t {
    char *name;
    char *args;
    char *code;
    int codelen;
    int nargs;
} RzCmdMacroItem;
 
typedef struct rz_cmd_macro_t {
    int counter;
    ut64 *brk_value;
    ut64 _brk_value;
    int brk;
    //  int (*cmd)(void *user, const char *cmd);
    RzCoreCmd cmd;
    PrintfCallback cb_printf;
    void *user;
    RzNum *num;
    int labels_n;
    RzCmdMacroLabel labels[MACRO_LABELS];
    RzList *macros;
} RzCmdMacro;
 
typedef struct rz_cmd_item_t {
    char cmd[64];
    RzCmdCb callback;
} RzCmdItem;
 
typedef struct rz_cmd_alias_t {
    int count;
    char **keys;
    char **values;
    int *remote;
} RzCmdAlias;
 
typedef struct rz_cmd_desc_detail_entry_t {
    const char *text;
    const char *comment;
    const char *arg_str;
} RzCmdDescDetailEntry;
 
typedef struct rz_cmd_desc_detail_t {
    const char *name;
    const RzCmdDescDetailEntry *entries;
} RzCmdDescDetail;
 
typedef RZ_OWN RzCmdDescDetail *(*RzCmdDescDetailCb)(RzCore *core, int argc, const char **argv);
 
typedef RZ_OWN char **(*RzCmdArgChoiceCb)(RzCore *core);
 
typedef struct rz_cmd_desc_arg_t {
    const char *name;
    bool optional;
    bool no_space;
    RzCmdArgType type;
    int flags;
    const char *default_value;
    union {
        const char **choices;
        RzCmdArgChoiceCb choices_cb;
    };
} RzCmdDescArg;
 
typedef struct rz_cmd_desc_help_t {
    const char *summary;
    const char *description;
    const char *args_str;
    const char *usage;
    const char *options;
    bool sort_subcommands;
    const RzCmdDescDetail *details;
    RzCmdDescDetailCb details_cb;
    const RzCmdDescArg *args;
} RzCmdDescHelp;
 
typedef enum rz_cmd_desc_type_t {
    RZ_CMD_DESC_TYPE_OLDINPUT = 0,
    RZ_CMD_DESC_TYPE_ARGV,
    RZ_CMD_DESC_TYPE_GROUP,
    RZ_CMD_DESC_TYPE_INNER,
    RZ_CMD_DESC_TYPE_FAKE,
    RZ_CMD_DESC_TYPE_ARGV_MODES,
    RZ_CMD_DESC_TYPE_ARGV_STATE,
} RzCmdDescType;
 
typedef struct rz_cmd_desc_t {
    RzCmdDescType type;
    char *name;
    struct rz_cmd_desc_t *parent;
    int n_children;
    RzPVector children;
    const RzCmdDescHelp *help;
 
    union {
        struct {
            RzCmdCb cb;
        } oldinput_data;
        struct {
            RzCmdArgvCb cb;
            int min_argc;
            int max_argc;
        } argv_data;
        struct {
            struct rz_cmd_desc_t *exec_cd;
        } group_data;
        struct {
            RzCmdArgvModesCb cb;
            int modes; 
            RzOutputMode default_mode; 
            int min_argc;
            int max_argc;
        } argv_modes_data;
        struct {
            RzCmdArgvStateCb cb;
            int modes; 
            RzOutputMode default_mode; 
            int min_argc;
            int max_argc;
        } argv_state_data;
    } d;
} RzCmdDesc;
 
typedef struct rz_cmd_t {
    void *data;
    RzCmdNullCb nullcallback;
    RzCmdItem *cmds[UT8_MAX];
    RzCmdMacro macro;
    RzCmdAlias aliases;
    void *language; // used to store TSLanguage *
    HtUP *ts_symbols_ht;
    RzCmdDesc *root_cmd_desc;
    HtPP *ht_cmds;
    bool has_cons;
    bool batch;
} RzCmd;
 
// TODO: remove this once transitioned to RzCmdDesc
typedef struct rz_cmd_descriptor_t {
    const char *cmd;
    const char **help_msg;
    const char **help_detail;
    const char **help_detail2;
    struct rz_cmd_descriptor_t *sub[127];
} RzCmdDescriptor;
 
typedef bool (*RzCmdForeachNameCb)(RzCmd *cmd, const RzCmdDesc *desc, void *user);
 
#ifdef RZ_API
RZ_API RzCmd *rz_cmd_new(bool has_cons);
RZ_API RzCmd *rz_cmd_free(RzCmd *cmd);
RZ_API int rz_cmd_set_data(RzCmd *cmd, void *data);
RZ_API void rz_cmd_batch_start(RzCmd *cmd);
RZ_API void rz_cmd_batch_end(RzCmd *cmd);
RZ_API int rz_cmd_add(RzCmd *cmd, const char *command, RzCmdCb callback);
RZ_API int rz_cmd_call(RzCmd *cmd, const char *command);
RZ_API RzCmdStatus rz_cmd_call_parsed_args(RzCmd *cmd, RzCmdParsedArgs *args);
RZ_API RzCmdDesc *rz_cmd_get_root(RzCmd *cmd);
RZ_API RzCmdDesc *rz_cmd_get_desc(RzCmd *cmd, const char *cmd_identifier);
RZ_API RzCmdDesc *rz_cmd_get_desc_best(RzCmd *cmd, const char *cmd_identifier);
RZ_API char *rz_cmd_get_help(RzCmd *cmd, RzCmdParsedArgs *args, bool use_color);
RZ_API bool rz_cmd_get_help_json(RzCmd *cmd, const RzCmdDesc *cd, PJ *j);
RZ_API bool rz_cmd_get_help_strbuf(RzCmd *cmd, const RzCmdDesc *cd, bool use_color, RzStrBuf *sb);
 
static inline RzCmdStatus rz_cmd_int2status(int v) {
    if (v == -2) {
        return RZ_CMD_STATUS_EXIT;
    } else if (v < 0) {
        return RZ_CMD_STATUS_ERROR;
    } else {
        return RZ_CMD_STATUS_OK;
    }
}
 
static inline int rz_cmd_status2int(RzCmdStatus s) {
    switch (s) {
    case RZ_CMD_STATUS_OK:
        return 0;
    case RZ_CMD_STATUS_ERROR:
    case RZ_CMD_STATUS_WRONG_ARGS:
    case RZ_CMD_STATUS_INVALID:
    case RZ_CMD_STATUS_NONEXISTINGCMD:
        return -1;
    case RZ_CMD_STATUS_EXIT:
    default:
        return -2;
    }
}
 
/* RzCmdDescriptor */
RZ_API RzCmdDesc *rz_cmd_desc_argv_new(RzCmd *cmd, RzCmdDesc *parent, const char *name, RzCmdArgvCb cb, const RzCmdDescHelp *help);
RZ_API RzCmdDesc *rz_cmd_desc_argv_modes_new(RzCmd *cmd, RzCmdDesc *parent, const char *name, int modes, RzCmdArgvModesCb cb, const RzCmdDescHelp *help);
RZ_API RzCmdDesc *rz_cmd_desc_argv_state_new(RzCmd *cmd, RzCmdDesc *parent, const char *name, int modes, RzCmdArgvStateCb cb, const RzCmdDescHelp *help);
RZ_API RzCmdDesc *rz_cmd_desc_inner_new(RzCmd *cmd, RzCmdDesc *parent, const char *name, const RzCmdDescHelp *help);
RZ_API RzCmdDesc *rz_cmd_desc_group_new(RzCmd *cmd, RzCmdDesc *parent, const char *name, RzCmdArgvCb cb, const RzCmdDescHelp *help, const RzCmdDescHelp *group_help);
RZ_API RzCmdDesc *rz_cmd_desc_group_modes_new(RzCmd *cmd, RzCmdDesc *parent, const char *name, int modes, RzCmdArgvModesCb cb, const RzCmdDescHelp *help, const RzCmdDescHelp *group_help);
RZ_API RzCmdDesc *rz_cmd_desc_group_state_new(RzCmd *cmd, RzCmdDesc *parent, const char *name, int modes, RzCmdArgvStateCb cb, const RzCmdDescHelp *help, const RzCmdDescHelp *group_help);
RZ_API RzCmdDesc *rz_cmd_desc_oldinput_new(RzCmd *cmd, RzCmdDesc *parent, const char *name, RzCmdCb cb, const RzCmdDescHelp *help);
RZ_API RzCmdDesc *rz_cmd_desc_fake_new(RzCmd *cmd, RzCmdDesc *parent, const char *name, const RzCmdDescHelp *help);
RZ_API RzCmdDesc *rz_cmd_desc_parent(RzCmdDesc *cd);
RZ_API RzCmdDesc *rz_cmd_desc_get_exec(RzCmdDesc *cd);
RZ_API bool rz_cmd_desc_set_default_mode(RzCmdDesc *cd, RzOutputMode mode);
RZ_API bool rz_cmd_desc_has_handler(const RzCmdDesc *cd);
RZ_API bool rz_cmd_desc_remove(RzCmd *cmd, RzCmdDesc *cd);
RZ_API void rz_cmd_foreach_cmdname(RzCmd *cmd, RzCmdDesc *begin, RzCmdForeachNameCb cb, void *user);
RZ_API const RzCmdDescArg *rz_cmd_desc_get_arg(RzCmd *cmd, const RzCmdDesc *cd, size_t i);
 
#define rz_cmd_desc_children_foreach(root, it_cd) rz_pvector_foreach (&root->children, it_cd)
 
RZ_API void rz_cmd_desc_details_free(RzCmdDescDetail *details);
 
/* RzCmdParsedArgs */
RZ_API RzCmdParsedArgs *rz_cmd_parsed_args_new(const char *cmd, int n_args, char **args);
RZ_API RzCmdParsedArgs *rz_cmd_parsed_args_newcmd(const char *cmd);
RZ_API RzCmdParsedArgs *rz_cmd_parsed_args_newargs(int n_args, char **args);
RZ_API void rz_cmd_parsed_args_free(RzCmdParsedArgs *args);
RZ_API bool rz_cmd_parsed_args_setargs(RzCmdParsedArgs *arg, int n_args, char **args);
RZ_API bool rz_cmd_parsed_args_addarg(RzCmdParsedArgs *a, const char *arg);
RZ_API bool rz_cmd_parsed_args_setcmd(RzCmdParsedArgs *arg, const char *cmd);
RZ_API char *rz_cmd_parsed_args_argstr(RzCmdParsedArgs *arg);
RZ_API char *rz_cmd_parsed_args_execstr(RzCmdParsedArgs *arg);
RZ_API const char *rz_cmd_parsed_args_cmd(RzCmdParsedArgs *arg);
 
RZ_API char *rz_cmd_escape_arg(const char *arg, RzCmdEscape escape);
RZ_API char *rz_cmd_unescape_arg(const char *arg, RzCmdEscape escape);
 
RZ_API void rz_cmd_state_output_array_start(RzCmdStateOutput *state);
RZ_API void rz_cmd_state_output_array_end(RzCmdStateOutput *state);
RZ_API void rz_cmd_state_output_set_columnsf(RzCmdStateOutput *state, const char *fmt, ...);
RZ_API bool rz_cmd_state_output_init(RZ_NONNULL RzCmdStateOutput *state, RzOutputMode mode);
RZ_API void rz_cmd_state_output_fini(RZ_NONNULL RzCmdStateOutput *state);
RZ_API void rz_cmd_state_output_free(RZ_NONNULL RzCmdStateOutput *state);
RZ_API void rz_cmd_state_output_print(RZ_NONNULL RzCmdStateOutput *state);
 
#define rz_cmd_parsed_args_foreach_arg(args, i, arg) for ((i) = 1; (i) < (args->argc) && ((arg) = (args)->argv[i]); (i)++)
 
/* rz_cmd_macro */
RZ_API RzCmdMacroItem *rz_cmd_macro_item_new(void);
RZ_API void rz_cmd_macro_item_free(RzCmdMacroItem *item);
RZ_API void rz_cmd_macro_init(RzCmdMacro *mac);
RZ_API int rz_cmd_macro_add(RzCmdMacro *mac, const char *name);
RZ_API int rz_cmd_macro_rm(RzCmdMacro *mac, const char *_name);
RZ_API void rz_cmd_macro_list(RzCmdMacro *mac);
RZ_API void rz_cmd_macro_meta(RzCmdMacro *mac);
RZ_API int rz_cmd_macro_call(RzCmdMacro *mac, const char *name);
RZ_API int rz_cmd_macro_call_multiple(RzCmdMacro *mac, const char *name);
RZ_API int rz_cmd_macro_break(RzCmdMacro *mac, const char *value);
 
RZ_API bool rz_cmd_alias_del(RzCmd *cmd, const char *k);
RZ_API char **rz_cmd_alias_keys(RzCmd *cmd, int *sz);
RZ_API int rz_cmd_alias_set(RzCmd *cmd, const char *k, const char *v, int remote);
RZ_API char *rz_cmd_alias_get(RzCmd *cmd, const char *k, int remote);
RZ_API void rz_cmd_alias_free(RzCmd *cmd);
RZ_API void rz_cmd_macro_fini(RzCmdMacro *mac);
 
#ifdef __cplusplus
}
#endif
 
#endif
#endif