cmd_api.c File Reference

#include <rz_cmd.h>
#include <rz_util.h>
#include <stdio.h>
#include <rz_cons.h>
#include <rz_core.h>

Go to the source code of this file.

Classes
struct	argv_modes_t

Macros
#define	MAX_CHILDREN_SHOW   7
#define	MIN_SUMMARY_WIDTH   6
#define	MAX_RIGHT_ALIGHNMENT   20
#define	NCMDS   (sizeof(cmd->cmds) / sizeof(*cmd->cmds))
#define	CASE_TYPE(x, y)
#define	CASE_CDTYPE(x, y)

Functions
RZ_IPI int	rz_output_mode_to_char (RzOutputMode mode)
RZ_IPI const char *	rz_output_mode_to_summary (RzOutputMode mode)
	RZ_LIB_VERSION (rz_cmd)
static void	fill_details (RzCmd *cmd, RzCmdDesc *cd, RzStrBuf *sb, bool use_color)
static int	cd_sort (const void *a, const void *b)
static bool	cmd_desc_set_parent (RzCmd *cmd, RzCmdDesc *cd, RzCmdDesc *parent)
static void	cmd_desc_unset_parent (RzCmdDesc *cd)
static void	cmd_desc_remove_from_ht_cmds (RzCmd *cmd, RzCmdDesc *cd)
static void	cmd_desc_free (RzCmdDesc *cd)
static RzCmdDesc *	create_cmd_desc (RzCmd *cmd, RzCmdDesc *parent, RzCmdDescType type, const char *name, const RzCmdDescHelp *help, bool ht_insert)
RZ_API void	rz_cmd_alias_init (RzCmd *cmd)
RZ_API RzCmd *	rz_cmd_new (bool has_cons)
RZ_API RzCmd *	rz_cmd_free (RzCmd *cmd)
RZ_API RzCmdDesc *	rz_cmd_get_root (RzCmd *cmd)
	Get the root command descriptor. More...
RZ_API void	rz_cmd_batch_start (RzCmd *cmd)
	Mark the start of the batched changes to RzCmd. More...
static void	sort_groups (RzCmdDesc *group)
RZ_API void	rz_cmd_batch_end (RzCmd *cmd)
	Mark the end of the batched changes to RzCmd. More...
static RzOutputMode	suffix2mode (const char *suffix)
static bool	has_cd_submodes (const RzCmdDesc *cd)
static bool	is_valid_argv_modes (RzCmdDesc *cd, char last_letter)
RZ_API RzCmdDesc *	rz_cmd_desc_get_exec (RzCmdDesc *cd)
static RzCmdDesc *	cmd_get_desc_best (RzCmd *cmd, const char *cmd_identifier, bool best_match)
RZ_API RzCmdDesc *	rz_cmd_get_desc_best (RzCmd *cmd, const char *cmd_identifier)
	Retrieve the command descriptor that best matches the name cmd_identifier. More...
RZ_API RzCmdDesc *	rz_cmd_get_desc (RzCmd *cmd, const char *cmd_identifier)
	Retrieve the command descriptor for the command named cmd_identifier. More...
RZ_API bool	rz_cmd_desc_set_default_mode (RzCmdDesc *cd, RzOutputMode mode)
	Set the default mode of the command descriptor, if the type allows it. More...
RZ_API char **	rz_cmd_alias_keys (RzCmd *cmd, int *sz)
RZ_API void	rz_cmd_alias_free (RzCmd *cmd)
RZ_API bool	rz_cmd_alias_del (RzCmd *cmd, const char *k)
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 int	rz_cmd_set_data (RzCmd *cmd, void *data)
RZ_API int	rz_cmd_add (RzCmd *c, const char *cmd, RzCmdCb cb)
RZ_API int	rz_cmd_del (RzCmd *cmd, const char *command)
RZ_API int	rz_cmd_call (RzCmd *cmd, const char *input)
static RzCmdStatus	int2cmdstatus (int v)
static void	get_minmax_argc (RzCmdDesc *cd, int *min_argc, int *max_argc)
static RzOutputMode	get_cd_default_mode (RzCmdDesc *cd)
static bool	has_cd_default_mode (RzCmdDesc *cd)
static RzOutputMode	cd_suffix2mode (RzCmdDesc *cd, const char *cmdid)
static void	args_preprocessing (RzCmdDesc *cd, RzCmdParsedArgs *args)
static RzCmdStatus	argv_call_cb (RzCmd *cmd, RzCmdDesc *cd, RzCmdParsedArgs *args)
static RzCmdStatus	call_cd (RzCmd *cmd, RzCmdDesc *cd, RzCmdParsedArgs *args)
RZ_API RzCmdStatus	rz_cmd_call_parsed_args (RzCmd *cmd, RzCmdParsedArgs *args)
static size_t	strlen0 (const char *s)
static size_t	strbuf_append_calc (RzStrBuf *sb, const char *s)
static void	fill_modes_children_chars (RzStrBuf *sb, const RzCmdDesc *cd)
static size_t	fill_children_chars (RzStrBuf *sb, const RzCmdDesc *cd)
static bool	show_children_shortcut (const RzCmdDesc *cd)
static void	fill_colored_args (RzCmd *cmd, RzStrBuf *sb, const char *line, bool use_color, const char *reset_color)
static void	fill_wrapped_comment (RzCmd *cmd, RzStrBuf *sb, const char *comment, size_t columns, bool use_color)
static void	close_optionals (size_t *n_optionals, RzStrBuf *sb, size_t *len)
static size_t	fill_args (RzStrBuf *sb, const RzCmdDesc *cd)
static void	fill_usage_strbuf (RzCmd *cmd, RzStrBuf *sb, RzCmdDesc *cd, bool use_color)
static size_t	calc_padding_len (const RzCmdDesc *cd, const char *name, bool show_children)
static void	update_minmax_len (RzCmdDesc *cd, size_t *max_len, size_t *min_len, bool show_children)
static void	do_print_child_help (RzCmd *cmd, RzStrBuf *sb, const RzCmdDesc *cd, const char *name, const char *summary, bool show_children, size_t max_len, bool use_color)
static void	print_child_help (RzCmd *cmd, RzStrBuf *sb, RzCmdDesc *cd, size_t max_len, bool use_color)
static char *	group_get_help (RzCmd *cmd, RzCmdDesc *cd, bool use_color)
static void	fill_argv_modes_help_strbuf (RzCmd *cmd, RzStrBuf *sb, RzCmdDesc *cd, bool use_color)
static const RzCmdDescDetail *	get_cd_details (RzCmdDesc *cd)
static RzCmdDescDetail *	get_cd_details_cb (RzCmd *cmd, RzCmdDesc *cd)
static void	fill_details_do (RzCmd *cmd, const RzCmdDescDetail *detail_it, RzStrBuf *sb, bool use_color)
static void	fill_details_static (RzCmd *cmd, RzCmdDesc *cd, RzStrBuf *sb, bool use_color)
static void	fill_details_cb (RzCmd *cmd, RzCmdDesc *cd, RzStrBuf *sb, bool use_color)
static char *	argv_get_help (RzCmd *cmd, RzCmdDesc *cd, size_t detail, bool use_color)
static char *	fake_get_help (RzCmd *cmd, RzCmdDesc *cd, bool use_color)
static char *	oldinput_get_help (RzCmd *cmd, RzCmdDesc *cd, RzCmdParsedArgs *a)
static char *	get_help (RzCmd *cmd, RzCmdDesc *cd, const char *cmdid, RzCmdParsedArgs *args, bool use_color, size_t detail)
static void	fill_args_json (const RzCmd *cmd, const RzCmdDesc *cd, PJ *j)
RZ_API bool	rz_cmd_get_help_json (RzCmd *cmd, const RzCmdDesc *cd, PJ *j)
	Generates a JSON output of the given help message description. More...
RZ_API bool	rz_cmd_get_help_strbuf (RzCmd *cmd, const RzCmdDesc *cd, bool use_color, RzStrBuf *sb)
	Generates a text output of the given help message description (summary format) More...
RZ_API char *	rz_cmd_get_help (RzCmd *cmd, RzCmdParsedArgs *args, bool use_color)
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 void	rz_cmd_macro_fini (RzCmdMacro *mac)
RZ_API int	rz_cmd_macro_add (RzCmdMacro *mac, const char *oname)
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_cmd_args (RzCmdMacro *mac, const char *ptr, const char *args, int nargs)
RZ_API char *	rz_cmd_macro_label_process (RzCmdMacro *mac, RzCmdMacroLabel *labels, int *labels_n, char *ptr)
static int	macro_call (RzCmdMacro *mac, const char *name, bool multiple)
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 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 *a)
static void	free_array (char **arr, int n)
RZ_API bool	rz_cmd_parsed_args_setargs (RzCmdParsedArgs *a, 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 *a, const char *cmd)
static void	parsed_args_iterateargs (RzCmdParsedArgs *a, RzStrBuf *sb)
RZ_API char *	rz_cmd_parsed_args_argstr (RzCmdParsedArgs *a)
RZ_API char *	rz_cmd_parsed_args_execstr (RzCmdParsedArgs *a)
RZ_API const char *	rz_cmd_parsed_args_cmd (RzCmdParsedArgs *a)
static RzCmdDesc *	argv_new (RzCmd *cmd, RzCmdDesc *parent, const char *name, RzCmdArgvCb cb, const RzCmdDescHelp *help, bool ht_insert)
RZ_API RzCmdDesc *	rz_cmd_desc_argv_new (RzCmd *cmd, RzCmdDesc *parent, const char *name, RzCmdArgvCb cb, const RzCmdDescHelp *help)
static RzCmdDesc *	argv_modes_new (RzCmd *cmd, RzCmdDesc *parent, const char *name, int modes, RzCmdArgvModesCb cb, const RzCmdDescHelp *help, bool ht_insert)
static RzCmdDesc *	argv_state_new (RzCmd *cmd, RzCmdDesc *parent, const char *name, int modes, RzCmdArgvStateCb cb, const RzCmdDescHelp *help, bool ht_insert)
RZ_API RzCmdDesc *	rz_cmd_desc_argv_modes_new (RzCmd *cmd, RzCmdDesc *parent, const char *name, int modes, RzCmdArgvModesCb cb, const RzCmdDescHelp *help)
	Create a new command descriptor for a command that supports multiple output modes (e.g. rizin commands, json, csv, etc.). More...
RZ_API RzCmdDesc *	rz_cmd_desc_argv_state_new (RzCmd *cmd, RzCmdDesc *parent, const char *name, int modes, RzCmdArgvStateCb cb, const RzCmdDescHelp *help)
	Create a new command descriptor for a command that supports multiple output modes (e.g. rizin commands, json, csv, etc.), where the state of the output is handled by RzCmd itself. More...
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)
	Create a new command descriptor for a name that is used both as a group but that has a sub-command with the same name as well. More...
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)
	Create a new command descriptor for a name that is used both as a group but that has a sub-command with the same name as well. The sub-command supports multiple output modes (e.g. rizin commands, json, csv, etc.). More...
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)
	Create a new command descriptor for a name that is used both as a group but that has a sub-command with the same name as well. The sub-command supports multiple output modes (e.g. rizin commands, json, csv, etc.), where the state of the output is handled by RzCmd itself. More...
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 bool	rz_cmd_desc_has_handler (const RzCmdDesc *cd)
RZ_API bool	rz_cmd_desc_remove (RzCmd *cmd, RzCmdDesc *cd)
RZ_API const RzCmdDescArg *	rz_cmd_desc_get_arg (RzCmd *cmd, const RzCmdDesc *cd, size_t i)
	Get a reference to the i-th argument of a command descriptor. More...
static RzCmdDescHelp *	mode_cmd_desc_help (RzCmdDescHelp *dst, const RzCmdDescHelp *src, const char *suffix)
static void	cmd_foreach_cmdname_modes (RzCmd *cmd, RzCmdDesc *cd, int modes, RzCmdForeachNameCb cb, void *user)
static void	cmd_foreach_cmdname (RzCmd *cmd, RzCmdDesc *cd, RzCmdForeachNameCb cb, void *user)
RZ_API void	rz_cmd_foreach_cmdname (RzCmd *cmd, RzCmdDesc *begin, RzCmdForeachNameCb cb, void *user)
	Execute a callback function on each possible command the user can execute. More...
static char *	escape_special_chars (const char *s, const char *special_chars)
static char *	unescape_special_chars (const char *s, const char *special_chars)
RZ_API char *	rz_cmd_escape_arg (const char *arg, RzCmdEscape esc)
RZ_API char *	rz_cmd_unescape_arg (const char *arg, RzCmdEscape esc)
RZ_API void	rz_cmd_state_output_array_start (RzCmdStateOutput *state)
	Mark the start of an array of elements in the output. More...
RZ_API void	rz_cmd_state_output_array_end (RzCmdStateOutput *state)
	Mark the end of an array of elements in the output. More...
RZ_API void	rz_cmd_state_output_set_columnsf (RzCmdStateOutput *state, const char *fmt,...)
	Specify the columns of the command output. More...
RZ_API void	rz_cmd_state_output_fini (RZ_NONNULL RzCmdStateOutput *state)
	Clear the inner fields of RzCmdStateOutput structure, but do not free it. More...
RZ_API void	rz_cmd_state_output_free (RZ_NONNULL RzCmdStateOutput *state)
	Free the RzCmdStateOutput structure and its inner fields appropriately. More...
RZ_API bool	rz_cmd_state_output_init (RZ_NONNULL RzCmdStateOutput *state, RzOutputMode mode)
	Initialize a RzCmdStateOutput structure and its inner fields based on the provided mode. More...
RZ_API void	rz_cmd_state_output_print (RZ_NONNULL RzCmdStateOutput *state)
	Print the output accumulated in state to RzCons, if necessary. More...
RZ_API void	rz_cmd_desc_details_free (RzCmdDescDetail *details)
	Free an array of RzCmdDescDetail sections. More...

Variables
static const char *	SPECIAL_CHARS_REGULAR = "@;~$#|`\"'()<>"
static const char *	SPECIAL_CHARS_REGULAR_SINGLE = "@;~$#|`\"'()<> "
static const char *	SPECIAL_CHARS_PF = "@;~$#|`\"'<>"
static const char *	SPECIAL_CHARS_DOUBLE_QUOTED = "\"$()`"
static const char *	SPECIAL_CHARS_SINGLE_QUOTED = "'"
static const RzCmdDescHelp	not_defined_help
static const RzCmdDescHelp	root_help
static const struct argv_modes_t	argv_modes []
static int	value = 0

Macro Definition Documentation

CASE_CDTYPE

#define CASE_CDTYPE	(		x,
			y
	)

Value:

    case (x): \
        type = (y); \
        break

CASE_TYPE

#define CASE_TYPE	(		x,
			y
	)

Value:

    case (x): \
        argtype = (y); \
        break

MAX_CHILDREN_SHOW

#define MAX_CHILDREN_SHOW   7

Number of sub-commands to show as options when displaying the help of a command. When a command has more options than MAX_CHILDREN_SHOW, ? is shown instead.

Example with MAX_CHILDREN_SHOW=3: w -> wa -> wb -> wc

When doing ?, you would see: w[abc]

If there is also: -> wd you would see: w[?]

Definition at line 30 of file cmd_api.c.

MAX_RIGHT_ALIGHNMENT

#define MAX_RIGHT_ALIGHNMENT   20

Definition at line 33 of file cmd_api.c.

MIN_SUMMARY_WIDTH

#define MIN_SUMMARY_WIDTH   6

Definition at line 32 of file cmd_api.c.

NCMDS

#define NCMDS   (sizeof(cmd->cmds) / sizeof(*cmd->cmds))

Definition at line 95 of file cmd_api.c.

Function Documentation

args_preprocessing()

static void args_preprocessing ( RzCmdDesc *  cd, RzCmdParsedArgs *  args  )

static

Performs a preprocessing step on the user arguments.

This is used to group together some arguments that are returned by the parser as multiple arguments but we want to let the command handler see them as a single one to make life easier for users.

It can also provide default arguments as specified by the command descriptor.

For example: cmdid pd 10 would be considered as having 2 arguments, "pd" and "10". However, if <cmdid> was defined to have as argument RZ_CMD_ARG_FLAG_LAST, we want to group "pd" and "10" in one single argument "pd 10" and pass that to <cmdid> handler.

Definition at line 667 of file cmd_api.c.

                                                                     {
    const RzCmdDescArg *arg;
    size_t i, j;
    for (arg = cd->help->args, i = 1; arg && arg->name && i < args->argc - 1; arg++, i++) {
        char *tmp;
        if (arg->flags & RZ_CMD_ARG_FLAG_LAST) {
            if (arg->type == RZ_CMD_ARG_TYPE_CMD) {
                for (j = i; j < args->argc; j++) {
                    char *s = rz_cmd_escape_arg(args->argv[j], RZ_CMD_ESCAPE_ONE_ARG);
                    if (strcmp(s, args->argv[j])) {
                        free(args->argv[j]);
                        args->argv[j] = s;
                    } else {
                        free(s);
                    }
                }
            }
 
            tmp = rz_str_array_join((const char **)&args->argv[i], args->argc - i, " ");
            if (!tmp) {
                return;
            }
            for (j = i; j < args->argc; j++) {
                free(args->argv[j]);
            }
            args->argv[i] = tmp;
            args->argc = i + 1;
            return;
        }
    }
    for (; arg && arg->name; arg++, i++) {
        if (arg->default_value && i >= args->argc) {
            rz_cmd_parsed_args_addarg(args, arg->default_value);
        }
    }
}

References arg(), args, cd, free(), i, arg::name, RZ_CMD_ARG_FLAG_LAST, RZ_CMD_ARG_TYPE_CMD, rz_cmd_escape_arg(), RZ_CMD_ESCAPE_ONE_ARG, rz_cmd_parsed_args_addarg(), rz_str_array_join(), s, and autogen_x86imm::tmp.

Referenced by argv_call_cb().

argv_call_cb()

static RzCmdStatus argv_call_cb ( RzCmd *  cmd, RzCmdDesc *  cd, RzCmdParsedArgs *  args  )

static

Definition at line 704 of file cmd_api.c.

                                                                                  {
    if (!rz_cmd_desc_has_handler(cd)) {
        return RZ_CMD_STATUS_NONEXISTINGCMD;
    }
 
    args_preprocessing(cd, args);
 
    int i;
    const char *s;
    rz_cmd_parsed_args_foreach_arg(args, i, s) {
        RZ_LOG_DEBUG("processed parsed_arg %d: '%s'\n", i, s);
    }
 
    RzOutputMode mode;
    switch (cd->type) {
    case RZ_CMD_DESC_TYPE_ARGV:
        if (args->argc < cd->d.argv_data.min_argc || args->argc > cd->d.argv_data.max_argc) {
            return RZ_CMD_STATUS_WRONG_ARGS;
        }
        return cd->d.argv_data.cb(cmd->data, args->argc, (const char **)args->argv);
    case RZ_CMD_DESC_TYPE_ARGV_MODES:
        mode = cd_suffix2mode(cd, rz_cmd_parsed_args_cmd(args));
        if (!mode) {
            return RZ_CMD_STATUS_NONEXISTINGCMD;
        }
        if (args->argc < cd->d.argv_modes_data.min_argc || args->argc > cd->d.argv_modes_data.max_argc) {
            return RZ_CMD_STATUS_WRONG_ARGS;
        }
        return cd->d.argv_modes_data.cb(cmd->data, args->argc, (const char **)args->argv, mode);
    case RZ_CMD_DESC_TYPE_ARGV_STATE:
        mode = cd_suffix2mode(cd, rz_cmd_parsed_args_cmd(args));
        if (!mode) {
            return RZ_CMD_STATUS_NONEXISTINGCMD;
        }
        if (args->argc < cd->d.argv_state_data.min_argc || args->argc > cd->d.argv_state_data.max_argc) {
            return RZ_CMD_STATUS_WRONG_ARGS;
        }
        RzCmdStateOutput state;
        if (!rz_cmd_state_output_init(&state, mode)) {
            return RZ_CMD_STATUS_INVALID;
        }
        RzCmdStatus res = cd->d.argv_state_data.cb(cmd->data, args->argc, (const char **)args->argv, &state);
        if (args->extra && state.mode == RZ_OUTPUT_MODE_TABLE) {
            bool res = rz_table_query(state.d.t, args->extra);
            if (!res) {
                rz_cmd_state_output_fini(&state);
                return RZ_CMD_STATUS_INVALID;
            }
        }
        if (res == RZ_CMD_STATUS_OK) {
            rz_cmd_state_output_print(&state);
        }
        rz_cmd_state_output_fini(&state);
        return res;
    default:
        return RZ_CMD_STATUS_INVALID;
    }
}

References args, args_preprocessing(), cd, cd_suffix2mode(), cmd, i, rz_cmd_desc_has_handler(), RZ_CMD_DESC_TYPE_ARGV, RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, rz_cmd_parsed_args_cmd(), rz_cmd_state_output_fini(), rz_cmd_state_output_init(), rz_cmd_state_output_print(), RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_NONEXISTINGCMD, RZ_CMD_STATUS_OK, RZ_CMD_STATUS_WRONG_ARGS, RZ_LOG_DEBUG, RZ_OUTPUT_MODE_TABLE, rz_table_query(), and s.

Referenced by call_cd().

argv_get_help()

static char* argv_get_help ( RzCmd *  cmd, RzCmdDesc *  cd, size_t  detail, bool  use_color  )

static

Definition at line 1266 of file cmd_api.c.

                                                                                     {
    RzStrBuf *sb = rz_strbuf_new(NULL);
    const char *pal_reset = "";
    if (cmd->has_cons && use_color) {
        RzCons *cons = rz_cons_singleton();
        pal_reset = cons->context->pal.reset;
    }
 
    fill_usage_strbuf(cmd, sb, cd, use_color);
 
    if (cd->type == RZ_CMD_DESC_TYPE_ARGV_MODES || cd->type == RZ_CMD_DESC_TYPE_ARGV_STATE) {
        fill_argv_modes_help_strbuf(cmd, sb, cd, use_color);
    }
 
    switch (detail) {
    case 1:
    case 2:
        if (cd->help->description) {
            rz_strbuf_append(sb, "\n");
            fill_colored_args(cmd, sb, cd->help->description, use_color, pal_reset);
            rz_strbuf_append(sb, "\n");
        }
        fill_details(cmd, cd, sb, use_color);
        break;
    default:
        rz_strbuf_free(sb);
        return NULL;
    }
    return rz_strbuf_drain(sb);
}

References cd, cmd, rz_cons_t::context, fill_argv_modes_help_strbuf(), fill_colored_args(), fill_details(), fill_usage_strbuf(), NULL, rz_cons_context_t::pal, rz_cons_printable_palette_t::reset, RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, rz_cons_singleton(), rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_free(), rz_strbuf_new(), and sb.

Referenced by fake_get_help(), and get_help().

argv_modes_new()

static RzCmdDesc* argv_modes_new ( RzCmd *  cmd, RzCmdDesc *  parent, const char *  name, int  modes, RzCmdArgvModesCb  cb, const RzCmdDescHelp *  help, bool  ht_insert  )

static

Definition at line 2158 of file cmd_api.c.

                                                                                                                                                             {
    RzCmdDesc *res = create_cmd_desc(cmd, parent, RZ_CMD_DESC_TYPE_ARGV_MODES, name, help, ht_insert);
    if (!res) {
        return NULL;
    }
 
    res->d.argv_modes_data.cb = cb;
    res->d.argv_modes_data.modes = modes;
    res->d.argv_modes_data.default_mode = RZ_OUTPUT_MODE_STANDARD;
    get_minmax_argc(res, &res->d.argv_modes_data.min_argc, &res->d.argv_modes_data.max_argc);
    return res;
}

References rz_cmd_desc_t::argv_modes_data, cb, cmd, create_cmd_desc(), rz_cmd_desc_t::d, get_minmax_argc(), cmd_descs_generate::help, NULL, RZ_CMD_DESC_TYPE_ARGV_MODES, and RZ_OUTPUT_MODE_STANDARD.

Referenced by rz_cmd_desc_argv_modes_new(), and rz_cmd_desc_group_modes_new().

argv_new()

static RzCmdDesc* argv_new ( RzCmd *  cmd, RzCmdDesc *  parent, const char *  name, RzCmdArgvCb  cb, const RzCmdDescHelp *  help, bool  ht_insert  )

static

Definition at line 2142 of file cmd_api.c.

                                                                                                                                       {
    RzCmdDesc *res = create_cmd_desc(cmd, parent, RZ_CMD_DESC_TYPE_ARGV, name, help, ht_insert);
    if (!res) {
        return NULL;
    }
 
    res->d.argv_data.cb = cb;
    get_minmax_argc(res, &res->d.argv_data.min_argc, &res->d.argv_data.max_argc);
    return res;
}

References rz_cmd_desc_t::argv_data, cb, cmd, create_cmd_desc(), rz_cmd_desc_t::d, get_minmax_argc(), cmd_descs_generate::help, NULL, and RZ_CMD_DESC_TYPE_ARGV.

Referenced by rz_cmd_desc_argv_new(), and rz_cmd_desc_group_new().

argv_state_new()

static RzCmdDesc* argv_state_new ( RzCmd *  cmd, RzCmdDesc *  parent, const char *  name, int  modes, RzCmdArgvStateCb  cb, const RzCmdDescHelp *  help, bool  ht_insert  )

static

Definition at line 2171 of file cmd_api.c.

                                                                                                                                                             {
    RzCmdDesc *res = create_cmd_desc(cmd, parent, RZ_CMD_DESC_TYPE_ARGV_STATE, name, help, ht_insert);
    if (!res) {
        return NULL;
    }
 
    res->d.argv_state_data.cb = cb;
    res->d.argv_state_data.modes = modes;
    res->d.argv_state_data.default_mode = RZ_OUTPUT_MODE_STANDARD;
    get_minmax_argc(res, &res->d.argv_state_data.min_argc, &res->d.argv_state_data.max_argc);
    return res;
}

References rz_cmd_desc_t::argv_state_data, cb, cmd, create_cmd_desc(), rz_cmd_desc_t::d, get_minmax_argc(), cmd_descs_generate::help, NULL, RZ_CMD_DESC_TYPE_ARGV_STATE, and RZ_OUTPUT_MODE_STANDARD.

Referenced by rz_cmd_desc_argv_state_new(), and rz_cmd_desc_group_state_new().

calc_padding_len()

static size_t calc_padding_len ( const RzCmdDesc *  cd, const char *  name, bool  show_children  )

static

Definition at line 1051 of file cmd_api.c.

                                                                                          {
    size_t name_len = strlen(name);
    size_t args_len = 0;
    size_t children_length = 0;
    if (show_children && show_children_shortcut(cd)) {
        RzStrBuf sb;
        rz_strbuf_init(&sb);
        fill_children_chars(&sb, cd);
        children_length += rz_strbuf_length(&sb);
        rz_strbuf_fini(&sb);
    }
    if (cd->help->args_str) {
        args_len = strlen0(cd->help->args_str);
    } else {
        RzStrBuf sb;
        rz_strbuf_init(&sb);
        fill_args(&sb, cd);
        args_len = rz_strbuf_length(&sb);
        rz_strbuf_fini(&sb);
    }
    return name_len + args_len + children_length;
}

References cd, fill_args(), fill_children_chars(), rz_strbuf_fini(), rz_strbuf_init(), rz_strbuf_length(), sb, show_children_shortcut(), and strlen0().

Referenced by do_print_child_help(), and update_minmax_len().

call_cd()

static RzCmdStatus call_cd ( RzCmd *  cmd, RzCmdDesc *  cd, RzCmdParsedArgs *  args  )

static

Definition at line 763 of file cmd_api.c.

                                                                             {
    char *exec_string;
    RzCmdStatus res = RZ_CMD_STATUS_INVALID;
 
    int i;
    const char *s;
    rz_cmd_parsed_args_foreach_arg(args, i, s) {
        RZ_LOG_DEBUG("parsed_arg %d: '%s'\n", i, s);
    }
 
    switch (cd->type) {
    case RZ_CMD_DESC_TYPE_GROUP:
        if (!cd->d.group_data.exec_cd) {
            return RZ_CMD_STATUS_NONEXISTINGCMD;
        }
        return call_cd(cmd, cd->d.group_data.exec_cd, args);
    case RZ_CMD_DESC_TYPE_ARGV:
    case RZ_CMD_DESC_TYPE_ARGV_MODES:
    case RZ_CMD_DESC_TYPE_ARGV_STATE:
        return argv_call_cb(cmd, cd, args);
    case RZ_CMD_DESC_TYPE_OLDINPUT:
        exec_string = rz_cmd_parsed_args_execstr(args);
        res = int2cmdstatus(cd->d.oldinput_data.cb(cmd->data, exec_string + strlen(cd->name)));
        RZ_FREE(exec_string);
        return res;
    default:
        RZ_LOG_ERROR("RzCmdDesc type not handled\n");
        return RZ_CMD_STATUS_INVALID;
    }
}

References args, argv_call_cb(), cd, cmd, i, int2cmdstatus(), RZ_CMD_DESC_TYPE_ARGV, RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, RZ_CMD_DESC_TYPE_GROUP, RZ_CMD_DESC_TYPE_OLDINPUT, rz_cmd_parsed_args_execstr(), RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_NONEXISTINGCMD, RZ_FREE, RZ_LOG_DEBUG, RZ_LOG_ERROR, and s.

Referenced by rz_cmd_call_parsed_args().

cd_sort()

static int cd_sort ( const void *  a, const void *  b  )

static

Definition at line 100 of file cmd_api.c.

                                                 {
    RzCmdDesc *ca = (RzCmdDesc *)a;
    RzCmdDesc *cb = (RzCmdDesc *)b;
    return rz_str_casecmp(ca->name, cb->name);
}

References a, b, cb, rz_cmd_desc_t::name, and rz_str_casecmp().

Referenced by cmd_desc_set_parent(), and sort_groups().

cd_suffix2mode()

static RzOutputMode cd_suffix2mode ( RzCmdDesc *  cd, const char *  cmdid  )

static

Definition at line 640 of file cmd_api.c.

                                                                     {
    if (!has_cd_submodes(cd)) {
        return 0;
    }
    RzOutputMode mode = suffix2mode(cmdid + strlen(cd->name));
    if (mode == RZ_OUTPUT_MODE_STANDARD && has_cd_default_mode(cd)) {
        mode = get_cd_default_mode(cd);
    }
    return mode;
}

References cd, get_cd_default_mode(), has_cd_default_mode(), has_cd_submodes(), RZ_OUTPUT_MODE_STANDARD, and suffix2mode().

Referenced by argv_call_cb().

close_optionals()

static void close_optionals ( size_t *  n_optionals, RzStrBuf *  sb, size_t *  len  )

static

Definition at line 939 of file cmd_api.c.

                                                                            {
    for (; *n_optionals > 0; (*n_optionals)--) {
        rz_strbuf_append(sb, "]");
        (*len)++;
    }
}

References rz_strbuf_append(), and sb.

Referenced by fill_args().

cmd_desc_free()

static void cmd_desc_free ( RzCmdDesc *  cd )

static

Definition at line 151 of file cmd_api.c.

                                         {
    if (!cd) {
        return;
    }
 
    rz_pvector_clear(&cd->children);
    free(cd->name);
    free(cd);
}

References cd, free(), and rz_pvector_clear().

Referenced by create_cmd_desc(), rz_cmd_desc_remove(), and rz_cmd_free().

cmd_desc_remove_from_ht_cmds()

static void cmd_desc_remove_from_ht_cmds ( RzCmd *  cmd, RzCmdDesc *  cd  )

static

Definition at line 141 of file cmd_api.c.

                                                                    {
    void **it_cd;
    bool res = ht_pp_delete(cmd->ht_cmds, cd->name);
    rz_return_if_fail(res);
    rz_cmd_desc_children_foreach(cd, it_cd) {
        RzCmdDesc *child_cd = *it_cd;
        cmd_desc_remove_from_ht_cmds(cmd, child_cd);
    }
}

References cd, cmd, and rz_return_if_fail.

Referenced by rz_cmd_desc_remove().

cmd_desc_set_parent()

static bool cmd_desc_set_parent ( RzCmd *  cmd, RzCmdDesc *  cd, RzCmdDesc *  parent  )

static

Definition at line 106 of file cmd_api.c.

                                                                              {
    rz_return_val_if_fail(cd && !cd->parent, false);
    if (parent) {
        switch (parent->type) {
        case RZ_CMD_DESC_TYPE_OLDINPUT:
        case RZ_CMD_DESC_TYPE_GROUP:
        case RZ_CMD_DESC_TYPE_INNER:
            break;
        case RZ_CMD_DESC_TYPE_ARGV:
        case RZ_CMD_DESC_TYPE_ARGV_MODES:
        case RZ_CMD_DESC_TYPE_ARGV_STATE:
        case RZ_CMD_DESC_TYPE_FAKE:
            rz_warn_if_reached();
            return false;
        }
    }
    if (parent) {
        cd->parent = parent;
        rz_pvector_push(&parent->children, cd);
        if (!cmd->batch && parent->help->sort_subcommands) {
            rz_pvector_sort(&parent->children, cd_sort);
        }
        parent->n_children++;
    }
    return true;
}

References cd, cd_sort(), rz_cmd_desc_t::children, cmd, rz_cmd_desc_t::help, rz_cmd_desc_t::n_children, RZ_CMD_DESC_TYPE_ARGV, RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, RZ_CMD_DESC_TYPE_FAKE, RZ_CMD_DESC_TYPE_GROUP, RZ_CMD_DESC_TYPE_INNER, RZ_CMD_DESC_TYPE_OLDINPUT, rz_pvector_push(), rz_pvector_sort(), rz_return_val_if_fail, rz_warn_if_reached, rz_cmd_desc_help_t::sort_subcommands, and rz_cmd_desc_t::type.

Referenced by create_cmd_desc().

cmd_desc_unset_parent()

static void cmd_desc_unset_parent ( RzCmdDesc *  cd )

static

Definition at line 133 of file cmd_api.c.

                                                 {
    rz_return_if_fail(cd && cd->parent);
    RzCmdDesc *parent = cd->parent;
    rz_pvector_remove_data(&parent->children, cd);
    parent->n_children--;
    cd->parent = NULL;
}

References cd, rz_cmd_desc_t::children, rz_cmd_desc_t::n_children, NULL, rz_pvector_remove_data(), and rz_return_if_fail.

Referenced by rz_cmd_desc_remove().

cmd_foreach_cmdname()

static void cmd_foreach_cmdname ( RzCmd *  cmd, RzCmdDesc *  cd, RzCmdForeachNameCb  cb, void *  user  )

static

Definition at line 2427 of file cmd_api.c.

                                                                                              {
    if (!cd) {
        return;
    }
 
    void **it_cd;
 
    switch (cd->type) {
    case RZ_CMD_DESC_TYPE_ARGV:
        if (rz_cmd_desc_has_handler(cd)) {
            cb(cmd, cd, user);
        }
        break;
    case RZ_CMD_DESC_TYPE_ARGV_STATE:
        cmd_foreach_cmdname_modes(cmd, cd, cd->d.argv_state_data.modes, cb, user);
        break;
    case RZ_CMD_DESC_TYPE_ARGV_MODES:
        cmd_foreach_cmdname_modes(cmd, cd, cd->d.argv_modes_data.modes, cb, user);
        break;
    case RZ_CMD_DESC_TYPE_FAKE:
        break;
    case RZ_CMD_DESC_TYPE_OLDINPUT:
        if (rz_cmd_desc_has_handler(cd)) {
            cb(cmd, cd, user);
        }
        // fallthrough
    case RZ_CMD_DESC_TYPE_INNER:
    case RZ_CMD_DESC_TYPE_GROUP:
        rz_cmd_desc_children_foreach(cd, it_cd) {
            RzCmdDesc *child = *it_cd;
            cmd_foreach_cmdname(cmd, child, cb, user);
        }
        break;
    }
}

References cb, cd, cmd, cmd_foreach_cmdname_modes(), rz_cmd_desc_has_handler(), RZ_CMD_DESC_TYPE_ARGV, RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, RZ_CMD_DESC_TYPE_FAKE, RZ_CMD_DESC_TYPE_GROUP, RZ_CMD_DESC_TYPE_INNER, and RZ_CMD_DESC_TYPE_OLDINPUT.

Referenced by rz_cmd_foreach_cmdname().

cmd_foreach_cmdname_modes()

static void cmd_foreach_cmdname_modes ( RzCmd *  cmd, RzCmdDesc *  cd, int  modes, RzCmdForeachNameCb  cb, void *  user  )

static

Definition at line 2406 of file cmd_api.c.

                                                                                                               {
    size_t i;
    for (i = 0; i < RZ_ARRAY_SIZE(argv_modes); i++) {
        if (modes & argv_modes[i].mode) {
            RzCmdDescHelp mode_help;
            const RzCmdDescHelp *copy = cd->help;
            cd->help = mode_cmd_desc_help(&mode_help, copy, argv_modes[i].summary_suffix);
 
            char *name = cd->name;
            cd->name = rz_str_newf("%s%s", name, argv_modes[i].suffix);
 
            cb(cmd, cd, user);
 
            free(cd->name);
            free((char *)mode_help.summary);
            cd->name = name;
            cd->help = copy;
        }
    }
}

References argv_modes, cb, cd, cmd, free(), i, mode_cmd_desc_help(), name, RZ_ARRAY_SIZE, rz_str_newf(), suffix, and rz_cmd_desc_help_t::summary.

Referenced by cmd_foreach_cmdname().

cmd_get_desc_best()

static RzCmdDesc* cmd_get_desc_best ( RzCmd *  cmd, const char *  cmd_identifier, bool  best_match  )

static

Definition at line 303 of file cmd_api.c.

                                                                                             {
    rz_return_val_if_fail(cmd && cmd_identifier, NULL);
    char *cmdid = strdup(cmd_identifier);
    char *end_cmdid = cmdid + strlen(cmdid);
    RzCmdDesc *res = NULL;
    bool is_exact_match = true;
    char last_letter = '\0', o_last_letter = end_cmdid > cmdid ? *(end_cmdid - 1) : '\0';
    // match longer commands first
    while (*cmdid) {
        RzCmdDesc *cd = ht_pp_find(cmd->ht_cmds, cmdid, NULL);
        if (cd) {
            switch (cd->type) {
            case RZ_CMD_DESC_TYPE_ARGV:
            case RZ_CMD_DESC_TYPE_GROUP:
            case RZ_CMD_DESC_TYPE_FAKE:
            case RZ_CMD_DESC_TYPE_ARGV_MODES:
            case RZ_CMD_DESC_TYPE_ARGV_STATE:
                if (!best_match && (!is_exact_match && !is_valid_argv_modes(rz_cmd_desc_get_exec(cd), last_letter))) {
                    break;
                }
                res = cd;
                goto out;
            case RZ_CMD_DESC_TYPE_OLDINPUT:
                res = cd;
                goto out;
            case RZ_CMD_DESC_TYPE_INNER:
                break;
            }
        }
        // only the last letter is considered, then we zero last_letter
        last_letter = o_last_letter;
        o_last_letter = '\0';
 
        is_exact_match = false;
        *(--end_cmdid) = '\0';
    }
out:
    free(cmdid);
    return res;
}

References cd, cmd, free(), is_valid_argv_modes(), NULL, out, rz_cmd_desc_get_exec(), RZ_CMD_DESC_TYPE_ARGV, RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, RZ_CMD_DESC_TYPE_FAKE, RZ_CMD_DESC_TYPE_GROUP, RZ_CMD_DESC_TYPE_INNER, RZ_CMD_DESC_TYPE_OLDINPUT, rz_return_val_if_fail, and strdup().

Referenced by rz_cmd_get_desc(), and rz_cmd_get_desc_best().

create_cmd_desc()

static RzCmdDesc* create_cmd_desc ( RzCmd *  cmd, RzCmdDesc *  parent, RzCmdDescType  type, const char *  name, const RzCmdDescHelp *  help, bool  ht_insert  )

static

Definition at line 161 of file cmd_api.c.

                                                                                                                                                  {
    RzCmdDesc *res = RZ_NEW0(RzCmdDesc);
    if (!res) {
        return NULL;
    }
    res->type = type;
    res->name = strdup(name);
    if (!res->name) {
        goto err;
    }
    res->n_children = 0;
    res->help = help ? help : &not_defined_help;
    rz_pvector_init(&res->children, (RzPVectorFree)cmd_desc_free);
    if (ht_insert && !ht_pp_insert(cmd->ht_cmds, name, res)) {
        goto err;
    }
    cmd_desc_set_parent(cmd, res, parent);
    return res;
err:
    cmd_desc_free(res);
    return NULL;
}

References rz_cmd_desc_t::children, cmd, cmd_desc_free(), cmd_desc_set_parent(), err, cmd_descs_generate::help, rz_cmd_desc_t::help, rz_cmd_desc_t::n_children, rz_cmd_desc_t::name, not_defined_help, NULL, RZ_NEW0, rz_pvector_init(), strdup(), type, and rz_cmd_desc_t::type.

Referenced by argv_modes_new(), argv_new(), argv_state_new(), rz_cmd_desc_fake_new(), rz_cmd_desc_group_modes_new(), rz_cmd_desc_group_new(), rz_cmd_desc_group_state_new(), rz_cmd_desc_inner_new(), rz_cmd_desc_oldinput_new(), and rz_cmd_new().

do_print_child_help()

static void do_print_child_help ( RzCmd *  cmd, RzStrBuf *  sb, const RzCmdDesc *  cd, const char *  name, const char *  summary, bool  show_children, size_t  max_len, bool  use_color  )

static

Definition at line 1080 of file cmd_api.c.

                                                                                                                                                                          {
    size_t str_len = calc_padding_len(cd, name, show_children);
    int padding = str_len < max_len ? max_len - str_len : 0;
    const char *pal_args_color = "",
           *pal_opt_color = "",
           *pal_help_color = "",
           *pal_input_color = "",
           *pal_reset = "";
 
    if (cmd->has_cons && use_color) {
        RzCons *cons = rz_cons_singleton();
        pal_args_color = cons->context->pal.args;
        pal_opt_color = cons->context->pal.reset;
        pal_help_color = cons->context->pal.help;
        pal_input_color = cons->context->pal.input;
        pal_reset = cons->context->pal.reset;
    }
 
    size_t columns = 0;
    columns += strbuf_append_calc(sb, "| ");
    rz_strbuf_append(sb, pal_input_color);
    columns += strbuf_append_calc(sb, name);
    if (show_children && show_children_shortcut(cd)) {
        rz_strbuf_append(sb, pal_opt_color);
        columns += fill_children_chars(sb, cd);
    }
    rz_strbuf_append(sb, pal_args_color);
    if (cd->help->args_str) {
        columns += strbuf_append_calc(sb, cd->help->args_str);
    } else {
        columns += fill_args(sb, cd);
    }
    rz_strbuf_appendf(sb, " %*s", padding, "");
    columns += padding + 1;
    rz_strbuf_append(sb, pal_help_color);
 
    fill_wrapped_comment(cmd, sb, summary, columns, use_color);
    rz_strbuf_appendf(sb, "%s\n", pal_reset);
}

References rz_cons_printable_palette_t::args, calc_padding_len(), cd, cmd, rz_cons_t::context, fill_args(), fill_children_chars(), fill_wrapped_comment(), rz_cons_printable_palette_t::help, rz_cons_printable_palette_t::input, rz_cons_context_t::pal, rz_cons_printable_palette_t::reset, rz_cons_singleton(), rz_strbuf_append(), rz_strbuf_appendf(), sb, show_children_shortcut(), strbuf_append_calc(), and summary.

Referenced by fill_argv_modes_help_strbuf(), print_child_help(), and rz_cmd_get_help_strbuf().

escape_special_chars()

static char* escape_special_chars ( const char *  s, const char *  special_chars  )

static

Definition at line 2479 of file cmd_api.c.

                                                                            {
    size_t s_len = strlen(s);
    char *d = RZ_NEWS(char, s_len * 2 + 1);
    int i, j = 0;
    for (i = 0; i < s_len; i++) {
        if (strchr(special_chars, s[i])) {
            d[j++] = '\\';
        }
        d[j++] = s[i];
    }
    d[j++] = '\0';
    return d;
}

References d, i, RZ_NEWS, and s.

Referenced by rz_cmd_escape_arg().

fake_get_help()

static char* fake_get_help ( RzCmd *  cmd, RzCmdDesc *  cd, bool  use_color  )

static

Definition at line 1297 of file cmd_api.c.

                                                                      {
    // abuse detail=2 of the argv help as they show essentially the same info
    return argv_get_help(cmd, cd, 2, use_color);
}

References argv_get_help(), cd, and cmd.

Referenced by get_help().

fill_args()

static size_t fill_args ( RzStrBuf *  sb, const RzCmdDesc *  cd  )

static

Definition at line 946 of file cmd_api.c.

                                                           {
    const RzCmdDescArg *arg;
    size_t n_optionals = 0;
    size_t len = 0;
    bool has_array = false;
    for (arg = cd->help->args; arg && arg->name; arg++) {
        if (arg->type == RZ_CMD_ARG_TYPE_FAKE) {
            if (!arg->optional) {
                // Assume arg is a closing bracket
                close_optionals(&n_optionals, sb, &len);
            }
            rz_strbuf_append(sb, arg->name);
            len += strlen(arg->name);
            continue;
        }
 
        if (has_array) {
            rz_warn_if_reached();
            break;
        }
        if (!arg->no_space) {
            rz_strbuf_append(sb, " ");
            len++;
        }
        if (arg->optional) {
            rz_strbuf_append(sb, "[");
            len++;
            n_optionals++;
        }
        if (arg->flags & RZ_CMD_ARG_FLAG_ARRAY) {
            has_array = true;
            rz_strbuf_appendf(sb, "<%s1>", arg->name);
            len += strlen(arg->name) + 3;
            rz_strbuf_appendf(sb, " <%s2> ...", arg->name);
            len += strlen(arg->name) + 8;
        } else if (arg->flags & RZ_CMD_ARG_FLAG_OPTION) {
            rz_strbuf_appendf(sb, "-%s", arg->name);
            len += strlen(arg->name) + 1;
        } else {
            rz_strbuf_appendf(sb, "<%s>", arg->name);
            len += strlen(arg->name) + 2;
            if (arg->default_value) {
                rz_strbuf_appendf(sb, "=%s", arg->default_value);
                len += strlen(arg->default_value) + 1;
            }
        }
    }
    close_optionals(&n_optionals, sb, &len);
    return len;
}

References arg(), cd, close_optionals(), len, arg::name, RZ_CMD_ARG_FLAG_ARRAY, RZ_CMD_ARG_FLAG_OPTION, RZ_CMD_ARG_TYPE_FAKE, rz_strbuf_append(), rz_strbuf_appendf(), rz_warn_if_reached, and sb.

Referenced by calc_padding_len(), do_print_child_help(), fill_usage_strbuf(), and rz_cmd_get_help_json().

fill_args_json()

static void fill_args_json ( const RzCmd *  cmd, const RzCmdDesc *  cd, PJ *  j  )

static

Definition at line 1353 of file cmd_api.c.

                                                                         {
    const RzCmdDescArg *arg;
    bool has_array = false;
    pj_ka(j, "args");
    const char *argtype = NULL;
    for (arg = cd->help->args; arg && arg->name; arg++) {
        if (has_array) {
            rz_warn_if_reached();
            break;
        }
        pj_o(j);
#define CASE_TYPE(x, y) \
    case (x): \
        argtype = (y); \
        break
        switch (arg->type) {
            CASE_TYPE(RZ_CMD_ARG_TYPE_FAKE, "fake");
            CASE_TYPE(RZ_CMD_ARG_TYPE_NUM, "number");
            CASE_TYPE(RZ_CMD_ARG_TYPE_RZNUM, "expression");
            CASE_TYPE(RZ_CMD_ARG_TYPE_STRING, "string");
            CASE_TYPE(RZ_CMD_ARG_TYPE_ENV, "environment_variable");
            CASE_TYPE(RZ_CMD_ARG_TYPE_CHOICES, "choice");
            CASE_TYPE(RZ_CMD_ARG_TYPE_FCN, "function");
            CASE_TYPE(RZ_CMD_ARG_TYPE_FILE, "filename");
            CASE_TYPE(RZ_CMD_ARG_TYPE_OPTION, "option");
            CASE_TYPE(RZ_CMD_ARG_TYPE_CMD, "command");
            CASE_TYPE(RZ_CMD_ARG_TYPE_MACRO, "macro");
            CASE_TYPE(RZ_CMD_ARG_TYPE_EVAL_KEY, "evaluable");
            CASE_TYPE(RZ_CMD_ARG_TYPE_EVAL_FULL, "evaluable_full");
#undef CASE_TYPE
        default:
            argtype = "unknown";
            break;
        }
        pj_ks(j, "type", argtype);
        pj_ks(j, "name", arg->name);
        if (arg->type == RZ_CMD_ARG_TYPE_FAKE) {
            pj_end(j);
            continue;
        }
        if (arg->no_space) {
            pj_kb(j, "nospace", true);
        }
        if (!arg->optional) {
            pj_kb(j, "required", true);
        }
        if (arg->flags & RZ_CMD_ARG_FLAG_LAST) {
            pj_kb(j, "is_last", true);
        }
        if (arg->flags & RZ_CMD_ARG_FLAG_ARRAY) {
            pj_kb(j, "is_array", true);
        }
        if (arg->flags & RZ_CMD_ARG_FLAG_OPTION) {
            pj_kb(j, "is_option", true);
        }
        if (arg->default_value) {
            pj_ks(j, "default", arg->default_value);
        }
        if (arg->type == RZ_CMD_ARG_TYPE_CHOICES) {
            pj_ka(j, "choices");
            char **ochoice = arg->choices_cb ? arg->choices_cb(cmd->data) : (char **)arg->choices;
            for (char **choice = ochoice; *choice; choice++) {
                pj_s(j, *choice);
            }
            pj_end(j);
            if (arg->choices_cb) {
                for (char **choice = ochoice; *choice; choice++) {
                    free(*choice);
                }
                free(ochoice);
            }
        }
        pj_end(j);
    }
    pj_end(j);
}

References arg(), CASE_TYPE, cd, cmd, free(), arg::name, NULL, pj_end(), pj_ka(), pj_kb(), pj_ks(), pj_o(), pj_s(), RZ_CMD_ARG_FLAG_ARRAY, RZ_CMD_ARG_FLAG_LAST, RZ_CMD_ARG_FLAG_OPTION, RZ_CMD_ARG_TYPE_CHOICES, RZ_CMD_ARG_TYPE_CMD, RZ_CMD_ARG_TYPE_ENV, RZ_CMD_ARG_TYPE_EVAL_FULL, RZ_CMD_ARG_TYPE_EVAL_KEY, RZ_CMD_ARG_TYPE_FAKE, RZ_CMD_ARG_TYPE_FCN, RZ_CMD_ARG_TYPE_FILE, RZ_CMD_ARG_TYPE_MACRO, RZ_CMD_ARG_TYPE_NUM, RZ_CMD_ARG_TYPE_OPTION, RZ_CMD_ARG_TYPE_RZNUM, RZ_CMD_ARG_TYPE_STRING, and rz_warn_if_reached.

Referenced by rz_cmd_get_help_json().

fill_argv_modes_help_strbuf()

static void fill_argv_modes_help_strbuf ( RzCmd *  cmd, RzStrBuf *  sb, RzCmdDesc *  cd, bool  use_color  )

static

Definition at line 1148 of file cmd_api.c.

                                                                                                 {
    size_t max_len = 0, min_len = SIZE_MAX;
    update_minmax_len(cd, &max_len, &min_len, true);
    max_len++; // consider the suffix letter
    if (max_len - min_len > MAX_RIGHT_ALIGHNMENT) {
        max_len = min_len + MAX_RIGHT_ALIGHNMENT;
    }
 
    size_t i;
    for (i = 0; i < RZ_ARRAY_SIZE(argv_modes); i++) {
        if (cd->d.argv_modes_data.modes & argv_modes[i].mode) {
            char *name = rz_str_newf("%s%s", cd->name, argv_modes[i].suffix);
            char *summary = rz_str_newf("%s%s", cd->help->summary, argv_modes[i].summary_suffix);
            do_print_child_help(cmd, sb, cd, name, summary, false, max_len, use_color);
            free(name);
            free(summary);
        }
    }
}

References argv_modes, cd, cmd, do_print_child_help(), free(), i, MAX_RIGHT_ALIGHNMENT, argv_modes_t::mode, RZ_ARRAY_SIZE, rz_str_newf(), sb, SIZE_MAX, argv_modes_t::suffix, summary, argv_modes_t::summary_suffix, and update_minmax_len().

Referenced by argv_get_help().

fill_children_chars()

static size_t fill_children_chars ( RzStrBuf *  sb, const RzCmdDesc *  cd  )

static

Definition at line 823 of file cmd_api.c.

                                                                     {
    if (cd->help->options) {
        return strbuf_append_calc(sb, cd->help->options);
    }
 
    RzStrBuf csb;
    rz_strbuf_init(&csb);
 
    void **it;
    bool has_other_commands = false;
    const RzCmdDesc *exec_cd = rz_cmd_desc_get_exec((RzCmdDesc *)cd);
    if (exec_cd) {
        switch (exec_cd->type) {
        case RZ_CMD_DESC_TYPE_ARGV_MODES:
        case RZ_CMD_DESC_TYPE_ARGV_STATE:
            fill_modes_children_chars(&csb, exec_cd);
            break;
        default:
            break;
        }
    }
    rz_cmd_desc_children_foreach(cd, it) {
        RzCmdDesc *child = *(RzCmdDesc **)it;
        if (rz_str_startswith(child->name, cd->name) && strlen(child->name) == strlen(cd->name) + 1) {
            rz_strbuf_appendf(&csb, "%c", child->name[strlen(cd->name)]);
        } else if (strcmp(child->name, cd->name)) {
            has_other_commands = true;
        }
    }
 
    if (rz_strbuf_is_empty(&csb) || rz_strbuf_length(&csb) >= MAX_CHILDREN_SHOW) {
        rz_strbuf_fini(&csb);
        rz_strbuf_set(&csb, "?");
        has_other_commands = false;
    }
 
    if (has_other_commands) {
        rz_strbuf_append(&csb, "?");
    }
 
    if (!cd->n_children || rz_cmd_desc_has_handler(cd)) {
        rz_strbuf_prepend(&csb, "[");
        rz_strbuf_append(&csb, "]");
    } else {
        rz_strbuf_prepend(&csb, "<");
        rz_strbuf_append(&csb, ">");
    }
    size_t res = rz_strbuf_length(&csb);
    char *s = rz_strbuf_drain_nofree(&csb);
    rz_strbuf_append(sb, s);
    free(s);
    return res;
}

References cd, fill_modes_children_chars(), free(), MAX_CHILDREN_SHOW, rz_cmd_desc_t::name, rz_cmd_desc_get_exec(), rz_cmd_desc_has_handler(), RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, rz_str_startswith(), rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_drain_nofree(), rz_strbuf_fini(), rz_strbuf_init(), rz_strbuf_is_empty(), rz_strbuf_length(), rz_strbuf_prepend(), rz_strbuf_set(), s, sb, strbuf_append_calc(), and rz_cmd_desc_t::type.

Referenced by calc_padding_len(), do_print_child_help(), and fill_usage_strbuf().

fill_colored_args()

static void fill_colored_args ( RzCmd *  cmd, RzStrBuf *  sb, const char *  line, bool  use_color, const char *  reset_color  )

static

Definition at line 882 of file cmd_api.c.

                                                                                                                   {
    const char *pal_args_color = "";
    if (cmd->has_cons && use_color) {
        RzCons *cons = rz_cons_singleton();
        pal_args_color = cons->context->pal.args;
    }
 
    while (line) {
        const char *close_arg = NULL;
        const char *open_arg = strchr(line, '<');
        if (!open_arg) {
            break;
        }
        close_arg = strchr(open_arg, '>');
        if (!close_arg) {
            break;
        }
        rz_strbuf_appendf(sb, "%.*s%s", (int)(open_arg - line), line, pal_args_color);
        rz_strbuf_appendf(sb, "%.*s%s", (int)(close_arg - open_arg + 1), open_arg, reset_color);
        line = close_arg + 1;
    }
    rz_strbuf_append(sb, line);
}

References rz_cons_printable_palette_t::args, cmd, rz_cons_t::context, setup::line, NULL, rz_cons_context_t::pal, rz_cons_singleton(), rz_strbuf_append(), rz_strbuf_appendf(), and sb.

Referenced by argv_get_help(), and fill_wrapped_comment().

fill_details()

static void fill_details ( RzCmd *  cmd, RzCmdDesc *  cd, RzStrBuf *  sb, bool  use_color  )

static

Definition at line 1261 of file cmd_api.c.

                                                                                  {
    fill_details_static(cmd, cd, sb, use_color);
    fill_details_cb(cmd, cd, sb, use_color);
}

References cd, cmd, fill_details_cb(), fill_details_static(), and sb.

Referenced by argv_get_help(), and group_get_help().

fill_details_cb()

static void fill_details_cb ( RzCmd *  cmd, RzCmdDesc *  cd, RzStrBuf *  sb, bool  use_color  )

static

Definition at line 1252 of file cmd_api.c.

                                                                                     {
    RzCmdDescDetail *detail_it = get_cd_details_cb(cmd, cd);
    if (!detail_it) {
        return;
    }
    fill_details_do(cmd, detail_it, sb, use_color);
    rz_cmd_desc_details_free(detail_it);
}

References cd, cmd, fill_details_do(), get_cd_details_cb(), rz_cmd_desc_details_free(), and sb.

Referenced by fill_details().

fill_details_do()

static void fill_details_do ( RzCmd *  cmd, const RzCmdDescDetail *  detail_it, RzStrBuf *  sb, bool  use_color  )

static

Definition at line 1189 of file cmd_api.c.

                                                                                                        {
    const char *pal_help_color = "",
           *pal_input_color = "",
           *pal_label_color = "",
           *pal_args_color = "",
           *pal_reset = "";
    if (cmd->has_cons && use_color) {
        RzCons *cons = rz_cons_singleton();
        pal_help_color = cons->context->pal.help;
        pal_input_color = cons->context->pal.input;
        pal_label_color = cons->context->pal.label;
        pal_args_color = cons->context->pal.args;
        pal_reset = cons->context->pal.reset;
    }
 
    while (detail_it->name) {
        if (!RZ_STR_ISEMPTY(detail_it->name)) {
            rz_strbuf_appendf(sb, "\n%s%s:%s\n", pal_label_color, detail_it->name, pal_reset);
        }
        const RzCmdDescDetailEntry *entry_it = detail_it->entries;
        size_t max_len = 0, min_len = SIZE_MAX;
        while (entry_it && entry_it->text) {
            size_t len = strlen(entry_it->text) + strlen0(entry_it->arg_str);
            if (max_len < len) {
                max_len = len;
            }
            if (min_len > len) {
                min_len = len;
            }
            entry_it++;
        }
        if (max_len - min_len > MAX_RIGHT_ALIGHNMENT) {
            max_len = min_len + MAX_RIGHT_ALIGHNMENT;
        }
 
        entry_it = detail_it->entries;
        while (entry_it && entry_it->text) {
            size_t len = strlen(entry_it->text) + strlen0(entry_it->arg_str);
            int padding = len < max_len ? max_len - len : 0;
            const char *arg_str = entry_it->arg_str ? entry_it->arg_str : "";
            rz_strbuf_appendf(sb, "| %s%s%s%s %*s%s",
                pal_input_color, entry_it->text,
                pal_args_color, arg_str,
                padding, "",
                pal_help_color);
            size_t columns = strlen("| ") + strlen(entry_it->text) +
                strlen(" ") + strlen(arg_str) + padding;
            fill_wrapped_comment(cmd, sb, entry_it->comment, columns, use_color);
            rz_strbuf_appendf(sb, "%s\n", pal_reset);
            entry_it++;
        }
        detail_it++;
    }
}

References rz_cmd_desc_detail_entry_t::arg_str, rz_cons_printable_palette_t::args, cmd, rz_cmd_desc_detail_entry_t::comment, rz_cons_t::context, rz_cmd_desc_detail_t::entries, fill_wrapped_comment(), rz_cons_printable_palette_t::help, rz_cons_printable_palette_t::input, rz_cons_printable_palette_t::label, len, MAX_RIGHT_ALIGHNMENT, rz_cmd_desc_detail_t::name, rz_cons_context_t::pal, rz_cons_printable_palette_t::reset, rz_cons_singleton(), RZ_STR_ISEMPTY, rz_strbuf_appendf(), sb, SIZE_MAX, strlen0(), and rz_cmd_desc_detail_entry_t::text.

Referenced by fill_details_cb(), and fill_details_static().

fill_details_static()

static void fill_details_static ( RzCmd *  cmd, RzCmdDesc *  cd, RzStrBuf *  sb, bool  use_color  )

static

Definition at line 1244 of file cmd_api.c.

                                                                                         {
    const RzCmdDescDetail *detail_it = get_cd_details(cd);
    if (!detail_it) {
        return;
    }
    fill_details_do(cmd, detail_it, sb, use_color);
}

References cd, cmd, fill_details_do(), get_cd_details(), and sb.

Referenced by fill_details().

fill_modes_children_chars()

static void fill_modes_children_chars ( RzStrBuf *  sb, const RzCmdDesc *  cd  )

static

Definition at line 812 of file cmd_api.c.

                                                                         {
    // RZ_CMD_DESC_TYPE_ARGV_MODES does not have actual children for
    // the output modes, so we consider it separately
    size_t i;
    for (i = 0; i < RZ_ARRAY_SIZE(argv_modes); i++) {
        if (cd->d.argv_modes_data.modes & argv_modes[i].mode) {
            rz_strbuf_append(sb, argv_modes[i].suffix);
        }
    }
}

References argv_modes, cd, i, argv_modes_t::mode, RZ_ARRAY_SIZE, rz_strbuf_append(), sb, and suffix.

Referenced by fill_children_chars().

fill_usage_strbuf()

static void fill_usage_strbuf ( RzCmd *  cmd, RzStrBuf *  sb, RzCmdDesc *  cd, bool  use_color  )

static

Definition at line 997 of file cmd_api.c.

                                                                                       {
    const char *pal_label_color = "",
           *pal_args_color = "",
           *pal_input_color = "",
           *pal_help_color = "",
           *pal_reset = "";
 
    if (cmd->has_cons && use_color) {
        RzCons *cons = rz_cons_singleton();
        pal_label_color = cons->context->pal.label;
        pal_args_color = cons->context->pal.args;
        pal_input_color = cons->context->pal.input;
        pal_help_color = cons->context->pal.help;
        pal_reset = cons->context->pal.reset;
    }
 
    size_t columns = 0;
    rz_strbuf_append(sb, pal_label_color);
    columns += strbuf_append_calc(sb, "Usage: ");
    rz_strbuf_append(sb, pal_reset);
    if (cd->help->usage) {
        columns += strbuf_append_calc(sb, cd->help->usage);
        rz_strbuf_append(sb, pal_reset);
    } else {
        rz_strbuf_append(sb, pal_input_color);
        columns += strbuf_append_calc(sb, cd->name);
        if (show_children_shortcut(cd)) {
            rz_strbuf_append(sb, pal_reset);
            columns += fill_children_chars(sb, cd);
        }
        rz_strbuf_append(sb, pal_args_color);
        if (cd->help->args_str) {
            columns += strbuf_append_calc(sb, cd->help->args_str);
        } else {
            columns += fill_args(sb, cd);
        }
        rz_strbuf_append(sb, pal_reset);
    }
    if (cd->help->summary) {
        RzStrBuf *summary_sb = rz_strbuf_new(cd->help->summary);
        if (summary_sb) {
            columns += strbuf_append_calc(sb, "   ");
            rz_strbuf_append(sb, pal_help_color);
            if (has_cd_default_mode(cd)) {
                rz_strbuf_appendf(summary_sb, "%s", rz_output_mode_to_summary(get_cd_default_mode(cd)));
            }
            fill_wrapped_comment(cmd, sb, rz_strbuf_get(summary_sb), columns, use_color);
            rz_strbuf_append(sb, pal_reset);
            rz_strbuf_free(summary_sb);
        }
    }
    rz_strbuf_append(sb, "\n");
}

References rz_cons_printable_palette_t::args, cd, cmd, rz_cons_t::context, fill_args(), fill_children_chars(), fill_wrapped_comment(), get_cd_default_mode(), has_cd_default_mode(), rz_cons_printable_palette_t::help, rz_cons_printable_palette_t::input, rz_cons_printable_palette_t::label, rz_cons_context_t::pal, rz_cons_printable_palette_t::reset, rz_cons_singleton(), rz_output_mode_to_summary(), rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_free(), rz_strbuf_get(), rz_strbuf_new(), sb, show_children_shortcut(), and strbuf_append_calc().

Referenced by argv_get_help(), and group_get_help().

fill_wrapped_comment()

static void fill_wrapped_comment ( RzCmd *  cmd, RzStrBuf *  sb, const char *  comment, size_t  columns, bool  use_color  )

static

Definition at line 906 of file cmd_api.c.

                                                                                                                {
    int rows, cols;
    bool is_interactive = false;
    const char *help_color = "";
    if (cmd->has_cons) {
        RzCons *cons = rz_cons_singleton();
        cols = rz_cons_get_size(&rows);
        is_interactive = rz_cons_is_interactive();
        help_color = use_color ? cons->context->pal.help : "";
    }
    if (is_interactive && cols > 0 && cols - columns > MIN_SUMMARY_WIDTH && !RZ_STR_ISEMPTY(comment)) {
        char *text = strdup(comment);
        RzList *wrapped_text = rz_str_wrap(text, cols - columns - 2);
        RzListIter *it;
        const char *line;
        bool first = true;
        rz_list_foreach (wrapped_text, it, line) {
            if (!first) {
                rz_strbuf_appendf(sb, "\n%*s", (int)(columns + 2), "");
            } else {
                rz_strbuf_append(sb, "# ");
                first = false;
            }
 
            fill_colored_args(cmd, sb, line, use_color, help_color);
        }
        rz_list_free(wrapped_text);
        free(text);
    } else if (!RZ_STR_ISEMPTY(comment)) {
        rz_strbuf_appendf(sb, "# %s", comment);
    }
}

References cmd, rz_cons_t::context, fill_colored_args(), free(), rz_cons_printable_palette_t::help, setup::line, MIN_SUMMARY_WIDTH, rz_cons_context_t::pal, rz_cons_get_size(), rz_cons_is_interactive(), rz_cons_singleton(), rz_list_free(), RZ_STR_ISEMPTY, rz_str_wrap(), rz_strbuf_append(), rz_strbuf_appendf(), sb, strdup(), and create_tags_rz::text.

Referenced by do_print_child_help(), fill_details_do(), and fill_usage_strbuf().

free_array()

static void free_array ( char **  arr, int  n  )

static

Definition at line 2049 of file cmd_api.c.

                                          {
    int i;
    for (i = 0; i < n; i++) {
        free(arr[i]);
    }
    free(arr);
}

References syscall_preprocessing::arr, free(), i, and n.

Referenced by rz_cmd_parsed_args_setargs().

get_cd_default_mode()

static RzOutputMode get_cd_default_mode ( RzCmdDesc *  cd )

static

Definition at line 625 of file cmd_api.c.

                                                       {
    switch (cd->type) {
    case RZ_CMD_DESC_TYPE_ARGV_MODES:
        return cd->d.argv_modes_data.default_mode;
    case RZ_CMD_DESC_TYPE_ARGV_STATE:
        return cd->d.argv_state_data.default_mode;
    default:
        return RZ_OUTPUT_MODE_STANDARD;
    }
}

References cd, RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, and RZ_OUTPUT_MODE_STANDARD.

Referenced by cd_suffix2mode(), fill_usage_strbuf(), and has_cd_default_mode().

get_cd_details()

static const RzCmdDescDetail* get_cd_details ( RzCmdDesc *  cd )

static

Definition at line 1168 of file cmd_api.c.

                                                            {
    do {
        if (cd->help->details) {
            return cd->help->details;
        }
        cd = cd->parent;
    } while (cd);
    return NULL;
}

References cd, and NULL.

Referenced by fill_details_static().

get_cd_details_cb()

static RzCmdDescDetail* get_cd_details_cb ( RzCmd *  cmd, RzCmdDesc *  cd  )

static

Definition at line 1178 of file cmd_api.c.

                                                                     {
    do {
        if (cd->help->details || cd->help->details_cb) {
            const char *argv[] = { cd->name, NULL };
            return cd->help->details_cb ? cd->help->details_cb(cmd->data, 1, argv) : NULL;
        }
        cd = cd->parent;
    } while (cd);
    return NULL;
}

References argv, cd, cmd, and NULL.

Referenced by fill_details_cb().

get_help()

static char* get_help ( RzCmd *  cmd, RzCmdDesc *  cd, const char *  cmdid, RzCmdParsedArgs *  args, bool  use_color, size_t  detail  )

static

Definition at line 1324 of file cmd_api.c.

                                                                                                                          {
    switch (cd->type) {
    case RZ_CMD_DESC_TYPE_GROUP:
        if (cd->d.group_data.exec_cd && (detail > 1 || (detail == 1 && strcmp(cmdid, cd->name)))) {
            return get_help(cmd, cd->d.group_data.exec_cd, cmdid, args, use_color, detail);
        }
        if (detail == 1) {
            // show the group help only when doing <cmd>?
            return group_get_help(cmd, cd, use_color);
        }
        return argv_get_help(cmd, cd, detail, use_color);
    case RZ_CMD_DESC_TYPE_ARGV:
    case RZ_CMD_DESC_TYPE_ARGV_MODES:
    case RZ_CMD_DESC_TYPE_ARGV_STATE:
        return argv_get_help(cmd, cd, detail, use_color);
    case RZ_CMD_DESC_TYPE_FAKE:
        if (detail != 1) {
            return NULL;
        }
        return fake_get_help(cmd, cd, use_color);
    case RZ_CMD_DESC_TYPE_OLDINPUT:
        return oldinput_get_help(cmd, cd, args);
    case RZ_CMD_DESC_TYPE_INNER:
        rz_warn_if_reached();
        return NULL;
    }
    return NULL;
}

References args, argv_get_help(), cd, cmd, fake_get_help(), group_get_help(), NULL, oldinput_get_help(), RZ_CMD_DESC_TYPE_ARGV, RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, RZ_CMD_DESC_TYPE_FAKE, RZ_CMD_DESC_TYPE_GROUP, RZ_CMD_DESC_TYPE_INNER, RZ_CMD_DESC_TYPE_OLDINPUT, and rz_warn_if_reached.

Referenced by rz_cmd_get_help().

get_minmax_argc()

static void get_minmax_argc ( RzCmdDesc *  cd, int *  min_argc, int *  max_argc  )

static

Definition at line 592 of file cmd_api.c.

                                                                         {
    *min_argc = 1;
    *max_argc = 1;
    const RzCmdDescArg *arg = cd->help->args;
    while (arg && arg->name && !arg->optional) {
        if (arg->type == RZ_CMD_ARG_TYPE_FAKE) {
            arg++;
            continue;
        }
        (*min_argc)++;
        (*max_argc)++;
        if (arg->flags & RZ_CMD_ARG_FLAG_LAST) {
            return;
        } else if (arg->flags & RZ_CMD_ARG_FLAG_ARRAY) {
            *max_argc = INT_MAX;
            return;
        }
        arg++;
    }
    while (arg && arg->name) {
        if (arg->type == RZ_CMD_ARG_TYPE_FAKE) {
            arg++;
            continue;
        }
        (*max_argc)++;
        if (arg->flags & RZ_CMD_ARG_FLAG_ARRAY) {
            *max_argc = INT_MAX;
            return;
        }
        arg++;
    }
}

References cd, INT_MAX, arg::name, RZ_CMD_ARG_FLAG_ARRAY, RZ_CMD_ARG_FLAG_LAST, and RZ_CMD_ARG_TYPE_FAKE.

Referenced by argv_modes_new(), argv_new(), and argv_state_new().

group_get_help()

static char* group_get_help ( RzCmd *  cmd, RzCmdDesc *  cd, bool  use_color  )

static

Definition at line 1124 of file cmd_api.c.

                                                                       {
    RzStrBuf *sb = rz_strbuf_new(NULL);
    fill_usage_strbuf(cmd, sb, cd, use_color);
 
    void **it_cd;
    size_t max_len = 0, min_len = SIZE_MAX;
 
    rz_cmd_desc_children_foreach(cd, it_cd) {
        RzCmdDesc *child = *(RzCmdDesc **)it_cd;
        update_minmax_len(child, &max_len, &min_len, true);
    }
    if (max_len - min_len > MAX_RIGHT_ALIGHNMENT) {
        max_len = min_len + MAX_RIGHT_ALIGHNMENT;
    }
 
    rz_cmd_desc_children_foreach(cd, it_cd) {
        RzCmdDesc *child = *(RzCmdDesc **)it_cd;
        print_child_help(cmd, sb, child, max_len, use_color);
    }
 
    fill_details(cmd, cd, sb, use_color);
    return rz_strbuf_drain(sb);
}

References cd, cmd, fill_details(), fill_usage_strbuf(), MAX_RIGHT_ALIGHNMENT, NULL, print_child_help(), rz_strbuf_drain(), rz_strbuf_new(), sb, SIZE_MAX, and update_minmax_len().

Referenced by get_help().

has_cd_default_mode()

static bool has_cd_default_mode ( RzCmdDesc *  cd )

static

Definition at line 636 of file cmd_api.c.

                                               {
    return get_cd_default_mode(cd) != RZ_OUTPUT_MODE_STANDARD;
}

References cd, get_cd_default_mode(), and RZ_OUTPUT_MODE_STANDARD.

Referenced by cd_suffix2mode(), and fill_usage_strbuf().

has_cd_submodes()

static bool has_cd_submodes ( const RzCmdDesc *  cd )

static

Definition at line 279 of file cmd_api.c.

                                                 {
    return cd->type == RZ_CMD_DESC_TYPE_ARGV_MODES || cd->type == RZ_CMD_DESC_TYPE_ARGV_STATE;
}

References cd, RZ_CMD_DESC_TYPE_ARGV_MODES, and RZ_CMD_DESC_TYPE_ARGV_STATE.

Referenced by cd_suffix2mode(), is_valid_argv_modes(), and show_children_shortcut().

int2cmdstatus()

static RzCmdStatus int2cmdstatus ( int  v )

static

Definition at line 582 of file cmd_api.c.

                                        {
    if (v == -2) {
        return RZ_CMD_STATUS_EXIT;
    } else if (v < 0) {
        return RZ_CMD_STATUS_ERROR;
    } else {
        return RZ_CMD_STATUS_OK;
    }
}

References RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_EXIT, RZ_CMD_STATUS_OK, and v.

Referenced by call_cd().

is_valid_argv_modes()

static bool is_valid_argv_modes ( RzCmdDesc *  cd, char  last_letter  )

static

Definition at line 283 of file cmd_api.c.

                                                                 {
    if (!cd || !has_cd_submodes(cd) || last_letter == '\0') {
        return false;
    }
    char suffix[] = { last_letter, '\0' };
    return cd->d.argv_modes_data.modes & suffix2mode(suffix);
}

References cd, has_cd_submodes(), suffix, and suffix2mode().

Referenced by cmd_get_desc_best().

macro_call()

static int macro_call ( RzCmdMacro *  mac, const char *  name, bool  multiple  )

static

Definition at line 1853 of file cmd_api.c.

                                                                        {
    char *args;
    int nargs = 0;
    char *str, *ptr, *ptr2;
    RzListIter *iter;
    static int macro_level = 0;
    RzCmdMacroItem *m;
    /* labels */
    int labels_n = 0;
    struct rz_cmd_macro_label_t labels[MACRO_LABELS];
 
    str = strdup(name);
    if (!str) {
        perror("strdup");
        return false;
    }
    ptr = strchr(str, ')');
    if (!ptr) {
        RZ_LOG_ERROR("Missing end ')' parenthesis.\n");
        free(str);
        return false;
    } else {
        *ptr = '\0';
    }
 
    args = strchr(str, ' ');
    if (args) {
        *args = '\0';
        args++;
        nargs = rz_str_word_set0(args);
    }
 
    macro_level++;
    if (macro_level > MACRO_LIMIT) {
        RZ_LOG_ERROR("Maximum macro recursivity reached.\n");
        macro_level--;
        free(str);
        return 0;
    }
    ptr = strchr(str, ';');
    if (ptr) {
        *ptr = 0;
    }
 
    rz_cons_break_push(NULL, NULL);
    rz_list_foreach (mac->macros, iter, m) {
        if (!strcmp(str, m->name)) {
            char *ptr = m->code;
            char *end = strchr(ptr, '\n');
            char *init_ptr = ptr;
            char *init_end = end;
            if ((m->nargs == 0 && nargs != m->nargs) ||
                (m->nargs != 0 &&
                    ((multiple && (nargs % m->nargs != 0 || nargs == 0)) ||
                        (!multiple && nargs != m->nargs)))) {
                if (!multiple || m->nargs == 0 || nargs == 0) {
                    RZ_LOG_ERROR("Macro '%s' expects %d args, not %d\n", m->name, m->nargs, nargs);
                } else {
                    RZ_LOG_ERROR("Macro '%s' expects %d args and %d is not a multiple of %d\n",
                        m->name, m->nargs, nargs, m->nargs);
                }
                macro_level--;
                free(str);
                rz_cons_break_pop();
                return false;
            }
            mac->brk = 0;
            int args_processed = 0;
            do {
                if (end) {
                    *end = '\0';
                }
                if (rz_cons_is_breaked()) {
                    RZ_LOG_ERROR("Interrupted at (%s)\n", ptr);
                    if (end) {
                        *end = '\n';
                    }
                    free(str);
                    rz_cons_break_pop();
                    return false;
                }
                rz_cons_flush();
                /* Label handling */
                ptr2 = rz_cmd_macro_label_process(mac, &(labels[0]), &labels_n, ptr);
                if (!ptr2) {
                    RZ_LOG_ERROR("Oops. invalid label name\n");
                    break;
                } else if (ptr != ptr2) {
                    ptr = ptr2;
                    if (end) {
                        *end = '\n';
                    }
                    end = strchr(ptr, '\n');
                    continue;
                }
                /* Command execution */
                if (*ptr) {
                    mac->num->value = value;
                    int r = rz_cmd_macro_cmd_args(mac, ptr, args, nargs);
                    // TODO: handle quit? r == 0??
                    // quit, exits the macro. like a break
                    value = mac->num->value;
                    if (r < 0) {
                        free(str);
                        rz_cons_break_pop();
                        return r;
                    }
                }
                if (end) {
                    *end = '\n';
                    ptr = end + 1;
                    /* Fetch next command */
                    end = strchr(ptr, '\n');
                } else {
                    args_processed += m->nargs;
                    if (!multiple || args_processed >= nargs) {
                        macro_level--;
                        free(str);
                        goto out_clean;
                    }
                    args = (char *)rz_str_word_get0(args, m->nargs);
                    ptr = init_ptr;
                    end = init_end;
                }
            } while (!mac->brk);
            if (mac->brk) {
                macro_level--;
                free(str);
                goto out_clean;
            }
        }
    }
    RZ_LOG_ERROR("No macro named '%s'\n", str);
    macro_level--;
    free(str);
out_clean:
    rz_cons_break_pop();
    return true;
}

References args, rz_cmd_macro_t::brk, test_evm::end, free(), regress::m, MACRO_LABELS, MACRO_LIMIT, rz_cmd_macro_t::macros, cmd_descs_generate::nargs, NULL, rz_cmd_macro_t::num, rz_cmd_macro_label_t::ptr, r, rz_cmd_macro_cmd_args(), rz_cmd_macro_label_process(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_flush(), rz_cons_is_breaked(), RZ_LOG_ERROR, rz_str_word_get0(), rz_str_word_set0(), cmd_descs_generate::str, strdup(), value, and rz_num_t::value.

Referenced by rz_cmd_macro_call(), and rz_cmd_macro_call_multiple().

mode_cmd_desc_help()

static RzCmdDescHelp* mode_cmd_desc_help ( RzCmdDescHelp *  dst, const RzCmdDescHelp *  src, const char *  suffix  )

static

Definition at line 2395 of file cmd_api.c.

                                                                                                           {
    dst->summary = rz_str_newf("%s%s", src->summary, suffix);
    dst->description = src->description;
    dst->args_str = src->args_str;
    dst->usage = src->usage;
    dst->options = src->options;
    dst->details = src->details;
    dst->args = src->args;
    return dst;
}

References dst, rz_str_newf(), src, and suffix.

Referenced by cmd_foreach_cmdname_modes().

oldinput_get_help()

static char* oldinput_get_help ( RzCmd *  cmd, RzCmdDesc *  cd, RzCmdParsedArgs *  a  )

static

Definition at line 1302 of file cmd_api.c.

                                                                              {
    if (!cmd->has_cons) {
        return NULL;
    }
 
    char *res = NULL;
    rz_cons_push();
    // rz_cons_push disables flushing, which is going to be a problem if a help menu is
    // displayed.
    rz_cons_set_flush(true);
    RzCmdStatus status = rz_cmd_call_parsed_args(cmd, a);
    if (status == RZ_CMD_STATUS_OK) {
        rz_cons_filter();
        res = rz_cons_get_buffer_dup();
    }
    if (!res) {
        res = strdup("");
    }
    rz_cons_pop();
    return res;
}

References a, cmd, NULL, rz_cmd_call_parsed_args(), RZ_CMD_STATUS_OK, rz_cons_filter(), rz_cons_get_buffer_dup(), rz_cons_pop(), rz_cons_push(), rz_cons_set_flush(), status, and strdup().

Referenced by get_help().

parsed_args_iterateargs()

static void parsed_args_iterateargs ( RzCmdParsedArgs *  a, RzStrBuf *  sb  )

static

Definition at line 2105 of file cmd_api.c.

                                                                      {
    int i;
    for (i = 1; i < a->argc; i++) {
        if (i > 1) {
            rz_strbuf_append(sb, " ");
        }
        rz_strbuf_append(sb, a->argv[i]);
    }
}

References a, i, rz_strbuf_append(), and sb.

Referenced by rz_cmd_parsed_args_argstr(), and rz_cmd_parsed_args_execstr().

print_child_help()

static void print_child_help ( RzCmd *  cmd, RzStrBuf *  sb, RzCmdDesc *  cd, size_t  max_len, bool  use_color  )

static

Definition at line 1120 of file cmd_api.c.

                                                                                                      {
    do_print_child_help(cmd, sb, cd, cd->name, cd->help->summary ? cd->help->summary : "", true, max_len, use_color);
}

References cd, cmd, do_print_child_help(), and sb.

Referenced by group_get_help().

rz_cmd_add()

RZ_API int rz_cmd_add	(	RzCmd *	c,
		const char *	cmd,
		RzCmdCb	cb
	)

Definition at line 528 of file cmd_api.c.

                                                             {
    int idx = (ut8)cmd[0];
    RzCmdItem *item = c->cmds[idx];
    if (!item) {
        item = RZ_NEW0(RzCmdItem);
        c->cmds[idx] = item;
    }
    strncpy(item->cmd, cmd, sizeof(item->cmd) - 1);
    item->callback = cb;
    return true;
}

References c, rz_cmd_item_t::callback, cb, rz_cmd_item_t::cmd, cmd, setup::idx, RZ_NEW0, and ut8.

Referenced by rz_core_cmd_init().

rz_cmd_alias_del()

RZ_API bool rz_cmd_alias_del	(	RzCmd *	cmd,
		const char *	k
	)

Definition at line 431 of file cmd_api.c.

                                                        {
    int i; // find
    for (i = 0; i < cmd->aliases.count; i++) {
        if (!k || !strcmp(k, cmd->aliases.keys[i])) {
            RZ_FREE(cmd->aliases.values[i]);
            cmd->aliases.count--;
            if (cmd->aliases.count > 0) {
                if (i > 0) {
                    free(cmd->aliases.keys[i]);
                    cmd->aliases.keys[i] = cmd->aliases.keys[0];
                    free(cmd->aliases.values[i]);
                    cmd->aliases.values[i] = cmd->aliases.values[0];
                }
                memmove(cmd->aliases.values,
                    cmd->aliases.values + 1,
                    cmd->aliases.count * sizeof(void *));
                memmove(cmd->aliases.keys,
                    cmd->aliases.keys + 1,
                    cmd->aliases.count * sizeof(void *));
            }
            return true;
        }
    }
    return false;
}

References cmd, free(), i, k, and RZ_FREE.

Referenced by rz_cmd_alias().

rz_cmd_alias_free()

RZ_API void rz_cmd_alias_free

(

RzCmd *

cmd

)

Definition at line 419 of file cmd_api.c.

                                          {
    int i; // find
    for (i = 0; i < cmd->aliases.count; i++) {
        free(cmd->aliases.keys[i]);
        free(cmd->aliases.values[i]);
    }
    cmd->aliases.count = 0;
    RZ_FREE(cmd->aliases.keys);
    RZ_FREE(cmd->aliases.values);
    free(cmd->aliases.remote);
}

References cmd, free(), i, and RZ_FREE.

Referenced by rz_cmd_free().

rz_cmd_alias_get()

RZ_API char* rz_cmd_alias_get	(	RzCmd *	cmd,
		const char *	k,
		int	remote
	)

Definition at line 501 of file cmd_api.c.

                                                                     {
    int matches, i;
    if (!cmd || !k) {
        return NULL;
    }
    for (i = 0; i < cmd->aliases.count; i++) {
        matches = 0;
        if (remote) {
            if (cmd->aliases.remote[i]) {
                matches = !strncmp(k, cmd->aliases.keys[i],
                    strlen(cmd->aliases.keys[i]));
            }
        } else {
            matches = !strcmp(k, cmd->aliases.keys[i]);
        }
        if (matches) {
            return cmd->aliases.values[i];
        }
    }
    return NULL;
}

References cmd, i, k, and NULL.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), getFileData(), rz_cmd_alias(), rz_cmd_call(), rz_cmd_shell_cat_handler(), and rz_core_cmd_subst_i().

rz_cmd_alias_init()

RZ_API void rz_cmd_alias_init

(

RzCmd *

cmd

)

Definition at line 184 of file cmd_api.c.

                                          {
    cmd->aliases.count = 0;
    cmd->aliases.keys = NULL;
    cmd->aliases.values = NULL;
}

References cmd, and NULL.

Referenced by rz_cmd_new().

rz_cmd_alias_keys()

RZ_API char** rz_cmd_alias_keys	(	RzCmd *	cmd,
		int *	sz
	)

Definition at line 412 of file cmd_api.c.

                                                     {
    if (sz) {
        *sz = cmd->aliases.count;
    }
    return cmd->aliases.keys;
}

References cmd.

Referenced by autocomplete_minus(), and rz_cmd_alias().

rz_cmd_alias_set()

RZ_API int rz_cmd_alias_set	(	RzCmd *	cmd,
		const char *	k,
		const char *	v,
		int	remote
	)

Definition at line 458 of file cmd_api.c.

                                                                                  {
    void *tofree = NULL;
    if (!strncmp(v, "base64:", 7)) {
        ut8 *s = rz_base64_decode_dyn(v + 7, -1);
        if (s) {
            tofree = s;
            v = (const char *)s;
        }
    }
    int i;
    for (i = 0; i < cmd->aliases.count; i++) {
        int matches = !strcmp(k, cmd->aliases.keys[i]);
        if (matches) {
            free(cmd->aliases.values[i]);
            cmd->aliases.values[i] = strdup(v);
            free(tofree);
            return 1;
        }
    }
 
    i = cmd->aliases.count++;
    char **K = (char **)realloc(cmd->aliases.keys,
        sizeof(char *) * cmd->aliases.count);
    if (K) {
        cmd->aliases.keys = K;
        int *R = (int *)realloc(cmd->aliases.remote,
            sizeof(int) * cmd->aliases.count);
        if (R) {
            cmd->aliases.remote = R;
            char **V = (char **)realloc(cmd->aliases.values,
                sizeof(char *) * cmd->aliases.count);
            if (V) {
                cmd->aliases.values = V;
                cmd->aliases.keys[i] = strdup(k);
                cmd->aliases.values[i] = strdup(v);
                cmd->aliases.remote[i] = remote;
            }
        }
    }
    free(tofree);
    return 0;
}

References cmd, free(), i, k, NULL, R, realloc(), rz_base64_decode_dyn(), s, strdup(), v, and V.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), rz_cmd_alias(), and rz_core_cmd_subst_i().

rz_cmd_batch_end()

RZ_API void rz_cmd_batch_end

(

RzCmd *

cmd

)

Mark the end of the batched changes to RzCmd.

All groups are sorted, if necessary. Call rz_cmd_batch_start before using this function.

Definition at line 264 of file cmd_api.c.

                                         {
    cmd->batch = false;
    sort_groups(rz_cmd_get_root(cmd));
}

References cmd, rz_cmd_get_root(), and sort_groups().

Referenced by rzshell_cmddescs_init().

rz_cmd_batch_start()

RZ_API void rz_cmd_batch_start

(

RzCmd *

cmd

)

Mark the start of the batched changes to RzCmd.

Commands added after this call won't be sorted until rz_cmd_batch_end is called.

Definition at line 240 of file cmd_api.c.

                                           {
    cmd->batch = true;
}

References cmd.

Referenced by rzshell_cmddescs_init().

rz_cmd_call()

RZ_API int rz_cmd_call	(	RzCmd *	cmd,
		const char *	input
	)

Definition at line 546 of file cmd_api.c.

                                                      {
    struct rz_cmd_item_t *c;
    int ret = -1;
    rz_return_val_if_fail(cmd && input, -1);
    if (!*input) {
        if (cmd->nullcallback) {
            ret = cmd->nullcallback(cmd->data);
        }
    } else {
        char *nstr = NULL;
        const char *ji = rz_cmd_alias_get(cmd, input, 1);
        if (ji) {
            if (*ji == '$') {
                rz_cons_strcat(ji + 1);
                return true;
            } else {
                nstr = rz_str_newf("R! %s", input);
                input = nstr;
            }
        }
        if (!*input) {
            free(nstr);
            return -1;
        }
        c = cmd->cmds[((ut8)input[0]) & 0xff];
        if (c && c->callback) {
            const char *inp = (*input) ? input + 1 : "";
            ret = c->callback(cmd->data, inp);
        } else {
            ret = -1;
        }
        free(nstr);
    }
    return ret;
}

References c, cmd, free(), input(), NULL, rz_cmd_alias_get(), rz_cons_strcat(), rz_return_val_if_fail, rz_str_newf(), and ut8.

Referenced by rz_core_cmd_subst_i().

rz_cmd_call_parsed_args()

RZ_API RzCmdStatus rz_cmd_call_parsed_args	(	RzCmd *	cmd,
		RzCmdParsedArgs *	args
	)

Definition at line 794 of file cmd_api.c.

                                                                              {
    RzCmdDesc *cd = rz_cmd_get_desc(cmd, rz_cmd_parsed_args_cmd(args));
    if (!cd) {
        return RZ_CMD_STATUS_NONEXISTINGCMD;
    }
 
    return call_cd(cmd, cd, args);
}

References args, call_cd(), cd, cmd, rz_cmd_get_desc(), rz_cmd_parsed_args_cmd(), and RZ_CMD_STATUS_NONEXISTINGCMD.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and oldinput_get_help().

rz_cmd_del()

RZ_API int rz_cmd_del	(	RzCmd *	cmd,
		const char *	command
	)

Definition at line 540 of file cmd_api.c.

                                                       {
    int idx = (ut8)command[0];
    RZ_FREE(cmd->cmds[idx]);
    return 0;
}

References cmd, command, setup::idx, RZ_FREE, and ut8.

rz_cmd_desc_argv_modes_new()

RZ_API RzCmdDesc* rz_cmd_desc_argv_modes_new	(	RzCmd *	cmd,
		RzCmdDesc *	parent,
		const char *	name,
		int	modes,
		RzCmdArgvModesCb	cb,
		const RzCmdDescHelp *	help
	)

Create a new command descriptor for a command that supports multiple output modes (e.g. rizin commands, json, csv, etc.).

Parameters

cmd	reference to the RzCmd
parent	Parent command descriptor of the command being added
name	Base name of the command. New commands will be created with the proper suffix based on the supported modes
modes	Modes supported by the handler (see RzOutputMode). They can be put in OR to support multiple modes
cb	Callback that actually executes the command
help	Help structure used to describe the command when using ? and ??

Definition at line 2195 of file cmd_api.c.

                                                                                                                                                         {
    rz_return_val_if_fail(cmd && parent && name && help && help->args && modes, NULL);
    return argv_modes_new(cmd, parent, name, modes, cb, help, true);
}

References argv_modes_new(), cb, cmd, cmd_descs_generate::help, NULL, and rz_return_val_if_fail.

Referenced by rzshell_cmddescs_init().

rz_cmd_desc_argv_new()

RZ_API RzCmdDesc* rz_cmd_desc_argv_new	(	RzCmd *	cmd,
		RzCmdDesc *	parent,
		const char *	name,
		RzCmdArgvCb	cb,
		const RzCmdDescHelp *	help
	)

Definition at line 2153 of file cmd_api.c.

                                                                                                                                   {
    rz_return_val_if_fail(cmd && parent && name && help && help->args, NULL);
    return argv_new(cmd, parent, name, cb, help, true);
}

References argv_new(), cb, cmd, cmd_descs_generate::help, NULL, and rz_return_val_if_fail.

Referenced by rz_cmd_example_init(), and rzshell_cmddescs_init().

rz_cmd_desc_argv_state_new()

RZ_API RzCmdDesc* rz_cmd_desc_argv_state_new	(	RzCmd *	cmd,
		RzCmdDesc *	parent,
		const char *	name,
		int	modes,
		RzCmdArgvStateCb	cb,
		const RzCmdDescHelp *	help
	)

Create a new command descriptor for a command that supports multiple output modes (e.g. rizin commands, json, csv, etc.), where the state of the output is handled by RzCmd itself.

Parameters

cmd	reference to the RzCmd
parent	Parent command descriptor of the command being added
name	Base name of the command. New commands will be created with the proper suffix based on the supported modes
modes	Modes supported by the handler (see RzOutputMode). They can be put in OR to support multiple modes
cb	Callback that actually executes the command
help	Help structure used to describe the command when using ? and ??

Definition at line 2212 of file cmd_api.c.

                                                                                                                                                         {
    rz_return_val_if_fail(cmd && parent && name && help && help->args && modes, NULL);
    return argv_state_new(cmd, parent, name, modes, cb, help, true);
}

References argv_state_new(), cb, cmd, cmd_descs_generate::help, NULL, and rz_return_val_if_fail.

Referenced by rzshell_cmddescs_init().

rz_cmd_desc_details_free()

RZ_API void rz_cmd_desc_details_free

(

RzCmdDescDetail *

details

)

Free an array of RzCmdDescDetail sections.

Usually command handlers do not need to free the details sections because they are const, but due to details_cb those sections could be dynamically generated. In that case all the data within the details should be dynamically allocated memory, even the one marked as const, as they are going to be freed anyway.

Parameters

entries

Pointer to the array of RzCmdDescDetails

Definition at line 2698 of file cmd_api.c.

                                                               {
    RzCmdDescDetail *detail_it = details;
    while (detail_it->name) {
        free((char *)detail_it->name);
        RzCmdDescDetailEntry *oentry, *entry;
        oentry = entry = (RzCmdDescDetailEntry *)detail_it->entries;
        while (entry && entry->text) {
            free((char *)entry->text);
            free((char *)entry->comment);
            free((char *)entry->arg_str);
            entry++;
        }
        free(oentry);
        detail_it++;
    }
    free(details);
}

References entry::comment, rz_cmd_desc_detail_t::entries, free(), rz_cmd_desc_detail_t::name, and while().

Referenced by fill_details_cb(), and rz_hash_bang_details_cb().

rz_cmd_desc_fake_new()

RZ_API RzCmdDesc* rz_cmd_desc_fake_new	(	RzCmd *	cmd,
		RzCmdDesc *	parent,
		const char *	name,
		const RzCmdDescHelp *	help
	)

Definition at line 2326 of file cmd_api.c.

                                                                                                                   {
    rz_return_val_if_fail(cmd && parent && name && help, NULL);
    return create_cmd_desc(cmd, parent, RZ_CMD_DESC_TYPE_FAKE, name, help, true);
}

References cmd, create_cmd_desc(), cmd_descs_generate::help, NULL, RZ_CMD_DESC_TYPE_FAKE, and rz_return_val_if_fail.

Referenced by rzshell_cmddescs_init().

rz_cmd_desc_get_arg()

RZ_API const RzCmdDescArg* rz_cmd_desc_get_arg	(	RzCmd *	cmd,
		const RzCmdDesc *	cd,
		size_t	i
	)

Get a reference to the i-th argument of a command descriptor.

Get a reference to the i-th argument of a command. This function is useful to know which RzCmdDescArg an argument actually belongs to. In particular, it deals with arguments with special flags like RZ_CMD_ARG_FLAG_LAST or RZ_CMD_ARG_FLAG_ARRAY, where even if there is just one RzCmdDescArg, everything is considered as part of the same RzCmdDescArg.

Definition at line 2375 of file cmd_api.c.

                                                                                          {
    const RzCmdDescArg *arg = cd->help->args;
    size_t j = 0;
    while (arg && arg->name) {
        if (arg->type == RZ_CMD_ARG_TYPE_FAKE) {
            arg++;
            continue;
        }
        if (i == j) {
            return arg;
        }
        if ((arg->flags & RZ_CMD_ARG_FLAG_LAST) || (arg->flags & RZ_CMD_ARG_FLAG_ARRAY)) {
            return arg;
        }
        arg++;
        j++;
    }
    return NULL;
}

References arg(), cd, i, arg::name, NULL, RZ_CMD_ARG_FLAG_ARRAY, RZ_CMD_ARG_FLAG_LAST, and RZ_CMD_ARG_TYPE_FAKE.

Referenced by autocmplt_cmd_arg(), and fill_autocmplt_data_cmdarg().

rz_cmd_desc_get_exec()

RZ_API RzCmdDesc* rz_cmd_desc_get_exec

(

RzCmdDesc *

cd

)

Definition at line 291 of file cmd_api.c.

                                                      {
    if (!cd) {
        return NULL;
    }
    switch (cd->type) {
    case RZ_CMD_DESC_TYPE_GROUP:
        return cd->d.group_data.exec_cd;
    default:
        return cd;
    }
}

References cd, NULL, and RZ_CMD_DESC_TYPE_GROUP.

Referenced by cmd_get_desc_best(), fill_children_chars(), get_cd_from_cmdid(), and rz_cmd_desc_set_default_mode().

rz_cmd_desc_group_modes_new()

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
	)

Create a new command descriptor for a name that is used both as a group but that has a sub-command with the same name as well. The sub-command supports multiple output modes (e.g. rizin commands, json, csv, etc.).

Parameters

cmd	reference to the RzCmd
parent	Parent command descriptor of the command being added
name	Base name of the group/sub-command. New commands will be created with the proper suffix based on the supported modes
modes	Modes supported by the handler (see RzOutputMode). They can be put in OR to support multiple modes
cb	Callback that actually executes the command
help	Help structure used to describe the command when using ? and ??
group_help	Help structure used to describe the group

Definition at line 2268 of file cmd_api.c.

                                                                                                                                                                                           {
    rz_return_val_if_fail(cmd && parent && name && group_help && modes && cb && help && help->args, NULL);
    RzCmdDesc *res = create_cmd_desc(cmd, parent, RZ_CMD_DESC_TYPE_GROUP, name, group_help, true);
    if (!res) {
        return NULL;
    }
 
    RzCmdDesc *exec_cd = argv_modes_new(cmd, res, name, modes, cb, help, false);
    if (!exec_cd) {
        rz_cmd_desc_remove(cmd, res);
        return NULL;
    }
 
    res->d.group_data.exec_cd = exec_cd;
    return res;
}

References argv_modes_new(), cb, cmd, create_cmd_desc(), rz_cmd_desc_t::d, rz_cmd_desc_t::group_data, cmd_descs_generate::help, NULL, rz_cmd_desc_remove(), RZ_CMD_DESC_TYPE_GROUP, and rz_return_val_if_fail.

Referenced by rzshell_cmddescs_init().

rz_cmd_desc_group_new()

RZ_API RzCmdDesc* rz_cmd_desc_group_new	(	RzCmd *	cmd,
		RzCmdDesc *	parent,
		const char *	name,
		RzCmdArgvCb	cb,
		const RzCmdDescHelp *	help,
		const RzCmdDescHelp *	group_help
	)

Create a new command descriptor for a name that is used both as a group but that has a sub-command with the same name as well.

Parameters

cmd	reference to the RzCmd
parent	Parent command descriptor of the command being added
name	Base name of the group/sub-command.
cb	Callback that actually executes the command
help	Help structure used to describe the command when using ? and ??
group_help	Help structure used to describe the group

Definition at line 2233 of file cmd_api.c.

                                                                                                                                                                     {
    rz_return_val_if_fail(cmd && parent && name && group_help, NULL);
    RzCmdDesc *res = create_cmd_desc(cmd, parent, RZ_CMD_DESC_TYPE_GROUP, name, group_help, true);
    if (!res) {
        return NULL;
    }
 
    RzCmdDesc *exec_cd = NULL;
    if (cb && help) {
        rz_return_val_if_fail(help->args, NULL);
        exec_cd = argv_new(cmd, res, name, cb, help, false);
        if (!exec_cd) {
            rz_cmd_desc_remove(cmd, res);
            return NULL;
        }
    }
 
    res->d.group_data.exec_cd = exec_cd;
    return res;
}

References argv_new(), cb, cmd, create_cmd_desc(), rz_cmd_desc_t::d, rz_cmd_desc_t::group_data, cmd_descs_generate::help, NULL, rz_cmd_desc_remove(), RZ_CMD_DESC_TYPE_GROUP, and rz_return_val_if_fail.

Referenced by rz_cmd_dex_init_handler(), rz_cmd_java_init_handler(), and rzshell_cmddescs_init().

rz_cmd_desc_group_state_new()

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
	)

Create a new command descriptor for a name that is used both as a group but that has a sub-command with the same name as well. The sub-command supports multiple output modes (e.g. rizin commands, json, csv, etc.), where the state of the output is handled by RzCmd itself.

Parameters

cmd	reference to the RzCmd
parent	Parent command descriptor of the command being added
name	Base name of the group/sub-command. New commands will be created with the proper suffix based on the supported modes
modes	Modes supported by the handler (see RzOutputMode). They can be put in OR to support multiple modes
cb	Callback that actually executes the command
help	Help structure used to describe the command when using ? and ??
group_help	Help structure used to describe the group

Definition at line 2299 of file cmd_api.c.

                                                                                                                                                                                           {
    rz_return_val_if_fail(cmd && parent && name && group_help && modes && cb && help && help->args, NULL);
    RzCmdDesc *res = create_cmd_desc(cmd, parent, RZ_CMD_DESC_TYPE_GROUP, name, group_help, true);
    if (!res) {
        return NULL;
    }
 
    RzCmdDesc *exec_cd = argv_state_new(cmd, res, name, modes, cb, help, false);
    if (!exec_cd) {
        rz_cmd_desc_remove(cmd, res);
        return NULL;
    }
 
    res->d.group_data.exec_cd = exec_cd;
    return res;
}

References argv_state_new(), cb, cmd, create_cmd_desc(), rz_cmd_desc_t::d, rz_cmd_desc_t::group_data, cmd_descs_generate::help, NULL, rz_cmd_desc_remove(), RZ_CMD_DESC_TYPE_GROUP, and rz_return_val_if_fail.

Referenced by rzshell_cmddescs_init().

rz_cmd_desc_has_handler()

RZ_API bool rz_cmd_desc_has_handler

(

const RzCmdDesc *

cd

)

Definition at line 2336 of file cmd_api.c.

                                                         {
    rz_return_val_if_fail(cd, false);
    switch (cd->type) {
    case RZ_CMD_DESC_TYPE_ARGV:
        return cd->d.argv_data.cb;
    case RZ_CMD_DESC_TYPE_ARGV_MODES:
        return cd->d.argv_modes_data.cb;
    case RZ_CMD_DESC_TYPE_ARGV_STATE:
        return cd->d.argv_state_data.cb;
    case RZ_CMD_DESC_TYPE_OLDINPUT:
        return cd->d.oldinput_data.cb;
    case RZ_CMD_DESC_TYPE_FAKE:
    case RZ_CMD_DESC_TYPE_INNER:
        return false;
    case RZ_CMD_DESC_TYPE_GROUP:
        return cd->d.group_data.exec_cd && rz_cmd_desc_has_handler(cd->d.group_data.exec_cd);
    }
    return false;
}

References cd, RZ_CMD_DESC_TYPE_ARGV, RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, RZ_CMD_DESC_TYPE_FAKE, RZ_CMD_DESC_TYPE_GROUP, RZ_CMD_DESC_TYPE_INNER, RZ_CMD_DESC_TYPE_OLDINPUT, and rz_return_val_if_fail.

Referenced by argv_call_cb(), cmd_foreach_cmdname(), and fill_children_chars().

rz_cmd_desc_inner_new()

RZ_API RzCmdDesc* rz_cmd_desc_inner_new	(	RzCmd *	cmd,
		RzCmdDesc *	parent,
		const char *	name,
		const RzCmdDescHelp *	help
	)

Definition at line 2217 of file cmd_api.c.

                                                                                                                    {
    rz_return_val_if_fail(cmd && parent && name && help, NULL);
    return create_cmd_desc(cmd, parent, RZ_CMD_DESC_TYPE_INNER, name, help, false);
}

References cmd, create_cmd_desc(), cmd_descs_generate::help, NULL, RZ_CMD_DESC_TYPE_INNER, and rz_return_val_if_fail.

Referenced by rzshell_cmddescs_init().

rz_cmd_desc_oldinput_new()

RZ_API RzCmdDesc* rz_cmd_desc_oldinput_new	(	RzCmd *	cmd,
		RzCmdDesc *	parent,
		const char *	name,
		RzCmdCb	cb,
		const RzCmdDescHelp *	help
	)

Definition at line 2316 of file cmd_api.c.

                                                                                                                                   {
    rz_return_val_if_fail(cmd && parent && name && cb, NULL);
    RzCmdDesc *res = create_cmd_desc(cmd, parent, RZ_CMD_DESC_TYPE_OLDINPUT, name, help, true);
    if (!res) {
        return NULL;
    }
    res->d.oldinput_data.cb = cb;
    return res;
}

References cb, cmd, create_cmd_desc(), rz_cmd_desc_t::d, cmd_descs_generate::help, NULL, rz_cmd_desc_t::oldinput_data, RZ_CMD_DESC_TYPE_OLDINPUT, and rz_return_val_if_fail.

Referenced by rzshell_cmddescs_init().

rz_cmd_desc_parent()

RZ_API RzCmdDesc* rz_cmd_desc_parent

(

RzCmdDesc *

cd

)

Definition at line 2331 of file cmd_api.c.

                                                    {
    rz_return_val_if_fail(cd, NULL);
    return cd->parent;
}

References cd, NULL, and rz_return_val_if_fail.

rz_cmd_desc_remove()

RZ_API bool rz_cmd_desc_remove	(	RzCmd *	cmd,
		RzCmdDesc *	cd
	)

Definition at line 2356 of file cmd_api.c.

                                                          {
    rz_return_val_if_fail(cmd && cd, false);
    if (cd->parent) {
        cmd_desc_unset_parent(cd);
    }
    cmd_desc_remove_from_ht_cmds(cmd, cd);
    cmd_desc_free(cd);
    return true;
}

References cd, cmd, cmd_desc_free(), cmd_desc_remove_from_ht_cmds(), cmd_desc_unset_parent(), and rz_return_val_if_fail.

Referenced by rz_cmd_desc_group_modes_new(), rz_cmd_desc_group_new(), and rz_cmd_desc_group_state_new().

rz_cmd_desc_set_default_mode()

RZ_API bool rz_cmd_desc_set_default_mode	(	RzCmdDesc *	cd,
		RzOutputMode	mode
	)

Set the default mode of the command descriptor, if the type allows it.

Command descriptors that support multiple output modes can also have a default one. This function can be used to set it.

Returns

True if the default output mode was changed, false otherwise.

Definition at line 384 of file cmd_api.c.

                                                                           {
    rz_return_val_if_fail(cd, false);
 
    switch (cd->type) {
    case RZ_CMD_DESC_TYPE_ARGV_MODES:
        if (cd->d.argv_modes_data.modes & RZ_OUTPUT_MODE_STANDARD) {
            return false;
        }
        cd->d.argv_modes_data.default_mode = mode;
        return true;
    case RZ_CMD_DESC_TYPE_ARGV_STATE:
        if (cd->d.argv_state_data.modes & RZ_OUTPUT_MODE_STANDARD) {
            return false;
        }
        cd->d.argv_state_data.default_mode = mode;
        return true;
    case RZ_CMD_DESC_TYPE_GROUP: {
        RzCmdDesc *exec_cd = rz_cmd_desc_get_exec(cd);
        if (exec_cd) {
            return rz_cmd_desc_set_default_mode(exec_cd, mode);
        }
        return false;
    }
    default:
        return false;
    }
}

References cd, rz_cmd_desc_get_exec(), RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, RZ_CMD_DESC_TYPE_GROUP, RZ_OUTPUT_MODE_STANDARD, and rz_return_val_if_fail.

Referenced by rzshell_cmddescs_init().

rz_cmd_escape_arg()

RZ_API char* rz_cmd_escape_arg	(	const char *	arg,
		RzCmdEscape	esc
	)

Returns an heap-allocated string with special characters considered by the rizin grammar as special characters escaped. Use this when you need to escape a string that should appear as argument of a command.

Definition at line 2516 of file cmd_api.c.

                                                                 {
    switch (esc) {
    case RZ_CMD_ESCAPE_ONE_ARG:
        return escape_special_chars(arg, SPECIAL_CHARS_REGULAR_SINGLE);
    case RZ_CMD_ESCAPE_MULTI_ARG:
        return escape_special_chars(arg, SPECIAL_CHARS_REGULAR);
    case RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG:
        return escape_special_chars(arg, SPECIAL_CHARS_DOUBLE_QUOTED);
    case RZ_CMD_ESCAPE_SINGLE_QUOTED_ARG:
        return escape_special_chars(arg, SPECIAL_CHARS_SINGLE_QUOTED);
    case RZ_CMD_ESCAPE_PF_ARG:
        return escape_special_chars(arg, SPECIAL_CHARS_PF);
    }
    rz_return_val_if_reached(strdup(arg));
}

References escape_special_chars(), RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG, RZ_CMD_ESCAPE_MULTI_ARG, RZ_CMD_ESCAPE_ONE_ARG, RZ_CMD_ESCAPE_PF_ARG, RZ_CMD_ESCAPE_SINGLE_QUOTED_ARG, rz_return_val_if_reached, SPECIAL_CHARS_DOUBLE_QUOTED, SPECIAL_CHARS_PF, SPECIAL_CHARS_REGULAR, SPECIAL_CHARS_REGULAR_SINGLE, SPECIAL_CHARS_SINGLE_QUOTED, and strdup().

Referenced by args_preprocessing(), config_print_node(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), handle_cmd_substitution_arg(), and rz_reopen_debug_handler().

rz_cmd_foreach_cmdname()

RZ_API void rz_cmd_foreach_cmdname	(	RzCmd *	cmd,
		RzCmdDesc *	begin,
		RzCmdForeachNameCb	cb,
		void *	user
	)

Execute a callback function on each possible command the user can execute.

Only command names that can actually execute something are iterated. Help commands (e.g. ?, h?, etc.) are ignored.

Parameters

cmd	Reference to RzCmd
begin	Reference to RzCmdDesc from where to begin the for loop; if NULL the root will be used.
cb	Callback function that is called for each command name.
user	Additional user data that is passed to the callback cb.

Definition at line 2474 of file cmd_api.c.

                                                                                                    {
    RzCmdDesc *cd = begin ? begin : rz_cmd_get_root(cmd);
    cmd_foreach_cmdname(cmd, cd, cb, user);
}

References cb, cd, cmd, cmd_foreach_cmdname(), and rz_cmd_get_root().

Referenced by autocmplt_cmdidentifier(), and rz_cmd_help_search_handler().

rz_cmd_free()

RZ_API RzCmd* rz_cmd_free

(

RzCmd *

cmd

)

Definition at line 208 of file cmd_api.c.

                                      {
    int i;
    if (!cmd) {
        return NULL;
    }
    ht_up_free(cmd->ts_symbols_ht);
    rz_cmd_alias_free(cmd);
    rz_cmd_macro_fini(&cmd->macro);
    ht_pp_free(cmd->ht_cmds);
    for (i = 0; i < NCMDS; i++) {
        if (cmd->cmds[i]) {
            RZ_FREE(cmd->cmds[i]);
        }
    }
    cmd_desc_free(cmd->root_cmd_desc);
    free(cmd);
    return NULL;
}

References cmd, cmd_desc_free(), free(), i, NCMDS, NULL, rz_cmd_alias_free(), rz_cmd_macro_fini(), and RZ_FREE.

Referenced by rz_core_fini().

rz_cmd_get_desc()

RZ_API RzCmdDesc* rz_cmd_get_desc	(	RzCmd *	cmd,
		const char *	cmd_identifier
	)

Retrieve the command descriptor for the command named cmd_identifier.

Check if there is a command with exactly the name cmd_identifier.

If there isn't, it removes one letter at a time to be compatible with radare2 behaviour until all commands are converted to rzshell. This best-matching works only to find OLDINPUT command references.

Parameters

cmd	Reference to RzCmd instance
cmd_identifier	Name of the command to search

Returns

RzCmdDesc reference or NULL if not found

Definition at line 372 of file cmd_api.c.

                                                                          {
    return cmd_get_desc_best(cmd, cmd_identifier, false);
}

References cmd, and cmd_get_desc_best().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), get_cd_from_cmdid(), rz_cmd_call_parsed_args(), rz_cmd_get_help(), and rz_cmd_help_search_handler().

rz_cmd_get_desc_best()

RZ_API RzCmdDesc* rz_cmd_get_desc_best	(	RzCmd *	cmd,
		const char *	cmd_identifier
	)

Retrieve the command descriptor that best matches the name cmd_identifier.

Check if there is a command with exactly the name cmd_identifier. If there isn't, it tries to find the best matching one (right now by by removing one letter at a time, but this matching algorithm may be improved later).

Parameters

cmd	Reference to RzCmd instance
cmd_identifier	Name of the command to search

Returns

RzCmdDesc reference or NULL if not found

Definition at line 355 of file cmd_api.c.

                                                                               {
    return cmd_get_desc_best(cmd, cmd_identifier, true);
}

References cmd, and cmd_get_desc_best().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL().

rz_cmd_get_help()

RZ_API char* rz_cmd_get_help	(	RzCmd *	cmd,
		RzCmdParsedArgs *	args,
		bool	use_color
	)

Definition at line 1494 of file cmd_api.c.

                                                                                {
    char *cmdid = strdup(rz_cmd_parsed_args_cmd(args));
    if (!cmdid) {
        return NULL;
    }
    char *cmdid_p = cmdid + strlen(cmdid) - 1;
    size_t detail = 0;
    while (cmdid_p >= cmdid && *cmdid_p == '?' && detail < 2) {
        *cmdid_p = '\0';
        cmdid_p--;
        detail++;
    }
 
    char *res = NULL;
    if (detail == 0) {
        // there should be at least one `?`
        goto err;
    }
 
    RzCmdDesc *cd = cmdid_p >= cmdid ? rz_cmd_get_desc(cmd, cmdid) : rz_cmd_get_root(cmd);
    if (!cd || !cd->help) {
        goto err;
    }
 
    res = get_help(cmd, cd, cmdid, args, use_color, detail);
err:
    free(cmdid);
    return res;
}

References args, cd, cmd, err, free(), get_help(), NULL, rz_cmd_get_desc(), rz_cmd_get_root(), rz_cmd_parsed_args_cmd(), and strdup().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and get_help_wrong_cmd().

rz_cmd_get_help_json()

RZ_API bool rz_cmd_get_help_json	(	RzCmd *	cmd,
		const RzCmdDesc *	cd,
		PJ *	j
	)

Generates a JSON output of the given help message description.

Parameters

cmd	reference to RzCmd
cd	reference to RzCmdDesc
j	reference to PJ

Returns

returns false if an invalid argument was given, otherwise true.

Definition at line 1439 of file cmd_api.c.

                                                                         {
    rz_return_val_if_fail(cmd && cd && j, false);
    pj_ko(j, cd->name);
    pj_ks(j, "cmd", cd->name);
    const char *type;
    switch (cd->type) {
#define CASE_CDTYPE(x, y) \
    case (x): \
        type = (y); \
        break
        CASE_CDTYPE(RZ_CMD_DESC_TYPE_OLDINPUT, "oldinput");
        CASE_CDTYPE(RZ_CMD_DESC_TYPE_ARGV, "argv");
        CASE_CDTYPE(RZ_CMD_DESC_TYPE_GROUP, "group");
        CASE_CDTYPE(RZ_CMD_DESC_TYPE_INNER, "inner");
        CASE_CDTYPE(RZ_CMD_DESC_TYPE_FAKE, "fake");
        CASE_CDTYPE(RZ_CMD_DESC_TYPE_ARGV_MODES, "argv_modes");
        CASE_CDTYPE(RZ_CMD_DESC_TYPE_ARGV_STATE, "argv_state");
#undef CASE_CDTYPE
    default:
        type = "unknown";
        break;
    }
    pj_ks(j, "type", type);
    if (cd->help->args_str) {
        pj_ks(j, "args_str", cd->help->args_str);
    } else {
        RzStrBuf *sb = rz_strbuf_new(NULL);
        fill_args(sb, cd);
        char *args = rz_strbuf_drain(sb);
        pj_ks(j, "args_str", args);
        free(args);
    }
    fill_args_json(cmd, cd, j);
    pj_ks(j, "description", cd->help->description ? cd->help->description : "");
    pj_ks(j, "summary", cd->help->summary ? cd->help->summary : "");
    pj_end(j);
    return true;
}

References args, CASE_CDTYPE, cd, cmd, fill_args(), fill_args_json(), free(), NULL, pj_end(), pj_ko(), pj_ks(), RZ_CMD_DESC_TYPE_ARGV, RZ_CMD_DESC_TYPE_ARGV_MODES, RZ_CMD_DESC_TYPE_ARGV_STATE, RZ_CMD_DESC_TYPE_FAKE, RZ_CMD_DESC_TYPE_GROUP, RZ_CMD_DESC_TYPE_INNER, RZ_CMD_DESC_TYPE_OLDINPUT, rz_return_val_if_fail, rz_strbuf_drain(), rz_strbuf_new(), sb, and type.

Referenced by help_search_cmd_desc_entry().

rz_cmd_get_help_strbuf()

RZ_API bool rz_cmd_get_help_strbuf	(	RzCmd *	cmd,
		const RzCmdDesc *	cd,
		bool	use_color,
		RzStrBuf *	sb
	)

Generates a text output of the given help message description (summary format)

Parameters

cmd	reference to RzCmd
cd	reference to RzCmdDesc
use_color	output strings with color codes.
sb	reference to RzStrBuf

Returns

returns false if an invalid argument was given, otherwise true.

Definition at line 1488 of file cmd_api.c.

                                                                                                  {
    rz_return_val_if_fail(cmd && cd && sb, false);
    do_print_child_help(cmd, sb, cd, cd->name, cd->help->summary, false, MAX_RIGHT_ALIGHNMENT, use_color);
    return true;
}

References cd, cmd, do_print_child_help(), MAX_RIGHT_ALIGHNMENT, rz_return_val_if_fail, and sb.

Referenced by help_search_cmd_desc_entry().

rz_cmd_get_root()

RZ_API RzCmdDesc* rz_cmd_get_root

(

RzCmd *

cmd

)

Get the root command descriptor.

Definition at line 230 of file cmd_api.c.

                                              {
    return cmd->root_cmd_desc;
}

References cmd.

Referenced by rz_cmd_batch_end(), rz_cmd_dex_init_handler(), rz_cmd_example_init(), rz_cmd_foreach_cmdname(), rz_cmd_get_help(), rz_cmd_java_init_handler(), and rzshell_cmddescs_init().

rz_cmd_macro_add()

RZ_API int rz_cmd_macro_add	(	RzCmdMacro *	mac,
		const char *	oname
	)

Definition at line 1558 of file cmd_api.c.

                                                                {
    struct rz_cmd_macro_item_t *macro;
    char *name, *args = NULL;
    // char buf[RZ_CMD_MAXLEN];
    RzCmdMacroItem *m;
    int macro_update;
    RzListIter *iter;
    char *pbody;
    // char *bufp;
    char *ptr;
    int lidx;
 
    if (!*oname) {
        rz_cmd_macro_list(mac);
        return 0;
    }
 
    name = strdup(oname);
    if (!name) {
        perror("strdup");
        return 0;
    }
 
    pbody = strchr(name, ';');
    if (!pbody) {
        eprintf("Invalid macro body\n");
        free(name);
        return false;
    }
    *pbody = '\0';
    pbody++;
 
    if (*name && name[1] && name[strlen(name) - 1] == ')') {
        eprintf("rz_cmd_macro_add: missing macro body?\n");
        free(name);
        return -1;
    }
 
    macro = NULL;
    ptr = strchr(name, ' ');
    if (ptr) {
        *ptr = '\0';
        args = ptr + 1;
    }
    macro_update = 0;
    rz_list_foreach (mac->macros, iter, m) {
        if (!strcmp(name, m->name)) {
            macro = m;
            free(macro->name);
            free(macro->code);
            free(macro->args);
            macro_update = 1;
            break;
        }
    }
    if (ptr) {
        *ptr = ' ';
    }
    if (!macro) {
        macro = rz_cmd_macro_item_new();
        if (!macro) {
            free(name);
            return 0;
        }
    }
 
    macro->name = strdup(name);
    macro->codelen = (pbody[0]) ? strlen(pbody) + 2 : 4096;
    macro->code = (char *)malloc(macro->codelen);
    *macro->code = '\0';
    macro->nargs = 0;
    if (!args) {
        args = "";
    }
    macro->args = strdup(args);
    ptr = strchr(macro->name, ' ');
    if (ptr != NULL) {
        *ptr = '\0';
        macro->nargs = rz_str_word_set0(ptr + 1);
    }
 
    for (lidx = 0; pbody[lidx]; lidx++) {
        if (pbody[lidx] == ';') {
            pbody[lidx] = '\n';
        } else if (pbody[lidx] == ')' && pbody[lidx - 1] == '\n') {
            pbody[lidx] = '\0';
        }
    }
    strncpy(macro->code, pbody, macro->codelen);
    macro->code[macro->codelen - 1] = 0;
    if (macro_update == 0) {
        rz_list_append(mac->macros, macro);
    }
    free(name);
    return 0;
}

References args, macro::args, eprintf, free(), regress::m, rz_cmd_macro_t::macros, malloc(), name, macro::name, NULL, rz_cmd_macro_item_new(), rz_cmd_macro_list(), rz_list_append(), rz_str_word_set0(), and strdup().

Referenced by rz_cmd_macro().

rz_cmd_macro_break()

RZ_API int rz_cmd_macro_break	(	RzCmdMacro *	mac,
		const char *	value
	)

Definition at line 2001 of file cmd_api.c.

                                                                  {
    mac->brk = 1;
    mac->brk_value = NULL;
    mac->_brk_value = (ut64)rz_num_math(mac->num, value);
    if (value && *value) {
        mac->brk_value = &mac->_brk_value;
    }
    return 0;
}

References rz_cmd_macro_t::_brk_value, rz_cmd_macro_t::brk, rz_cmd_macro_t::brk_value, NULL, rz_cmd_macro_t::num, rz_num_math(), ut64(), and value.

Referenced by rz_cmd_macro().

rz_cmd_macro_call()

RZ_API int rz_cmd_macro_call	(	RzCmdMacro *	mac,
		const char *	name
	)

Definition at line 1993 of file cmd_api.c.

                                                                {
    return macro_call(mac, name, false);
}

References macro_call().

Referenced by rz_cmd_macro(), rz_core_cmd_foreach(), and rz_interpret_macro_handler().

rz_cmd_macro_call_multiple()

RZ_API int rz_cmd_macro_call_multiple	(	RzCmdMacro *	mac,
		const char *	name
	)

Definition at line 1997 of file cmd_api.c.

                                                                         {
    return macro_call(mac, name, true);
}

References macro_call().

Referenced by rz_interpret_macro_multiple_handler().

rz_cmd_macro_cmd_args()

RZ_API int rz_cmd_macro_cmd_args	(	RzCmdMacro *	mac,
		const char *	ptr,
		const char *	args,
		int	nargs
	)

Definition at line 1729 of file cmd_api.c.

                                                                                                {
    int i, j;
    char *pcmd, cmd[RZ_CMD_MAXLEN];
    const char *arg = args;
 
    for (*cmd = i = j = 0; j < RZ_CMD_MAXLEN && ptr[j]; i++, j++) {
        if (ptr[j] == '$') {
            if (ptr[j + 1] >= '0' && ptr[j + 1] <= '9') {
                int wordlen;
                int w = ptr[j + 1] - '0';
                const char *word = rz_str_word_get0(arg, w);
                if (word && *word) {
                    wordlen = strlen(word);
                    if ((i + wordlen + 1) >= sizeof(cmd)) {
                        return -1;
                    }
                    memcpy(cmd + i, word, wordlen + 1);
                    i += wordlen - 1;
                    j++;
                } else {
                    eprintf("Undefined argument %d\n", w);
                }
            } else if (ptr[j + 1] == '@') {
                char off[32];
                int offlen;
                offlen = snprintf(off, sizeof(off), "%d",
                    mac->counter);
                if ((i + offlen + 1) >= sizeof(cmd)) {
                    return -1;
                }
                memcpy(cmd + i, off, offlen + 1);
                i += offlen - 1;
                j++;
            } else {
                cmd[i] = ptr[j];
                cmd[i + 1] = '\0';
            }
        } else {
            cmd[i] = ptr[j];
            cmd[i + 1] = '\0';
        }
    }
    for (pcmd = cmd; *pcmd && (*pcmd == ' ' || *pcmd == '\t'); pcmd++) {
        ;
    }
    // eprintf ("-pre %d\n", (int)mac->num->value);
    int xx = (*pcmd == ')') ? 0 : mac->cmd(mac->user, pcmd);
    // eprintf ("-pos %p %d\n", mac->num, (int)mac->num->value);
    return xx;
}

References args, rz_cmd_macro_t::cmd, cmd, rz_cmd_macro_t::counter, eprintf, i, memcpy(), off, RZ_CMD_MAXLEN, rz_str_word_get0(), snprintf, rz_cmd_macro_t::user, and w.

Referenced by macro_call().

rz_cmd_macro_fini()

RZ_API void rz_cmd_macro_fini

(

RzCmdMacro *

mac

)

Definition at line 1551 of file cmd_api.c.

                                               {
    rz_list_free(mac->macros);
    mac->macros = NULL;
}

References rz_cmd_macro_t::macros, NULL, and rz_list_free().

Referenced by rz_cmd_free().

rz_cmd_macro_init()

RZ_API void rz_cmd_macro_init

(

RzCmdMacro *

mac

)

Definition at line 1540 of file cmd_api.c.

                                               {
    mac->counter = 0;
    mac->_brk_value = 0;
    mac->brk_value = &mac->_brk_value;
    mac->cb_printf = (void *)printf;
    mac->num = NULL;
    mac->user = NULL;
    mac->cmd = NULL;
    mac->macros = rz_list_newf((RzListFree)rz_cmd_macro_item_free);
}

References rz_cmd_macro_t::_brk_value, rz_cmd_macro_t::brk_value, rz_cmd_macro_t::cb_printf, rz_cmd_macro_t::cmd, rz_cmd_macro_t::counter, rz_cmd_macro_t::macros, NULL, rz_cmd_macro_t::num, printf(), rz_cmd_macro_item_free(), rz_list_newf(), and rz_cmd_macro_t::user.

Referenced by rz_cmd_new().

rz_cmd_macro_item_free()

RZ_API void rz_cmd_macro_item_free

(

RzCmdMacroItem *

item

)

Definition at line 1530 of file cmd_api.c.

                                                         {
    if (!item) {
        return;
    }
    free(item->name);
    free(item->args);
    free(item->code);
    free(item);
}

References rz_cmd_macro_item_t::args, rz_cmd_macro_item_t::code, free(), and rz_cmd_macro_item_t::name.

Referenced by rz_cmd_macro_init().

rz_cmd_macro_item_new()

RZ_API RzCmdMacroItem* rz_cmd_macro_item_new

(

void

)

macro.c

Definition at line 1526 of file cmd_api.c.

                                                   {
    return RZ_NEW0(RzCmdMacroItem);
}

References RZ_NEW0.

Referenced by rz_cmd_macro_add().

rz_cmd_macro_label_process()

RZ_API char* rz_cmd_macro_label_process	(	RzCmdMacro *	mac,
		RzCmdMacroLabel *	labels,
		int *	labels_n,
		char *	ptr
	)

Definition at line 1780 of file cmd_api.c.

                                                                                                            {
    int i;
    for (; *ptr == ' '; ptr++) {
        ;
    }
    if (ptr[strlen(ptr) - 1] == ':' && !strchr(ptr, ' ')) {
        /* label detected */
        if (ptr[0] == '.') {
            //  eprintf("---> GOTO '%s'\n", ptr+1);
            /* goto */
            for (i = 0; i < *labels_n; i++) {
                //  eprintf("---| chk '%s'\n", labels[i].name);
                if (!strcmp(ptr + 1, labels[i].name)) {
                    return labels[i].ptr;
                }
            }
            return NULL;
        } else
            /* conditional goto */
            if (ptr[0] == '?' && ptr[1] == '!' && ptr[2] != '?') {
                if (mac->num && mac->num->value != 0) {
                    char *label = ptr + 3;
                    for (; *label == ' ' || *label == '.'; label++) {
                        ;
                    }
                    //      eprintf("===> GOTO %s\n", label);
                    /* goto label ptr+3 */
                    for (i = 0; i < *labels_n; i++) {
                        if (!strcmp(label, labels[i].name)) {
                            return labels[i].ptr;
                        }
                    }
                    return NULL;
                }
            } else
                /* conditional goto */
                if (ptr[0] == '?' && ptr[1] == '?' && ptr[2] != '?') {
                    if (mac->num->value == 0) {
                        char *label = ptr + 3;
                        for (; label[0] == ' ' || label[0] == '.'; label++) {
                            ;
                        }
                        //      eprintf("===> GOTO %s\n", label);
                        /* goto label ptr+3 */
                        for (i = 0; i < *labels_n; i++) {
                            if (!strcmp(label, labels[i].name)) {
                                return labels[i].ptr;
                            }
                        }
                        return NULL;
                    }
                } else {
                    for (i = 0; i < *labels_n; i++) {
                        //  eprintf("---| chk '%s'\n", labels[i].name);
                        if (!strcmp(ptr + 1, labels[i].name)) {
                            i = 0;
                            break;
                        }
                    }
                    /* Add label */
                    //  eprintf("===> ADD LABEL(%s)\n", ptr);
                    if (i == 0) {
                        strncpy(labels[*labels_n].name, ptr, 64);
                        labels[*labels_n].ptr = ptr + strlen(ptr) + 1;
                        *labels_n = *labels_n + 1;
                    }
                }
        return ptr + strlen(ptr) + 1;
    }
    return ptr;
}

References i, NULL, rz_cmd_macro_t::num, rz_cmd_macro_label_t::ptr, and rz_num_t::value.

Referenced by macro_call().

rz_cmd_macro_list()

RZ_API void rz_cmd_macro_list

(

RzCmdMacro *

mac

)

Definition at line 1680 of file cmd_api.c.

                                               {
    RzCmdMacroItem *m;
    int j, idx = 0;
    RzListIter *iter;
    rz_list_foreach (mac->macros, iter, m) {
        mac->cb_printf("%d (%s %s; ", idx, m->name, m->args);
        for (j = 0; m->code[j]; j++) {
            if (m->code[j] == '\n') {
                mac->cb_printf("; ");
            } else {
                mac->cb_printf("%c", m->code[j]);
            }
        }
        mac->cb_printf(")\n");
        idx++;
    }
}

References rz_cmd_macro_t::cb_printf, setup::idx, regress::m, and rz_cmd_macro_t::macros.

Referenced by rz_cmd_macro(), and rz_cmd_macro_add().

rz_cmd_macro_meta()

RZ_API void rz_cmd_macro_meta

(

RzCmdMacro *

mac

)

Definition at line 1699 of file cmd_api.c.

                                               {
    RzCmdMacroItem *m;
    int j;
    RzListIter *iter;
    rz_list_foreach (mac->macros, iter, m) {
        mac->cb_printf("(%s %s, ", m->name, m->args);
        for (j = 0; m->code[j]; j++) {
            if (m->code[j] == '\n') {
                mac->cb_printf("; ");
            } else {
                mac->cb_printf("%c", m->code[j]);
            }
        }
        mac->cb_printf(")\n");
    }
}

References rz_cmd_macro_t::cb_printf, regress::m, and rz_cmd_macro_t::macros.

Referenced by rz_cmd_macro().

rz_cmd_macro_rm()

RZ_API int rz_cmd_macro_rm	(	RzCmdMacro *	mac,
		const char *	_name
	)

Definition at line 1655 of file cmd_api.c.

                                                               {
    RzListIter *iter;
    RzCmdMacroItem *m;
    char *name = strdup(_name);
    if (!name) {
        return false;
    }
    char *ptr = strchr(name, ')');
    if (ptr) {
        *ptr = '\0';
    }
    bool ret = false;
    rz_list_foreach (mac->macros, iter, m) {
        if (!strcmp(m->name, name)) {
            rz_list_delete(mac->macros, iter);
            eprintf("Macro '%s' removed.\n", name);
            ret = true;
            break;
        }
    }
    free(name);
    return ret;
}

References eprintf, free(), regress::m, rz_cmd_macro_t::macros, rz_list_delete(), and strdup().

Referenced by rz_cmd_macro().

rz_cmd_new()

RZ_API RzCmd* rz_cmd_new

(

bool

has_cons

)

Definition at line 190 of file cmd_api.c.

                                        {
    int i;
    RzCmd *cmd = RZ_NEW0(RzCmd);
    if (!cmd) {
        return cmd;
    }
    cmd->has_cons = has_cons;
    for (i = 0; i < NCMDS; i++) {
        cmd->cmds[i] = NULL;
    }
    cmd->nullcallback = cmd->data = NULL;
    cmd->ht_cmds = ht_pp_new0();
    cmd->root_cmd_desc = create_cmd_desc(cmd, NULL, RZ_CMD_DESC_TYPE_GROUP, "", &root_help, true);
    rz_cmd_macro_init(&cmd->macro);
    rz_cmd_alias_init(cmd);
    return cmd;
}

References cmd, create_cmd_desc(), i, NCMDS, NULL, root_help, rz_cmd_alias_init(), RZ_CMD_DESC_TYPE_GROUP, rz_cmd_macro_init(), and RZ_NEW0.

Referenced by rz_core_cmd_new().

rz_cmd_parsed_args_addarg()

RZ_API bool rz_cmd_parsed_args_addarg	(	RzCmdParsedArgs *	a,
		const char *	arg
	)

Definition at line 2081 of file cmd_api.c.

                                                                           {
    char **tmp = realloc(a->argv, sizeof(a->argv[0]) * (a->argc + 2));
    if (!tmp) {
        return false;
    }
 
    a->argv = tmp;
    a->argv[a->argc] = strdup(arg);
    a->argv[a->argc + 1] = NULL;
    a->argc++;
    return true;
}

References a, NULL, realloc(), strdup(), and autogen_x86imm::tmp.

Referenced by args_preprocessing().

rz_cmd_parsed_args_argstr()

RZ_API char* rz_cmd_parsed_args_argstr

(

RzCmdParsedArgs *

a

)

Definition at line 2115 of file cmd_api.c.

                                                           {
    rz_return_val_if_fail(a && a->argv && a->argv[0], NULL);
    RzStrBuf *sb = rz_strbuf_new("");
    parsed_args_iterateargs(a, sb);
    return rz_strbuf_drain(sb);
}

References a, NULL, parsed_args_iterateargs(), rz_return_val_if_fail, rz_strbuf_drain(), rz_strbuf_new(), and sb.

Referenced by ts_node_handle_arg().

rz_cmd_parsed_args_cmd()

RZ_API const char* rz_cmd_parsed_args_cmd

(

RzCmdParsedArgs *

a

)

Definition at line 2135 of file cmd_api.c.

                                                              {
    rz_return_val_if_fail(a && a->argv && a->argv[0], NULL);
    return a->argv[0];
}

References a, NULL, and rz_return_val_if_fail.

Referenced by argv_call_cb(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), rz_cmd_call_parsed_args(), and rz_cmd_get_help().

rz_cmd_parsed_args_execstr()

RZ_API char* rz_cmd_parsed_args_execstr

(

RzCmdParsedArgs *

a

)

Definition at line 2122 of file cmd_api.c.

                                                            {
    rz_return_val_if_fail(a && a->argv && a->argv[0], NULL);
    RzStrBuf *sb = rz_strbuf_new(a->argv[0]);
    if (a->argc > 1 && a->has_space_after_cmd) {
        rz_strbuf_append(sb, " ");
    }
    parsed_args_iterateargs(a, sb);
    if (a->extra) {
        rz_strbuf_append(sb, a->extra);
    }
    return rz_strbuf_drain(sb);
}

References a, NULL, parsed_args_iterateargs(), rz_return_val_if_fail, rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_new(), and sb.

Referenced by call_cd().

rz_cmd_parsed_args_free()

RZ_API void rz_cmd_parsed_args_free

(

RzCmdParsedArgs *

a

)

Definition at line 2036 of file cmd_api.c.

                                                        {
    if (!a) {
        return;
    }
 
    int i;
    for (i = 0; i < a->argc; i++) {
        free(a->argv[i]);
    }
    free(a->argv);
    free(a);
}

References a, free(), and i.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), get_help_wrong_cmd(), iter_offsets_common(), and ts_node_handle_arg().

rz_cmd_parsed_args_new()

RZ_API RzCmdParsedArgs* rz_cmd_parsed_args_new	(	const char *	cmd,
		int	n_args,
		char **	args
	)

Definition at line 2013 of file cmd_api.c.

                                                                                         {
    rz_return_val_if_fail(cmd && n_args >= 0, NULL);
    RzCmdParsedArgs *res = RZ_NEW0(RzCmdParsedArgs);
    res->has_space_after_cmd = true;
    res->argc = n_args + 1;
    res->argv = RZ_NEWS0(char *, res->argc + 1);
    res->argv[0] = strdup(cmd);
    int i;
    for (i = 1; i < res->argc; i++) {
        res->argv[i] = strdup(args[i - 1]);
    }
    res->argv[res->argc] = NULL;
    return res;
}

References rz_cmd_parsed_args_t::argc, args, rz_cmd_parsed_args_t::argv, cmd, rz_cmd_parsed_args_t::has_space_after_cmd, i, NULL, RZ_NEW0, RZ_NEWS0, rz_return_val_if_fail, and strdup().

Referenced by rz_cmd_parsed_args_newargs(), and rz_cmd_parsed_args_newcmd().

rz_cmd_parsed_args_newargs()

RZ_API RzCmdParsedArgs* rz_cmd_parsed_args_newargs	(	int	n_args,
		char **	args
	)

Definition at line 2032 of file cmd_api.c.

                                                                            {
    return rz_cmd_parsed_args_new("", n_args, args);
}

References args, and rz_cmd_parsed_args_new().

Referenced by parse_args().

rz_cmd_parsed_args_newcmd()

RZ_API RzCmdParsedArgs* rz_cmd_parsed_args_newcmd

(

const char *

cmd

)

Definition at line 2028 of file cmd_api.c.

                                                                   {
    return rz_cmd_parsed_args_new(cmd, 0, NULL);
}

References cmd, NULL, and rz_cmd_parsed_args_new().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and get_help_wrong_cmd().

rz_cmd_parsed_args_setargs()

RZ_API bool rz_cmd_parsed_args_setargs	(	RzCmdParsedArgs *	a,
		int	n_args,
		char **	args
	)

Definition at line 2057 of file cmd_api.c.

                                                                                    {
    rz_return_val_if_fail(a && a->argv && a->argv[0], false);
    char **tmp = RZ_NEWS0(char *, n_args + 2);
    if (!tmp) {
        return false;
    }
    tmp[0] = strdup(a->argv[0]);
    int i;
    for (i = 1; i < n_args + 1; i++) {
        tmp[i] = strdup(args[i - 1]);
        if (!tmp[i]) {
            goto err;
        }
    }
    tmp[n_args + 1] = NULL;
    free_array(a->argv, a->argc);
    a->argv = tmp;
    a->argc = n_args + 1;
    return true;
err:
    free_array(tmp, n_args + 1);
    return false;
}

References a, args, err, free_array(), i, NULL, RZ_NEWS0, rz_return_val_if_fail, strdup(), and autogen_x86imm::tmp.

rz_cmd_parsed_args_setcmd()

RZ_API bool rz_cmd_parsed_args_setcmd	(	RzCmdParsedArgs *	a,
		const char *	cmd
	)

Definition at line 2094 of file cmd_api.c.

                                                                           {
    rz_return_val_if_fail(a && a->argv && a->argv[0], false);
    char *tmp = strdup(cmd);
    if (!tmp) {
        return false;
    }
    free(a->argv[0]);
    a->argv[0] = tmp;
    return true;
}

References a, cmd, free(), rz_return_val_if_fail, strdup(), and autogen_x86imm::tmp.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL().

rz_cmd_set_data()

RZ_API int rz_cmd_set_data	(	RzCmd *	cmd,
		void *	data
	)

Definition at line 523 of file cmd_api.c.

                                                   {
    cmd->data = data;
    return 1;
}

References cmd.

Referenced by rz_core_cmd_init().

rz_cmd_state_output_array_end()

RZ_API void rz_cmd_state_output_array_end

(

RzCmdStateOutput *

state

)

Mark the end of an array of elements in the output.

Output modes that support arrays will use this to mark the end of an array (e.g. JSON). Used by command handlers after "printing" a list of elements.

Definition at line 2572 of file cmd_api.c.

                                                                   {
    rz_return_if_fail(state);
    if (state->mode == RZ_OUTPUT_MODE_JSON || state->mode == RZ_OUTPUT_MODE_LONG_JSON) {
        rz_return_if_fail(state->d.pj);
        pj_end(state->d.pj);
    }
}

References pj_end(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_LONG_JSON, and rz_return_if_fail.

Referenced by cmd_debug_modules(), core_disassembly(), entries_initfini_print(), flag_zone_list(), open_maps_list(), print_source_info(), rz_analysis_basic_block_find_paths_handler(), rz_analysis_basic_block_list_handler(), rz_analysis_syscall_print_handler(), rz_analysis_var_global_list_show(), rz_cmd_debug_display_bt_handler(), rz_cmd_debug_list_bp_handler(), rz_cmd_disassemble_recursively_from_current_block_handler(), rz_cmd_disassemble_recursively_handler(), rz_cmd_disassemble_recursively_no_function_handler(), rz_cmd_disassemble_ropchain_handler(), rz_cmd_disassembly_all_possible_opcodes_handler(), rz_cmd_disassembly_basic_block_handler(), rz_cmd_info_demangle_list_handler(), rz_cmd_sizes_of_n_instructions_handler(), rz_core_analysis_bbs_info_print(), rz_core_asm_plugins_print(), rz_core_bin_archs_print(), rz_core_bin_basefind_print(), rz_core_bin_class_fields_print(), rz_core_bin_class_methods_print(), rz_core_bin_classes_print(), rz_core_bin_fields_print(), rz_core_bin_imports_print(), rz_core_bin_libs_print(), rz_core_bin_memory_print(), rz_core_bin_plugins_print(), rz_core_bin_print_source_line_info(), rz_core_bin_relocs_print(), rz_core_bin_resources_print(), rz_core_bin_sections_mapping_print(), rz_core_bin_sections_print(), rz_core_bin_segments_print(), rz_core_binfiles_print(), rz_core_core_plugins_print(), rz_core_debug_map_print(), rz_core_debug_plugins_print(), rz_core_disasm_pde(), rz_core_hash_plugins_print(), rz_core_io_plugins_print(), rz_core_lang_plugins_print(), rz_core_meta_print_list_all(), rz_core_meta_print_list_at(), rz_core_meta_print_list_in_function(), rz_core_parser_plugins_print(), rz_core_pdb_info_print(), rz_core_spaces_print(), rz_flag_describe_at_handler(), rz_flag_local_list_all_handler(), rz_flag_local_list_handler(), rz_flag_tag_list_handler(), rz_open_list_handler(), rz_seek_history_list_handler(), strings_print(), and symbols_print().

rz_cmd_state_output_array_start()

RZ_API void rz_cmd_state_output_array_start

(

RzCmdStateOutput *

state

)

Mark the start of an array of elements in the output.

Output modes that support arrays will use this to mark the start of an array (e.g. JSON). Used by command handlers before "printing" a list of elements.

Definition at line 2558 of file cmd_api.c.

                                                                     {
    rz_return_if_fail(state);
    if (state->mode == RZ_OUTPUT_MODE_JSON || state->mode == RZ_OUTPUT_MODE_LONG_JSON) {
        rz_return_if_fail(state->d.pj);
        pj_a(state->d.pj);
    }
}

References pj_a(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_LONG_JSON, and rz_return_if_fail.

Referenced by cmd_debug_modules(), core_disassembly(), entries_initfini_print(), flag_zone_list(), open_maps_list(), print_source_info(), rz_analysis_basic_block_find_paths_handler(), rz_analysis_basic_block_list_handler(), rz_analysis_syscall_print_handler(), rz_analysis_var_global_list_show(), rz_cmd_debug_display_bt_handler(), rz_cmd_debug_list_bp_handler(), rz_cmd_disassemble_recursively_from_current_block_handler(), rz_cmd_disassemble_recursively_handler(), rz_cmd_disassemble_recursively_no_function_handler(), rz_cmd_disassemble_ropchain_handler(), rz_cmd_disassembly_all_possible_opcodes_handler(), rz_cmd_disassembly_basic_block_handler(), rz_cmd_info_demangle_list_handler(), rz_cmd_sizes_of_n_instructions_handler(), rz_core_analysis_bbs_info_print(), rz_core_asm_plugins_print(), rz_core_bin_archs_print(), rz_core_bin_basefind_print(), rz_core_bin_class_fields_print(), rz_core_bin_class_methods_print(), rz_core_bin_classes_print(), rz_core_bin_fields_print(), rz_core_bin_imports_print(), rz_core_bin_libs_print(), rz_core_bin_memory_print(), rz_core_bin_plugins_print(), rz_core_bin_print_source_line_info(), rz_core_bin_relocs_print(), rz_core_bin_resources_print(), rz_core_bin_sections_mapping_print(), rz_core_bin_sections_print(), rz_core_bin_segments_print(), rz_core_binfiles_print(), rz_core_core_plugins_print(), rz_core_debug_map_print(), rz_core_debug_plugins_print(), rz_core_disasm_pde(), rz_core_hash_plugins_print(), rz_core_io_plugins_print(), rz_core_lang_plugins_print(), rz_core_meta_print_list_all(), rz_core_meta_print_list_at(), rz_core_meta_print_list_in_function(), rz_core_parser_plugins_print(), rz_core_pdb_info_print(), rz_core_spaces_print(), rz_flag_describe_at_handler(), rz_flag_local_list_all_handler(), rz_flag_local_list_handler(), rz_flag_tag_list_handler(), rz_open_list_handler(), rz_seek_history_list_handler(), strings_print(), and symbols_print().

rz_cmd_state_output_fini()

RZ_API void rz_cmd_state_output_fini

(

RZ_NONNULL RzCmdStateOutput *

state

)

Clear the inner fields of RzCmdStateOutput structure, but do not free it.

Definition at line 2603 of file cmd_api.c.

                                                                         {
    rz_return_if_fail(state);
 
    switch (state->mode) {
    case RZ_OUTPUT_MODE_JSON:
    case RZ_OUTPUT_MODE_LONG_JSON:
        pj_free(state->d.pj);
        state->d.pj = NULL;
        break;
    case RZ_OUTPUT_MODE_TABLE:
        rz_table_free(state->d.t);
        state->d.t = NULL;
        break;
    default:
        break;
    }
}

References NULL, pj_free(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_LONG_JSON, RZ_OUTPUT_MODE_TABLE, rz_return_if_fail, and rz_table_free().

Referenced by __listPlugins(), argv_call_cb(), cb_asmarch(), cb_asmcpu(), cb_dbgbackend(), get_bin_info(), rz_analysis_function_list_handler(), rz_cmd_debug_dmi(), rz_cmd_debug_map_current_handler(), rz_cmd_eval_color_highlight_list_current_handler(), rz_cmd_eval_color_highlight_list_handler(), rz_cmd_heap_chunks_graph_handler(), rz_cmd_state_output_free(), rz_core_visual_xrefs(), rz_eval_getset_handler(), rz_main_rizin(), rz_main_rz_asm(), and rz_main_rz_bin().

rz_cmd_state_output_free()

RZ_API void rz_cmd_state_output_free

(

RZ_NONNULL RzCmdStateOutput *

state

)

Free the RzCmdStateOutput structure and its inner fields appropriately.

Definition at line 2624 of file cmd_api.c.

                                                                         {
    rz_return_if_fail(state);
 
    rz_cmd_state_output_fini(state);
    free(state);
}

References free(), rz_cmd_state_output_fini(), and rz_return_if_fail.

Referenced by add_footer(), and rz_core_bin_print().

rz_cmd_state_output_init()

RZ_API bool rz_cmd_state_output_init	(	RZ_NONNULL RzCmdStateOutput *	state,
		RzOutputMode	mode
	)

Initialize a RzCmdStateOutput structure and its inner fields based on the provided mode.

Definition at line 2634 of file cmd_api.c.

                                                                                            {
    rz_return_val_if_fail(state, false);
 
    state->mode = mode;
    switch (state->mode) {
    case RZ_OUTPUT_MODE_TABLE:
        state->d.t = rz_table_new();
        if (!state->d.t) {
            return false;
        }
        break;
    case RZ_OUTPUT_MODE_JSON:
    case RZ_OUTPUT_MODE_LONG_JSON:
        state->d.pj = pj_new();
        if (!state->d.pj) {
            return false;
        }
        break;
    default:
        memset(&state->d, 0, sizeof(state->d));
        break;
    }
    return true;
}

References memset(), pj_new(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_LONG_JSON, RZ_OUTPUT_MODE_TABLE, rz_return_val_if_fail, and rz_table_new().

Referenced by __listPlugins(), add_header(), argv_call_cb(), cb_asmarch(), cb_asmcpu(), cb_dbgbackend(), get_bin_info(), rz_analysis_function_list_handler(), rz_cmd_debug_dmi(), rz_cmd_debug_map_current_handler(), rz_cmd_eval_color_highlight_list_current_handler(), rz_cmd_eval_color_highlight_list_handler(), rz_cmd_heap_chunks_graph_handler(), rz_core_visual_xrefs(), rz_eval_getset_handler(), rz_main_rizin(), rz_main_rz_asm(), and rz_main_rz_bin().

rz_cmd_state_output_print()

RZ_API void rz_cmd_state_output_print

(

RZ_NONNULL RzCmdStateOutput *

state

)

Print the output accumulated in state to RzCons, if necessary.

Some output modes like JSON and TABLE accumulate their output in their respective data structures, thus it is needed to print them to have the output on screen. This function takes care of that, doing nothing in case the output was already printed to console for those types that output as they go (e.g. STANDARD, QUIET).

Definition at line 2668 of file cmd_api.c.

                                                                          {
    rz_return_if_fail(state);
 
    char *s;
    switch (state->mode) {
    case RZ_OUTPUT_MODE_JSON:
    case RZ_OUTPUT_MODE_LONG_JSON:
        rz_cons_println(pj_string(state->d.pj));
        break;
    case RZ_OUTPUT_MODE_TABLE:
        s = rz_table_tostring(state->d.t);
        rz_cons_printf("%s", s);
        free(s);
        break;
    default:
        break;
    }
}

References free(), pj_string(), rz_cons_printf(), rz_cons_println(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_LONG_JSON, RZ_OUTPUT_MODE_TABLE, rz_return_if_fail, rz_table_tostring(), and s.

Referenced by __listPlugins(), argv_call_cb(), cb_asmarch(), cb_asmcpu(), cb_dbgbackend(), get_bin_info(), rz_cmd_debug_dmi(), rz_cmd_debug_map_current_handler(), rz_cmd_eval_color_highlight_list_current_handler(), rz_cmd_eval_color_highlight_list_handler(), rz_cmd_heap_chunks_graph_handler(), rz_eval_getset_handler(), rz_main_rizin(), and rz_main_rz_asm().

rz_cmd_state_output_set_columnsf()

RZ_API void rz_cmd_state_output_set_columnsf	(	RzCmdStateOutput *	state,
		const char *	fmt,
			...
	)

Specify the columns of the command output.

Parameters

state	Reference to RzCmdStateOutput
fmt	String containing the numer and types of the columns (see RzTable for a reference of the possible types)
...	Variable number of strings that specify the names of the columns. There should be enough string as characters in fmt .

Definition at line 2589 of file cmd_api.c.

                                                                                            {
    rz_return_if_fail(state);
    va_list ap;
    va_start(ap, fmt);
    if (state->mode == RZ_OUTPUT_MODE_TABLE) {
        rz_return_if_fail(state->d.t);
        rz_table_set_vcolumnsf(state->d.t, fmt, ap);
    }
    va_end(ap);
}

References RZ_OUTPUT_MODE_TABLE, rz_return_if_fail, and rz_table_set_vcolumnsf().

Referenced by entries_initfini_print(), flag_print(), open_maps_list(), rz_analysis_basic_block_list_handler(), rz_cmd_debug_list_bp_handler(), rz_cmd_info_demangle_list_handler(), rz_core_analysis_bb_info_print(), rz_core_analysis_bbs_info_print(), rz_core_bin_archs_print(), rz_core_bin_basefind_print(), rz_core_bin_class_fields_print(), rz_core_bin_class_methods_print(), rz_core_bin_classes_print(), rz_core_bin_fields_print(), rz_core_bin_imports_print(), rz_core_bin_libs_print(), rz_core_bin_main_print(), rz_core_bin_memory_print(), rz_core_bin_plugin_print(), rz_core_bin_relocs_print(), rz_core_bin_resources_print(), rz_core_bin_sections_mapping_print(), rz_core_bin_segments_print(), rz_core_binfiles_print(), rz_core_binxtr_plugin_print(), rz_core_file_info_print(), rz_core_io_plugins_print(), rz_open_list_handler(), rz_open_maps_list_cur_handler(), rz_open_show_current_handler(), sections_headers_setup(), strings_print(), and symbols_print().

rz_cmd_unescape_arg()

RZ_API char* rz_cmd_unescape_arg	(	const char *	arg,
		RzCmdEscape	esc
	)

Returns an heap-allocated unescaped string. It is the opposite of rz_cmd_escape_arg.

Definition at line 2536 of file cmd_api.c.

                                                                   {
    switch (esc) {
    case RZ_CMD_ESCAPE_ONE_ARG:
        return unescape_special_chars(arg, SPECIAL_CHARS_REGULAR_SINGLE);
    case RZ_CMD_ESCAPE_MULTI_ARG:
        return unescape_special_chars(arg, SPECIAL_CHARS_REGULAR);
    case RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG:
        return unescape_special_chars(arg, SPECIAL_CHARS_DOUBLE_QUOTED);
    case RZ_CMD_ESCAPE_SINGLE_QUOTED_ARG:
        return unescape_special_chars(arg, SPECIAL_CHARS_SINGLE_QUOTED);
    case RZ_CMD_ESCAPE_PF_ARG:
        return unescape_special_chars(arg, SPECIAL_CHARS_PF);
    }
    rz_return_val_if_reached(strdup(arg));
}

References RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG, RZ_CMD_ESCAPE_MULTI_ARG, RZ_CMD_ESCAPE_ONE_ARG, RZ_CMD_ESCAPE_PF_ARG, RZ_CMD_ESCAPE_SINGLE_QUOTED_ARG, rz_return_val_if_reached, SPECIAL_CHARS_DOUBLE_QUOTED, SPECIAL_CHARS_PF, SPECIAL_CHARS_REGULAR, SPECIAL_CHARS_REGULAR_SINGLE, SPECIAL_CHARS_SINGLE_QUOTED, strdup(), and unescape_special_chars().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), do_handle_ts_unescape_arg(), and rz_core_cmd_subst_i().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_cmd

)

rz_output_mode_to_char()

RZ_IPI int rz_output_mode_to_char

(

RzOutputMode

mode

)

Definition at line 73 of file cmd_api.c.

                                                     {
    size_t i;
    for (i = 0; i < RZ_ARRAY_SIZE(argv_modes); i++) {
        if (argv_modes[i].mode == mode) {
            return argv_modes[i].suffix[0];
        }
    }
    return -1;
}

References argv_modes, i, RZ_ARRAY_SIZE, and argv_modes_t::suffix.

Referenced by rz_cmd_debug_trace_graph_handler().

rz_output_mode_to_summary()

RZ_IPI const char* rz_output_mode_to_summary

(

RzOutputMode

mode

)

Definition at line 83 of file cmd_api.c.

                                                                {
    size_t i;
    for (i = 0; i < RZ_ARRAY_SIZE(argv_modes); i++) {
        if (argv_modes[i].mode == mode) {
            return argv_modes[i].summary_suffix;
        }
    }
    return "";
}

References argv_modes, i, RZ_ARRAY_SIZE, and argv_modes_t::summary_suffix.

Referenced by fill_usage_strbuf().

show_children_shortcut()

static bool show_children_shortcut ( const RzCmdDesc *  cd )

static

Definition at line 877 of file cmd_api.c.

                                                        {
    return cd->n_children || cd->help->options || cd->type == RZ_CMD_DESC_TYPE_OLDINPUT ||
        has_cd_submodes(cd);
}

References cd, has_cd_submodes(), and RZ_CMD_DESC_TYPE_OLDINPUT.

Referenced by calc_padding_len(), do_print_child_help(), and fill_usage_strbuf().

sort_groups()

static void sort_groups ( RzCmdDesc *  group )

static

Definition at line 244 of file cmd_api.c.

                                          {
    void **it_cd;
 
    if (group->help->sort_subcommands) {
        rz_pvector_sort(&group->children, cd_sort);
    }
    rz_cmd_desc_children_foreach(group, it_cd) {
        RzCmdDesc *cd = *(RzCmdDesc **)it_cd;
        if (cd->n_children) {
            sort_groups(cd);
        }
    }
}

References cd, cd_sort(), rz_cmd_desc_t::children, rz_cmd_desc_t::help, rz_pvector_sort(), and rz_cmd_desc_help_t::sort_subcommands.

Referenced by rz_cmd_batch_end().

strbuf_append_calc()

static size_t strbuf_append_calc ( RzStrBuf *  sb, const char *  s  )

static

Definition at line 807 of file cmd_api.c.

                                                              {
    rz_strbuf_append(sb, s);
    return strlen(s);
}

References rz_strbuf_append(), s, and sb.

Referenced by do_print_child_help(), fill_children_chars(), and fill_usage_strbuf().

strlen0()

static size_t strlen0 ( const char *  s )

static

Definition at line 803 of file cmd_api.c.

                                     {
    return s ? strlen(s) : 0;
}

References s.

Referenced by calc_padding_len(), and fill_details_do().

suffix2mode()

static RzOutputMode suffix2mode ( const char *  suffix )

static

Definition at line 269 of file cmd_api.c.

                                                    {
    size_t i;
    for (i = 0; i < RZ_ARRAY_SIZE(argv_modes); i++) {
        if (!strcmp(suffix, argv_modes[i].suffix)) {
            return argv_modes[i].mode;
        }
    }
    return 0;
}

References argv_modes, i, argv_modes_t::mode, RZ_ARRAY_SIZE, and suffix.

Referenced by cd_suffix2mode(), and is_valid_argv_modes().

unescape_special_chars()

static char* unescape_special_chars ( const char *  s, const char *  special_chars  )

static

Definition at line 2493 of file cmd_api.c.

                                                                              {
    char *dst = RZ_NEWS(char, strlen(s) + 1);
    int i, j = 0;
 
    for (i = 0; s[i]; i++) {
        if (s[i] != '\\' || !strchr(special_chars, s[i + 1])) {
            dst[j++] = s[i];
            continue;
        }
        dst[j++] = s[++i];
        if (!s[i]) {
            break;
        }
    }
    dst[j++] = '\0';
    return dst;
}

References dst, i, RZ_NEWS, and s.

Referenced by rz_cmd_unescape_arg().

update_minmax_len()

static void update_minmax_len ( RzCmdDesc *  cd, size_t *  max_len, size_t *  min_len, bool  show_children  )

static

Definition at line 1074 of file cmd_api.c.

                                                                                                   {
    size_t val = calc_padding_len(cd, cd->name, show_children);
    *max_len = val > *max_len ? val : *max_len;
    *min_len = val < *min_len ? val : *min_len;
}

References calc_padding_len(), cd, and val.

Referenced by fill_argv_modes_help_strbuf(), and group_get_help().

Variable Documentation

argv_modes

const struct argv_modes_t argv_modes[]

static

Initial value:

= {
    { "", "", RZ_OUTPUT_MODE_STANDARD },
    { "j", " (JSON mode)", RZ_OUTPUT_MODE_JSON },
    { "*", " (rizin mode)", RZ_OUTPUT_MODE_RIZIN },
    { "q", " (quiet mode)", RZ_OUTPUT_MODE_QUIET },
    { "Q", " (quietest mode)", RZ_OUTPUT_MODE_QUIETEST },
    { "k", " (sdb mode)", RZ_OUTPUT_MODE_SDB },
    { "l", " (verbose mode)", RZ_OUTPUT_MODE_LONG },
    { "J", " (verbose JSON mode)", RZ_OUTPUT_MODE_LONG_JSON },
    { "t", " (table mode)", RZ_OUTPUT_MODE_TABLE },
}

Referenced by cmd_foreach_cmdname_modes(), fill_argv_modes_help_strbuf(), fill_modes_children_chars(), rz_output_mode_to_char(), rz_output_mode_to_summary(), and suffix2mode().

not_defined_help

const RzCmdDescHelp not_defined_help

static

Initial value:

= {
    .usage = "Usage not defined",
    .summary = "Help summary not defined",
    .description = "Help description not defined.",
}

Definition at line 45 of file cmd_api.c.

Referenced by create_cmd_desc().

root_help

const RzCmdDescHelp root_help

static

Initial value:

= {
    .usage = "[.][times][cmd][~grep][@[@iter]addr][|>pipe] ; ...",
    .description = "",
    .sort_subcommands = true,
}

Definition at line 51 of file cmd_api.c.

Referenced by rz_cmd_new().

SPECIAL_CHARS_DOUBLE_QUOTED

const char* SPECIAL_CHARS_DOUBLE_QUOTED = "\"$()`"

static

Definition at line 42 of file cmd_api.c.

Referenced by rz_cmd_escape_arg(), and rz_cmd_unescape_arg().

SPECIAL_CHARS_PF

const char* SPECIAL_CHARS_PF = "@;~$#|`\"'<>"

static

Definition at line 41 of file cmd_api.c.

Referenced by rz_cmd_escape_arg(), and rz_cmd_unescape_arg().

SPECIAL_CHARS_REGULAR

const char* SPECIAL_CHARS_REGULAR = "@;~$#|`\"'()<>"

static

Definition at line 39 of file cmd_api.c.

Referenced by rz_cmd_escape_arg(), and rz_cmd_unescape_arg().

SPECIAL_CHARS_REGULAR_SINGLE

const char* SPECIAL_CHARS_REGULAR_SINGLE = "@;~$#|`\"'()<> "

static

Definition at line 40 of file cmd_api.c.

Referenced by rz_cmd_escape_arg(), and rz_cmd_unescape_arg().

SPECIAL_CHARS_SINGLE_QUOTED

const char* SPECIAL_CHARS_SINGLE_QUOTED = "'"

static

Definition at line 43 of file cmd_api.c.

Referenced by rz_cmd_escape_arg(), and rz_cmd_unescape_arg().

value

int value = 0

static

Definition at line 93 of file cmd_api.c.

Referenced by __asm_equ_new(), _aeli_iter(), _insert_into_disk(), _restore_memory_cb(), _write_asm(), _zip_win32_named_op_create_temp_output(), aarch64_ext_addr_regoff(), aarch64_ext_aimm(), aarch64_ext_cond(), aarch64_ext_ft(), aarch64_ext_hint(), aarch64_ext_ldst_reglist(), aarch64_ext_ldst_reglist_r(), aarch64_ext_limm(), aarch64_ext_pstatefield(), aarch64_ext_reg_extended(), aarch64_ext_reg_shifted(), aarch64_ext_reglane(), aarch64_ext_sysins_op(), aarch64_find_alias_opcode(), aarch64_find_next_alias_opcode(), aarch64_find_next_opcode(), aarch64_logical_immediate_p(), aarch64_print_operand(), aarch64_wide_constant_p(), addr_hint_foreach_cb(), analBars(), anop32(), arc_aux_reg_name(), arc_opcode_init_tables(), arc_opcode_lookup_suffix(), avr_il_assign_bool(), basefind_array_has(), basefind_create_pointer_map(), be16(), be24(), bfd_getm32(), bflt_load_relocs(), bin_elf_versioninfo_versym(), bin_pe_init_sections(), bs_option(), cabd_param(), calculate_luhn(), cb_dirtmp(), cb_log_config_colors(), cb_log_config_file(), cb_log_config_srcinfo(), check_rom_exists(), cmd_print_bars(), common_write_value_handler(), convert_movebitmask_to_mov(), convert_movewide_to_mov(), create_temp_file(), cs_option(), decode_asimd_fcvt(), decode_fcvt(), decode_limm(), decode_parameter(), decode_sizeq(), decode_sve_aimm(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), deflatePrime(), do_handle_substitution_cmd(), do_misc_decoding(), do_special_decoding(), dofwd(), dump_element(), emit_equ(), extract_all_fields(), extract_field_2(), extract_fields(), extract_ld_offset(), extract_reg(), extract_st_offset(), flirt_write_module(), foreach_reg_set_or_clear(), format_reg_value(), from_oct(), gdbr_write_reg(), gdbr_write_register(), gdbr_write_registers(), get_arm64_hwwp_values(), get_arm_hwbp_values(), get_cond_from_value(), get_enum_type(), get_greg_qualifier_from_value(), get_regname(), get_top_bit(), get_union_type(), get_versym_entry_sdb_from_verdef(), get_versym_entry_sdb_from_verneed(), getarg(), getvalue(), hash_cfg_config_compare(), hash_print_crypto(), hash_print_digest(), hash_string(), hppa_field_adjust(), hppa_rebuild_insn(), inflatePrime(), insert(), insert_addr_wb(), insert_base(), insert_cond(), insert_field(), insert_field_2(), insert_jumpflags(), insert_nullify(), insert_offset(), insert_reg(), insert_reladdr(), insert_s12(), insert_s15(), insert_u16(), insert_u8(), insert_ul16(), insert_update(), insert_uu16(), is_pc_inside_module(), is_pc_inside_windmodule(), isMask(), isShiftedMask(), java_constant_pool_stringify(), lang_byte_array_c_cpp(), lang_byte_array_java(), lang_byte_array_kotlin(), lookup_value(), LZ4_write16(), LZ4_write32(), LZ4_writeLE16(), macro_call(), main(), main_print_var(), make_int_16(), make_int_8(), map_enum(), memlimit_show(), oabd_param(), p_b_symbol(), parse_array_type(), parse_atomic_type(), parse_attr_value(), parse_byte(), parse_codeview_fld_attribute(), parse_codeview_func_attribute(), parse_codeview_modifier(), parse_codeview_pointer_attribute(), parse_codeview_property(), parse_enumerate(), parse_enumerator(), parse_memlimit(), parse_options(), parse_struct_member(), parse_typedef(), prompt_offset_and_seek(), prompt_offset_and_seek_file(), qnxr_write_reg(), qnxr_write_register(), rc_direct(), rd_factor(), rd_value(), read_imm_16(), read_imm_32(), read_imm_64(), read_imm_8(), read_n_bits(), rebase_bytes_v1(), references_handler(), reg_has_changed(), reg_offset_cmp(), replace_cmd_kv(), replace_cmd_kv_file(), replace_seq(), resource_value(), restore_memory_cb(), rotate_left_32(), rsp_op(), rz_analysis_switch_op_add_case(), rz_analysis_value_free(), rz_analysis_value_to_string(), rz_asm_code_set_equ(), rz_asm_pseudo_fill(), rz_atomic_bool_get(), rz_atomic_bool_set(), rz_bin_elf_add_addr(), rz_bin_elf_add_off(), rz_bin_elf_mul_addr(), rz_bin_elf_mul_off(), rz_buf_sleb128(), rz_buf_uleb128(), rz_buf_write8(), rz_buf_write8_at(), rz_bv_new_from_st64(), rz_bv_new_from_ut64(), rz_bv_set_from_st64(), rz_bv_set_from_ut64(), rz_cf_key_value_new(), rz_cf_value_array_add(), rz_cf_value_array_print(), rz_cf_value_bool_new(), rz_cf_value_dict_parse(), rz_cf_value_free(), rz_cf_value_print(), rz_cmd_macro_break(), rz_config_eval(), rz_config_node_new(), rz_config_set(), rz_config_set_b(), rz_config_set_cb(), rz_core_analysis_hasrefs(), rz_core_analysis_hasrefs_to_depth(), rz_core_analysis_il_vm_set(), rz_core_cmd_foreach3(), rz_core_cmd_subst_i(), rz_core_flirt_arch_from_id(), rz_core_print_string_c_cpp(), rz_core_search_value_in_range(), rz_core_write_value_at(), rz_core_write_value_inc_at(), rz_debruijn_offset(), rz_egg_config_handler(), rz_eval_getset_handler(), rz_fletcher64_update(), rz_il_event_mem_read_new(), rz_il_event_var_read_new(), rz_il_handler_store(), rz_il_handler_storew(), rz_il_mem_store(), rz_il_mem_storew(), rz_il_op_effect_free(), rz_il_op_new_bitv(), rz_il_op_new_bitv_from_st64(), rz_il_op_new_bitv_from_ut64(), rz_il_op_new_store(), rz_il_op_new_storew(), rz_il_vm_mem_load(), rz_il_vm_mem_loadw(), rz_il_vm_mem_store(), rz_il_vm_mem_storew(), rz_il_vm_status_handler(), rz_interval_node_all_in(), rz_interval_tree_all_in(), rz_is_valid_input_num_value(), rz_lang_define(), rz_mod255_update(), rz_num_get_input_value(), rz_num_is_valid_input(), rz_reg_set_double(), rz_reg_set_longdouble(), rz_reg_set_value(), rz_regs_show_valgroup(), rz_serialize_analysis_switch_op_load(), rz_sleb128(), rz_sys_setenv(), rz_type_enum_bitfield_handler(), rz_type_format_uleb(), rz_type_print_value_handler(), rz_write_debruijn_find_handler(), rz_write_versioned_vle(), rz_xor16_update(), rz_xor8_update(), rzil_print_register_bool(), sdb_concat(), sdb_dump_dupnext(), sdb_get_len(), sdb_ht_insert(), sdb_ht_internal_insert(), sdb_ht_update(), sdb_uncat(), set_bcj(), set_delta(), set_lzma(), shared_ht_up_insert(), sign_extend(), sign_extend2(), sort_loclists(), sparc_decode_asi(), sparc_decode_membar(), sparc_decode_prefetch(), sparc_decode_sparclet_cpreg(), str_to_uint64(), symbols(), symbols_contain(), system_apply_env_var(), TAG_CALLBACK(), types_enum_member_find(), types_enum_member_find_all(), uint64_to_nicestr(), uint64_to_str(), update(), update_key(), uv__custom_sem_init(), uv__sem_init(), uv__socket_sockopt(), uv_key_get(), uv_key_set(), uv_os_setenv(), uv_recv_buffer_size(), uv_sem_init(), uv_send_buffer_size(), uv_tty_write_bufs(), uv_udp_set_broadcast(), uv_uptime(), valPrint(), value_aligned_p(), value_fit_signed_field_p(), value_fit_unsigned_field_p(), value_in_range_p(), vtable_addr_in_text_section(), vtable_is_addr_vtable_start_itanium(), vtable_is_value_in_text_section(), w32_hwbp_arm_add(), w32_hwbp_arm_del(), write_n_bits(), DotZLib.GZipStream::WriteByte(), zip_random_uint32(), and zip_set_archive_flag().