cmd.c File Reference

#include <rz_core.h>
#include <rz_analysis.h>
#include <rz_cons.h>
#include <rz_cmd.h>
#include <rz_windows.h>
#include <stdint.h>
#include <sys/types.h>
#include <ctype.h>
#include <stdarg.h>
#include <cmd_descs.h>
#include <tree_sitter/api.h>
#include "cmd_debug.c"
#include "cmd_analysis.c"
#include "cmd_macro.c"
#include "cmd_magic.c"
#include "cmd_search.c"
#include "cmd_print.c"
#include "cmd_help.c"
#include "rz-shell-parser-cmds.inc"

Go to the source code of this file.

Classes
struct	duplicate_flag_t
struct	exec_command_t
struct	tsr2cmd_state
struct	tsr2cmd_edit
struct	ts_data_symbol_map
struct	_search_help

Macros
#define	INTERACTIVE_MAX_REP   1024
#define	DEPRECATED_DEFINE_CMD_DESCRIPTOR(core, cmd_)
#define	DEPRECATED_DEFINE_CMD_DESCRIPTOR_WITH_DETAIL(core, cmd_)
#define	DEPRECATED_DEFINE_CMD_DESCRIPTOR_WITH_DETAIL2(core, cmd_)
#define	DEPRECATED_DEFINE_CMD_DESCRIPTOR_SPECIAL(core, cmd_, named_cmd)
#define	cmdstr(x)   rz_str_newf(x " '%s'", file);
#define	TS_START_END(node, start, end)
#define	DEFINE_SYMBOL_TS_FCN(name)   TSSymbol ts_##name##_symbol
#define	DEFINE_IS_TS_FCN(name)
#define	DEFINE_IS_TS_FCN_AND_SYMBOL(name)
#define	DEFINE_HANDLE_TS_FCN(name)
#define	DEFINE_HANDLE_TS_FCN_AND_SYMBOL(name)
#define	UPDATE_CMD_STATUS_RES(res, cmd_res, label)
#define	HANDLER_RULE_OP(name)   { #name, handle_ts_##name },
#define	RULE_OP(name)
#define	RULE_OP(name)   { #name, &ts_##name##_symbol },
#define	HANDLER_RULE_OP(name)   RULE_OP(name)

Typedefs
typedef RzCmdStatus(*	ts_handler) (struct tsr2cmd_state *state, TSNode node)
typedef struct _search_help	RzHelpSearch

Enumerations
enum	dbt_commands_mode { DBT_COMMANDS_MODE_ADDR , DBT_COMMANDS_MODE_BP , DBT_COMMANDS_MODE_SP }

Functions
TSLanguage *	tree_sitter_rzcmd ()
RZ_API void	rz_save_panels_layout (RzCore *core, const char *_name)
RZ_API bool	rz_load_panels_layout (RzCore *core, const char *_name)
static RzCmdDescriptor *	cmd_descriptor (const char *cmd, const char *help[])
static int	rz_core_cmd_subst_i (RzCore *core, char *cmd, char *colon, bool *tmpseek)
RZ_API void	rz_core_cmd_help (const RzCore *core, const char *help[])
static bool	duplicate_flag (RzFlagItem *flag, void *u)
static void	recursive_help_go (RzCore *core, int detail, RzCmdDescriptor *desc)
static void	recursive_help (RzCore *core, int detail, const char *cmd_prefix)
RZ_IPI bool	rz_core_cmd_lastcmd_repeat (RzCore *core, bool next)
static int	rz_core_cmd_nullcallback (void *data)
RZ_IPI int	rz_cmd_alias (void *data, const char *input)
static int	lang_run_file (RzCore *core, RzLang *lang, const char *file)
static char *	langFromHashbang (RzCore *core, const char *file)
RZ_API bool	rz_core_run_script (RzCore *core, RZ_NONNULL const char *file)
static bool	callback_foreach_kv (void *user, const char *k, const char *v)
RZ_API int	rz_line_hist_sdb_up (RzLine *line)
RZ_API int	rz_line_hist_sdb_down (RzLine *line)
RZ_IPI void	rz_core_kuery_print (RzCore *core, const char *k)
RZ_IPI int	rz_cmd_kuery (void *data, const char *input)
RZ_IPI int	rz_cmd_panels (void *data, const char *input)
RZ_IPI int	rz_cmd_visual (void *data, const char *input)
RZ_IPI RzCmdStatus	rz_push_escaped_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_pointer_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_last_output_handler (RzCore *core, int argc, const char **argv)
RZ_API int	rz_core_cmd_pipe_old (RzCore *core, char *rizin_cmd, char *shell_cmd)
static char *	parse_tmp_evals (RzCore *core, const char *str)
static bool	is_macro_command (const char *ptr)
static char *	find_ch_after_macro (char *ptr, char ch)
static int	rz_core_cmd_subst (RzCore *core, char *cmd)
static char *	find_eoq (char *p)
static char *	findSeparator (char *p)
static void	tmpenvs_free (void *item)
static bool	set_tmp_arch (RzCore *core, char *arch, char **tmparch)
static bool	set_tmp_bits (RzCore *core, int bits, char **tmpbits, int *cmd_ignbithints)
static bool	copy_into_flagitem_list (RzFlagItem *flg, void *u)
static void	foreach_pairs (RzCore *core, const char *cmd, const char *each)
RZ_API int	rz_core_cmd_foreach3 (RzCore *core, const char *cmd, char *each)
static void	foreachOffset (RzCore *core, const char *_cmd, const char *each)
static int	bb_cmp (const void *a, const void *b)
RZ_API int	rz_core_cmd_foreach (RzCore *core, const char *cmd, char *each)
static int	run_cmd_depth (RzCore *core, char *cmd)
static char *	ts_node_sub_string (TSNode node, const char *cstr)
static char *	ts_node_sub_parent_string (TSNode parent, TSNode node, const char *cstr)
static RzCmdStatus	handle_ts_stmt (struct tsr2cmd_state *state, TSNode node)
static RzCmdStatus	handle_ts_stmt_tmpseek (struct tsr2cmd_state *state, TSNode node)
static RzCmdStatus	core_cmd_tsrzcmd (RzCore *core, const char *cstr, bool split_lines, bool log)
static char *	system_exec_stdin (bool is_pipe, int argc, char **argv, const ut8 *input, int input_len, int *length)
static ut8 *	core_cmd_raw_node (RzCore *core, struct tsr2cmd_state *state, TSNode rizin_cmd, int *length)
static RzCmdStatus	core_cmd_pipe (RzCore *core, struct tsr2cmd_state *state, TSNode rizin_cmd, int argc, char **argv)
	Executes a rizin command and pipes the result to the stdin of the program specified in argc/argv. More...
static struct tsr2cmd_edit *	create_cmd_edit (struct tsr2cmd_state *state, TSNode arg, char *new_text)
static void	replace_whitespaces (char *s, char ch)
void	free_tsr2cmd_edit (struct tsr2cmd_edit *edit)
static char *	do_handle_substitution_cmd (struct tsr2cmd_state *state, TSNode inn_cmd)
static void	handle_cmd_substitution_arg (struct tsr2cmd_state *state, TSNode arg, RzList *edits)
static bool	is_group_of_args (TSNode args)
static bool	is_arg (TSNode args)
static bool	is_handled_args (TSNode args)
static void	handle_substitution_args (struct tsr2cmd_state *state, TSNode args, RzList *edits)
static char *	do_handle_ts_unescape_arg (struct tsr2cmd_state *state, TSNode arg, bool do_unwrap)
static RzCmdParsedArgs *	parse_args (struct tsr2cmd_state *state, TSNode args, bool do_unwrap)
static TSTree *	apply_edits (struct tsr2cmd_state *state, RzList *edits)
static void	substitute_args_fini (struct tsr2cmd_state *state)
static void	substitute_args_init (struct tsr2cmd_state *state, TSNode command)
static bool	substitute_args_do (struct tsr2cmd_state *state, RzList *edits, TSNode *new_command)
static bool	substitute_args (struct tsr2cmd_state *state, TSNode args, TSNode *new_command)
static RzCmdParsedArgs *	ts_node_handle_arg_prargs (struct tsr2cmd_state *state, TSNode command, TSNode arg, uint32_t child_idx, bool do_unwrap)
static char *	ts_node_handle_arg (struct tsr2cmd_state *state, TSNode command, TSNode arg, uint32_t child_idx)
static void	get_help_wrong_cmd (RzCore *core, const char *cmdname)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (arged_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (legacy_quoted_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (repeat_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (redirect_stmt)
static bool	help_search_cmd_desc_entry (RzCmd *cmd, const RzCmdDesc *cd, void *user)
RZ_IPI RzCmdStatus	rz_cmd_help_search_handler (RzCore *core, int argc, const char **argv, RzOutputMode mode)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (help_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_seek_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_blksz_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_fromto_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_arch_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_bits_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_nthi_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_eval_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_fs_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_reli_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_kuery_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_fd_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_reg_stmt)
static bool	handle_tmp_desc (struct tsr2cmd_state *state, TSNode command, const ut8 *buf, int sz)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_file_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_string_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_value_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (tmp_hex_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_flags_stmt)
static bool	iter_dbt_commands (struct tsr2cmd_state *state, TSNode node, enum dbt_commands_mode mode)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_dbta_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_dbtb_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_dbts_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_file_lines_stmt)
static RzCmdStatus	do_iter_offsets (RzCore *core, struct tsr2cmd_state *state, TSNode *command, RzCmdParsedArgs *a, bool has_size)
static RzCmdStatus	iter_offsets_common (struct tsr2cmd_state *state, TSNode node, bool has_size)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_offsets_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_offsetssizes_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_instrs_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_step_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_hit_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_bbs_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_interpret_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_interpret_offsetssizes_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_comment_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_import_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_register_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_symbol_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_string_stmt)
static RzCmdStatus	do_iter_sections (struct tsr2cmd_state *state, TSNode node, bool show_sections)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_sections_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_segments_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_iomap_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_dbgmap_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_function_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (iter_threads_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (grep_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (html_disable_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (html_enable_stmt)
	DEFINE_HANDLE_TS_FCN_AND_SYMBOL (pipe_stmt)
	DEFINE_HANDLE_TS_FCN (statements)
RZ_API RzCmd *	rz_core_cmd_new (bool has_cons)
	Create an instance of RzCmd for the Rizin language. More...
RZ_API RzCmdStatus	rz_core_cmd_rzshell (RzCore *core, const char *cstr, int log)
RZ_API int	rz_core_cmd (RzCore *core, const char *cstr, int log)
RZ_API RzCmdStatus	rz_core_cmd_lines_rzshell (RzCore *core, const char *lines)
RZ_API int	rz_core_cmd_lines (RzCore *core, const char *lines)
RZ_API int	rz_core_cmd_file (RzCore *core, const char *file)
RZ_API int	rz_core_cmd_command (RzCore *core, const char *command)
RZ_API char *	rz_core_disassemble_instr (RzCore *core, ut64 addr, int l)
RZ_API char *	rz_core_disassemble_bytes (RzCore *core, ut64 addr, int b)
RZ_API int	rz_core_cmd_buffer (RzCore *core, const char *buf)
RZ_API int	rz_core_cmdf (RzCore *core, const char *fmt,...)
RZ_API RzCmdStatus	rz_core_cmd0_rzshell (RzCore *core, const char *cmd)
RZ_API int	rz_core_cmd0 (RzCore *core, const char *cmd)
RZ_API int	rz_core_flush (RzCore *core, const char *cmd)
RZ_API char *	rz_core_cmd_str_pipe (RzCore *core, const char *cmd)
RZ_API char *	rz_core_cmd_strf (RzCore *core, const char *fmt,...)
static ut8 *	core_cmd_raw (RzCore *core, const char *cmd, int *length)
RZ_API char *	rz_core_cmd_str (RzCore *core, const char *cmd)
	Executes a rizin command and returns the stdout as a string. More...
RZ_API ut8 *	rz_core_cmd_raw (RzCore *core, const char *cmd, int *length)
	Executes a rizin command and returns the raw stdout and its length. More...
static int	compare_cmd_descriptor_name (const void *a, const void *b)
static void	cmd_descriptor_init (RzCore *core)
static int	core_cmd0_wrapper (void *core, const char *cmd)
RZ_API void	rz_core_cmd_init (RzCore *core)
RZ_IPI RzCmdStatus	rz_basefind_compute_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)

Variables
static const char *	help_msg_dollar []
static const char *	help_msg_k []
static const char *	help_msg_vertical_bar []
static const char *	help_msg_v []
struct ts_data_symbol_map	map_ts_stmt_handlers []
struct ts_data_symbol_map	map_ts_symbols []

Macro Definition Documentation

cmdstr

#define cmdstr

(

x

)

rz_str_newf(x " '%s'", file);

DEFINE_HANDLE_TS_FCN

#define DEFINE_HANDLE_TS_FCN

(

name

)

Value:

    static RzCmdStatus handle_ts_##name##_internal(struct tsr2cmd_state *state, TSNode node, char *node_string); \
    static RzCmdStatus handle_ts_##name(struct tsr2cmd_state *state, TSNode node) { \
        char *node_string = ts_node_sub_string(node, state->input); \
        RZ_LOG_DEBUG(#name ": '%s'\n", node_string); \
        RzCmdStatus res = handle_ts_##name##_internal(state, node, node_string); \
        free(node_string); \
        return res; \
    } \
    static RzCmdStatus handle_ts_##name##_internal(struct tsr2cmd_state *state, TSNode node, char *node_string)

Definition at line 3203 of file cmd.c.

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

#define DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

name

)

Value:

    DEFINE_SYMBOL_TS_FCN(name); \
    DEFINE_HANDLE_TS_FCN(name)

Definition at line 3214 of file cmd.c.

DEFINE_IS_TS_FCN

#define DEFINE_IS_TS_FCN

(

name

)

Value:

    static inline bool is_ts_##name(TSNode node) { \
        return ts_node_symbol(node) == ts_##name##_symbol; \
    }

Definition at line 3194 of file cmd.c.

DEFINE_IS_TS_FCN_AND_SYMBOL

#define DEFINE_IS_TS_FCN_AND_SYMBOL

(

name

)

Value:

    DEFINE_SYMBOL_TS_FCN(name); \
    DEFINE_IS_TS_FCN(name)

Definition at line 3199 of file cmd.c.

DEFINE_SYMBOL_TS_FCN

#define DEFINE_SYMBOL_TS_FCN

(

name

)

TSSymbol ts_##name##_symbol

Definition at line 3192 of file cmd.c.

DEPRECATED_DEFINE_CMD_DESCRIPTOR

#define DEPRECATED_DEFINE_CMD_DESCRIPTOR	(		core,
			cmd_
	)

Value:

    { \
        RzCmdDescriptor *d = cmd_descriptor(#cmd_, help_msg_##cmd_); \
        if (d) { \
            rz_list_append((core)->cmd_descriptors, d); \
        } \
    }

Definition at line 37 of file cmd.c.

DEPRECATED_DEFINE_CMD_DESCRIPTOR_SPECIAL

#define DEPRECATED_DEFINE_CMD_DESCRIPTOR_SPECIAL	(		core,
			cmd_,
			named_cmd
	)

Value:

    { \
        RzCmdDescriptor *d = RZ_NEW0(RzCmdDescriptor); \
        if (d) { \
            d->cmd = #cmd_; \
            d->help_msg = help_msg_##named_cmd; \
            rz_list_append((core)->cmd_descriptors, d); \
        } \
    }

Definition at line 64 of file cmd.c.

DEPRECATED_DEFINE_CMD_DESCRIPTOR_WITH_DETAIL

#define DEPRECATED_DEFINE_CMD_DESCRIPTOR_WITH_DETAIL	(		core,
			cmd_
	)

Value:

    { \
        RzCmdDescriptor *d = cmd_descriptor(#cmd_, help_msg##cmd_); \
        if (d) { \
            d->help_detail = help_detail_##cmd_; \
            rz_list_append((core)->cmd_descriptors, d); \
        } \
    }

Definition at line 45 of file cmd.c.

DEPRECATED_DEFINE_CMD_DESCRIPTOR_WITH_DETAIL2

#define DEPRECATED_DEFINE_CMD_DESCRIPTOR_WITH_DETAIL2	(		core,
			cmd_
	)

Value:

    { \
        RzCmdDescriptor *d = cmd_descriptor(#cmd_, help_msg_##cmd_); \
        if (d) { \
            d->help_detail = help_detail_##cmd_; \
            d->help_detail2 = help_detail2_##cmd_; \
            rz_list_append((core)->cmd_descriptors, d); \
        } \
    }

Definition at line 54 of file cmd.c.

HANDLER_RULE_OP [1/2]

#define HANDLER_RULE_OP

(

name

)

{ #name, handle_ts_##name },

Definition at line 5210 of file cmd.c.

HANDLER_RULE_OP [2/2]

#define HANDLER_RULE_OP

(

name

)

RULE_OP(name)

Definition at line 5210 of file cmd.c.

INTERACTIVE_MAX_REP

#define INTERACTIVE_MAX_REP   1024

Definition at line 5 of file cmd.c.

RULE_OP [1/2]

#define RULE_OP

(

name

)

Definition at line 5209 of file cmd.c.

RULE_OP [2/2]

#define RULE_OP

(

name

)

{ #name, &ts_##name##_symbol },

Definition at line 5209 of file cmd.c.

TS_START_END

#define TS_START_END	(		node,
			start,
			end
	)

Value:

    do { \
        start = ts_node_start_byte(node); \
        end = ts_node_end_byte(node); \
    } while (0)

Definition at line 3171 of file cmd.c.

UPDATE_CMD_STATUS_RES

#define UPDATE_CMD_STATUS_RES	(		res,
			cmd_res,
			label
	)

Value:

    if ((cmd_res) != RZ_CMD_STATUS_OK) { \
        res = (cmd_res); \
        goto label; \
    }

Definition at line 3218 of file cmd.c.

Typedef Documentation

RzHelpSearch

typedef struct _search_help RzHelpSearch

ts_handler

typedef RzCmdStatus(* ts_handler) (struct tsr2cmd_state *state, TSNode node)

Definition at line 3164 of file cmd.c.

Enumeration Type Documentation

dbt_commands_mode

enum dbt_commands_mode

Enumerator
DBT_COMMANDS_MODE_ADDR
DBT_COMMANDS_MODE_BP
DBT_COMMANDS_MODE_SP

Definition at line 4368 of file cmd.c.

                       {
    DBT_COMMANDS_MODE_ADDR,
    DBT_COMMANDS_MODE_BP,
    DBT_COMMANDS_MODE_SP,
};

Function Documentation

apply_edits()

static TSTree* apply_edits ( struct tsr2cmd_state *  state, RzList *  edits  )

static

Definition at line 3525 of file cmd.c.

                                                                       {
    struct tsr2cmd_edit *edit;
    RzListIter *it;
 
    RZ_LOG_DEBUG("old input = '%s'\n", state->input);
    rz_list_foreach (edits, it, edit) {
        RZ_LOG_DEBUG("apply_edits: about to replace '%s' with '%s'\n", edit->old_text, edit->new_text);
        state->input = rz_str_replace(state->input, edit->old_text, edit->new_text, 0);
    }
    RZ_LOG_DEBUG("new input = '%s'\n", state->input);
    return ts_parser_parse_string(state->parser, NULL, state->input, strlen(state->input));
}

References tsr2cmd_edit::new_text, NULL, tsr2cmd_edit::old_text, RZ_LOG_DEBUG, rz_str_replace(), and ts_parser_parse_string().

Referenced by substitute_args_do().

bb_cmp()

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

static

Definition at line 2792 of file cmd.c.

                                                {
    const RzAnalysisBlock *ba = a;
    const RzAnalysisBlock *bb = b;
    return ba->addr - bb->addr;
}

References a, rz_analysis_bb_t::addr, and b.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and rz_core_cmd_foreach().

callback_foreach_kv()

static bool callback_foreach_kv ( void *  user, const char *  k, const char *  v  )

static

Definition at line 609 of file cmd.c.

                                                                          {
    rz_cons_printf("%s=%s\n", k, v);
    return true;
}

References k, rz_cons_printf(), and v.

Referenced by rz_cmd_kuery().

cmd_descriptor()

static RzCmdDescriptor* cmd_descriptor ( const char *  cmd, const char *  help[]  )

static

Definition at line 28 of file cmd.c.

                                                                            {
    RzCmdDescriptor *d = RZ_NEW0(RzCmdDescriptor);
    if (d) {
        d->cmd = cmd;
        d->help_msg = help;
    }
    return d;
}

References cmd, d, cmd_descs_generate::help, and RZ_NEW0.

cmd_descriptor_init()

static void cmd_descriptor_init ( RzCore *  core )

static

Definition at line 5530 of file cmd.c.

                                              {
    const ut8 *p;
    RzListIter *iter;
    RzCmdDescriptor *x, *y;
    int n = core->cmd_descriptors->length;
    rz_list_sort(core->cmd_descriptors, compare_cmd_descriptor_name);
    rz_list_foreach (core->cmd_descriptors, iter, y) {
        if (--n < 0) {
            break;
        }
        x = &core->root_cmd_descriptor;
        for (p = (const ut8 *)y->cmd; *p; p++) {
            if (!x->sub[*p]) {
                if (p[1]) {
                    RzCmdDescriptor *d = RZ_NEW0(RzCmdDescriptor);
                    rz_list_append(core->cmd_descriptors, d);
                    x->sub[*p] = d;
                } else {
                    x->sub[*p] = y;
                }
            } else if (!p[1]) {
                eprintf("Command '%s' is duplicated, please check\n", y->cmd);
            }
            x = x->sub[*p];
        }
    }
}

References rz_cmd_descriptor_t::cmd, rz_core_t::cmd_descriptors, compare_cmd_descriptor_name(), tsr2cmd_state::core, d, eprintf, rz_list_t::length, n, p, rz_core_t::root_cmd_descriptor, rz_list_append(), rz_list_sort(), RZ_NEW0, and x.

Referenced by rz_core_cmd_init().

compare_cmd_descriptor_name()

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

static

Definition at line 5526 of file cmd.c.

                                                                     {
    return strcmp(((RzCmdDescriptor *)a)->cmd, ((RzCmdDescriptor *)b)->cmd);
}

References a, b, and cmd.

Referenced by cmd_descriptor_init().

copy_into_flagitem_list()

static bool copy_into_flagitem_list ( RzFlagItem *  flg, void *  u  )

static

Definition at line 2415 of file cmd.c.

                                                              {
    RzFlagItem *fi = rz_mem_dup(flg, sizeof(RzFlagItem));
    rz_list_append(u, fi);
    return true;
}

References rz_list_append(), and rz_mem_dup().

Referenced by rz_core_cmd_foreach3().

core_cmd0_wrapper()

static int core_cmd0_wrapper ( void *  core, const char *  cmd  )

static

Definition at line 5558 of file cmd.c.

                                                          {
    return rz_core_cmd0((RzCore *)core, cmd);
}

References cmd, tsr2cmd_state::core, and rz_core_cmd0().

Referenced by rz_core_cmd_init().

core_cmd_pipe()

static RzCmdStatus core_cmd_pipe ( RzCore *  core, struct tsr2cmd_state *  state, TSNode  rizin_cmd, int  argc, char **  argv  )

static

Executes a rizin command and pipes the result to the stdin of the program specified in argc/argv.

Executes a rizin command specified in rizin_cmd and pipe its stdout to the stdin of the system program specified in argc and argv arguments.

The output of the second program is then sent into RzCons.

Definition at line 3292 of file cmd.c.

                                                                                                                     {
    int length = 0;
    bool is_pipe = core->is_pipe;
    core->is_pipe = true;
    ut8 *bytes = core_cmd_raw_node(core, state, rizin_cmd, &length);
    core->is_pipe = is_pipe;
    if (!bytes) {
        return RZ_CMD_STATUS_ERROR;
    }
 
    char *out = system_exec_stdin(core->is_pipe, argc, argv, bytes, length, &length);
    if (out) {
        rz_cons_memcat(out, length);
    }
 
    free(bytes);
    free(out);
    return RZ_CMD_STATUS_OK;
}

References argv, bytes, core_cmd_raw_node(), free(), rz_core_t::is_pipe, length, out, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_memcat(), and system_exec_stdin().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL().

core_cmd_raw()

static ut8* core_cmd_raw ( RzCore *  core, const char *  cmd, int *  length  )

static

Definition at line 5483 of file cmd.c.

                                                                     {
    const char *static_str;
    ut8 *retstr = NULL;
    rz_cons_push();
    bool is_pipe = core->is_pipe;
    core->is_pipe = true;
    if (rz_core_cmd(core, cmd, 0) == -1) {
        core->is_pipe = is_pipe;
        rz_cons_pop();
        return NULL;
    }
    core->is_pipe = is_pipe;
    rz_cons_filter();
    static_str = rz_cons_get_buffer();
    if (length) {
        int len = rz_cons_get_buffer_len();
        retstr = (ut8 *)rz_str_newlen(static_str, len);
        *length = len;
    } else {
        retstr = (ut8 *)strdup(rz_str_get(static_str));
    }
 
    rz_cons_pop();
    rz_cons_echo(NULL);
    return retstr;
}

References cmd, tsr2cmd_state::core, rz_core_t::is_pipe, len, length, NULL, rz_cons_echo(), rz_cons_filter(), rz_cons_get_buffer(), rz_cons_get_buffer_len(), rz_cons_pop(), rz_cons_push(), rz_core_cmd(), rz_str_get(), rz_str_newlen(), and strdup().

Referenced by rz_core_cmd_raw(), and rz_core_cmd_str().

core_cmd_raw_node()

static ut8* core_cmd_raw_node ( RzCore *  core, struct tsr2cmd_state *  state, TSNode  rizin_cmd, int *  length  )

static

Definition at line 3264 of file cmd.c.

                                                                                                        {
    const char *static_str;
    ut8 *retstr = NULL;
    rz_cons_push();
    if (handle_ts_stmt(state, rizin_cmd) != RZ_CMD_STATUS_OK) {
        rz_cons_pop();
        return NULL;
    }
    rz_cons_filter();
 
    static_str = rz_cons_get_buffer();
    int len = rz_cons_get_buffer_len();
    retstr = (ut8 *)rz_str_newlen(static_str, len);
    *length = len;
 
    rz_cons_pop();
    rz_cons_echo(NULL);
    return retstr;
}

References handle_ts_stmt(), len, length, NULL, RZ_CMD_STATUS_OK, rz_cons_echo(), rz_cons_filter(), rz_cons_get_buffer(), rz_cons_get_buffer_len(), rz_cons_pop(), rz_cons_push(), and rz_str_newlen().

Referenced by core_cmd_pipe().

core_cmd_tsrzcmd()

static RzCmdStatus core_cmd_tsrzcmd ( RzCore *  core, const char *  cstr, bool  split_lines, bool  log  )

static

Definition at line 5245 of file cmd.c.

                                                                                                {
    TSParser *parser = ts_parser_new();
    bool language_ok = ts_parser_set_language(parser, (TSLanguage *)core->rcmd->language);
    rz_return_val_if_fail(language_ok, RZ_CMD_STATUS_INVALID);
 
    char *input = strdup(rz_str_trim_head_ro(cstr));
 
    TSTree *tree = ts_parser_parse_string(parser, NULL, input, strlen(input));
    if (!tree) {
        rz_warn_if_reached();
        free(input);
        return RZ_CMD_STATUS_INVALID;
    }
 
    TSNode root = ts_tree_root_node(tree);
 
    RzCmdStatus res = RZ_CMD_STATUS_INVALID;
    struct tsr2cmd_state state;
    state.parser = parser;
    state.core = core;
    state.input = input;
    state.tree = tree;
    state.log = log;
    state.split_lines = split_lines;
    rz_pvector_init(&state.saved_input, NULL);
    rz_pvector_init(&state.saved_tree, NULL);
 
    if (state.log) {
        rz_line_hist_add(state.input);
    }
 
    char *ts_str = ts_node_string(root);
    RZ_LOG_DEBUG("s-expr %s\n", ts_str);
    free(ts_str);
 
    if (is_ts_statements(root) && !ts_node_has_error(root)) {
        res = handle_ts_statements(&state, root);
    } else {
        // TODO: print a more meaningful error message and use the ERROR
        // tokens to indicate where, probably, the error is.
        eprintf("Error while parsing command: `%s`\n", input);
    }
 
    ts_tree_delete(tree);
    ts_parser_delete(parser);
    free(input);
    rz_pvector_fini(&state.saved_input);
    rz_pvector_fini(&state.saved_tree);
    return res;
}

References tsr2cmd_state::core, eprintf, free(), input(), rz_cmd_t::language, test-lz4-list::log(), NULL, cmd_descs_generate::parser, rz_core_t::rcmd, root, RZ_CMD_STATUS_INVALID, rz_line_hist_add(), RZ_LOG_DEBUG, rz_pvector_fini(), rz_pvector_init(), rz_return_val_if_fail, rz_str_trim_head_ro(), rz_warn_if_reached, tsr2cmd_state::split_lines, strdup(), tsr2cmd_state::tree, ts_node_has_error(), ts_node_string(), ts_parser_delete(), ts_parser_new(), ts_parser_parse_string(), ts_parser_set_language(), ts_tree_delete(), and ts_tree_root_node().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), rz_core_cmd(), rz_core_cmd_lines(), rz_core_cmd_lines_rzshell(), and rz_core_cmd_rzshell().

create_cmd_edit()

static struct tsr2cmd_edit* create_cmd_edit ( struct tsr2cmd_state *  state, TSNode  arg, char *  new_text  )

static

Definition at line 3331 of file cmd.c.

                                                                                                     {
    struct tsr2cmd_edit *e = RZ_NEW0(struct tsr2cmd_edit);
    ut32 command_start = ts_node_start_byte(state->substitute_cmd);
    TSPoint command_point = ts_node_start_point(state->substitute_cmd);
    e->new_text = new_text;
    e->old_text = ts_node_sub_parent_string(state->substitute_cmd, arg, state->input);
    e->start = ts_node_start_byte(arg) - command_start;
    e->end = ts_node_end_byte(arg) - command_start;
    e->start_point = ts_node_start_point(arg);
    e->end_point = ts_node_end_point(arg);
    if (e->start_point.row == command_point.row) {
        e->start_point.column -= command_point.column;
    }
    if (e->end_point.row == command_point.row) {
        e->end_point.column -= command_point.column;
    }
    e->start_point.row -= command_point.row;
    e->end_point.row -= command_point.row;
    return e;
}

References TSPoint::column, e, tsr2cmd_edit::new_text, TSPoint::row, RZ_NEW0, ts_node_end_byte(), ts_node_end_point(), ts_node_start_byte(), ts_node_start_point(), and ts_node_sub_parent_string().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and handle_cmd_substitution_arg().

DEFINE_HANDLE_TS_FCN()

DEFINE_HANDLE_TS_FCN

(

statements

)

Definition at line 5138 of file cmd.c.

                                 {
    RzCore *core = state->core;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    ut32 child_count = ts_node_named_child_count(node);
    int i;
 
    RZ_LOG_DEBUG("commands with %d childs\n", child_count);
    if (child_count == 0 && !*state->input) {
        if (core->cons->context->breaked) {
            core->cons->context->breaked = false;
            return RZ_CMD_STATUS_INVALID;
        }
        if (!core->cmdrepeat) {
            return RZ_CMD_STATUS_OK;
        }
        return rz_core_cmd_lastcmd_repeat(core, true) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_INVALID;
    }
    if (state->split_lines) {
        rz_cons_break_push(NULL, NULL);
    }
    for (i = 0; i < child_count; i++) {
        if (core->cons->context->cmd_depth < 1) {
            RZ_LOG_ERROR("handle_ts_statements: That was too deep...\n");
            return RZ_CMD_STATUS_INVALID;
        }
        core->cons->context->cmd_depth--;
        if (core->max_cmd_depth - core->cons->context->cmd_depth == 1) {
            core->prompt_offset = core->offset;
        }
 
        if (state->split_lines && rz_cons_is_breaked()) {
            rz_cons_break_pop();
            return res;
        }
        TSNode command = ts_node_named_child(node, i);
        RzCmdStatus cmd_res = handle_ts_stmt(state, command);
        if (state->split_lines) {
            rz_cons_flush();
            rz_core_task_yield(&core->tasks);
        }
        core->cons->context->cmd_depth++;
        if (cmd_res == RZ_CMD_STATUS_INVALID) {
            char *command_str = ts_node_sub_string(command, state->input);
            eprintf("Error while executing command: %s\n", command_str);
            free(command_str);
            res = cmd_res;
            goto err;
        } else if (cmd_res == RZ_CMD_STATUS_ERROR) {
            // make the whole script return ERROR, but continue to
            // execute the other commands
            res = cmd_res;
        } else if (cmd_res != RZ_CMD_STATUS_OK) {
            res = cmd_res;
            goto err;
        }
    }
err:
    if (state->split_lines) {
        rz_cons_break_pop();
    }
    return res;
}

References rz_cons_context_t::breaked, rz_cons_context_t::cmd_depth, rz_core_t::cmdrepeat, command, rz_core_t::cons, rz_cons_t::context, eprintf, err, free(), handle_ts_stmt(), i, rz_core_t::max_cmd_depth, NULL, rz_core_t::offset, rz_core_t::prompt_offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_cons_flush(), rz_cons_is_breaked(), rz_core_cmd_lastcmd_repeat(), rz_core_task_yield(), RZ_LOG_DEBUG, RZ_LOG_ERROR, rz_core_t::tasks, ts_node_named_child(), ts_node_named_child_count(), and ts_node_sub_string().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [1/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

arged_stmt

)

Definition at line 3639 of file cmd.c.

                                            {
    TSNode command = ts_node_child_by_field_name(node, "command", strlen("command"));
    rz_return_val_if_fail(!ts_node_is_null(command), false);
 
    TSNode command_extra = ts_node_child_by_field_name(command, "extra", strlen("extra"));
    char *command_str = NULL, *command_extra_str = NULL;
    if (!ts_node_is_null(command_extra)) {
        command_extra_str = ts_node_sub_string(command_extra, state->input);
        RZ_LOG_DEBUG("command_extra_str = '%s'\n", command_extra_str);
 
        ut32 start = ts_node_start_byte(command);
        ut32 end = ts_node_start_byte(command_extra);
        command_str = rz_str_newf("%.*s", end - start, state->input + start);
    } else {
        command_str = ts_node_sub_string(command, state->input);
    }
 
    rz_str_unescape(command_str);
    RZ_LOG_DEBUG("arged_stmt command: '%s'\n", command_str);
    TSNode args = ts_node_child_by_field_name(node, "args", strlen("args"));
    RzCmdStatus res = RZ_CMD_STATUS_INVALID;
 
    // FIXME: this special handling should be removed once we have a proper
    //        command tree
    if (!strcmp(command_str, "|.")) {
        char *cmd_str = ts_node_sub_string(args, state->input);
        char *exec_string = rz_str_newf(".%s", cmd_str);
        free(cmd_str);
        free(command_str);
        res = core_cmd_tsrzcmd(state->core, exec_string, state->split_lines, false);
        free(exec_string);
        free(command_extra_str);
        return res;
    }
 
    RzCmdParsedArgs *pr_args = NULL;
    if (!ts_node_is_null(args)) {
        RzCmdDesc *cd = rz_cmd_get_desc(state->core->rcmd, command_str);
        bool do_unwrap = cd && cd->type != RZ_CMD_DESC_TYPE_OLDINPUT;
        pr_args = ts_node_handle_arg_prargs(state, node, args, 1, do_unwrap);
        if (!pr_args) {
            goto err;
        }
        rz_cmd_parsed_args_setcmd(pr_args, command_str);
    } else {
        pr_args = rz_cmd_parsed_args_newcmd(command_str);
        if (!pr_args) {
            goto err;
        }
    }
 
    pr_args->extra = command_extra_str;
    pr_args->has_space_after_cmd = !ts_node_is_null(args) && ts_node_end_byte(command) < ts_node_start_byte(args);
    res = rz_cmd_call_parsed_args(state->core->rcmd, pr_args);
    if (res == RZ_CMD_STATUS_WRONG_ARGS) {
        const char *cmdname = rz_cmd_parsed_args_cmd(pr_args);
        eprintf("Wrong number of arguments passed to `%s`, see its help with `%s?`\n\n", cmdname, cmdname);
        get_help_wrong_cmd(state->core, cmdname);
    } else if (res == RZ_CMD_STATUS_NONEXISTINGCMD) {
        const char *cmdname = rz_cmd_parsed_args_cmd(pr_args);
        eprintf("Command '%s' does not exist.\n", cmdname);
        if (rz_str_endswith(cmdname, "?") && pr_args->argc > 1) {
            eprintf("Did you want to see the help? Try `%s` without any argument.\n", cmdname);
        } else {
            // Let's try to find the first command/group in the ancestor chain
            // that could provide some help
            RzCmdDesc *hcd = rz_cmd_get_desc_best(state->core->rcmd, cmdname);
            if (hcd) {
                eprintf("Displaying the help of command '%s'.\n\n", hcd->name);
                get_help_wrong_cmd(state->core, hcd->name);
            }
        }
    } else if (res == RZ_CMD_STATUS_ERROR) {
        RZ_LOG_DEBUG("Something wrong during the execution of `%s` command.\n", rz_cmd_parsed_args_cmd(pr_args));
    }
 
err:
    RZ_LOG_DEBUG("arged_stmt finished command: '%s'\n", command_str);
    rz_cmd_parsed_args_free(pr_args);
    free(command_str);
    return res;
}

References rz_cmd_parsed_args_t::argc, args, cd, command, core_cmd_tsrzcmd(), test_evm::end, eprintf, err, rz_cmd_parsed_args_t::extra, free(), get_help_wrong_cmd(), rz_cmd_parsed_args_t::has_space_after_cmd, rz_cmd_desc_t::name, NULL, rz_cmd_call_parsed_args(), RZ_CMD_DESC_TYPE_OLDINPUT, rz_cmd_get_desc(), rz_cmd_get_desc_best(), rz_cmd_parsed_args_cmd(), rz_cmd_parsed_args_free(), rz_cmd_parsed_args_newcmd(), rz_cmd_parsed_args_setcmd(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_NONEXISTINGCMD, RZ_CMD_STATUS_WRONG_ARGS, RZ_LOG_DEBUG, rz_return_val_if_fail, rz_str_endswith(), rz_str_newf(), rz_str_unescape(), start, ts_node_child_by_field_name(), ts_node_end_byte(), ts_node_handle_arg_prargs(), ts_node_is_null(), ts_node_start_byte(), and ts_node_sub_string().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [2/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

grep_stmt

)

Definition at line 5019 of file cmd.c.

                                           {
    TSNode command = ts_node_child_by_field_name(node, "command", strlen("command"));
    TSNode arg = ts_node_child_by_field_name(node, "specifier", strlen("specifier"));
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    bool is_pipe = state->core->is_pipe;
    state->core->is_pipe = true;
    RzCmdStatus res = handle_ts_stmt(state, command);
    state->core->is_pipe = is_pipe;
    RZ_LOG_DEBUG("grep_stmt specifier: '%s'\n", arg_str);
    RzStrBuf *sb = rz_strbuf_new(arg_str);
    rz_strbuf_prepend(sb, "~");
    char *specifier_str_es = rz_cons_grep_strip(rz_strbuf_get(sb), "`");
    rz_strbuf_free(sb);
    char *specifier_str = rz_cmd_unescape_arg(specifier_str_es, true);
    RZ_LOG_DEBUG("grep_stmt processed specifier: '%s'\n", specifier_str);
    rz_cons_grep_process(specifier_str);
    free(specifier_str_es);
    free(arg_str);
    return res;
}

References command, free(), handle_ts_stmt(), rz_cmd_unescape_arg(), rz_cons_grep_process(), rz_cons_grep_strip(), RZ_LOG_DEBUG, rz_strbuf_free(), rz_strbuf_get(), rz_strbuf_new(), rz_strbuf_prepend(), sb, ts_node_child_by_field_name(), and ts_node_handle_arg().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [3/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

help_stmt

)

Definition at line 3905 of file cmd.c.

                                           {
    size_t node_str_len = strlen(node_string);
    if (node_str_len >= 2 && !strcmp(node_string + node_str_len - 2, "?*")) {
        node_string[node_str_len - 2] = 0;
        const char *argv[2] = { NULL, node_string };
        return rz_cmd_help_search_handler(state->core, 2, argv, RZ_OUTPUT_MODE_STANDARD);
    } else if (node_str_len >= 3 && !strcmp(node_string + node_str_len - 3, "?*j")) {
        node_string[node_str_len - 3] = 0;
        const char *argv[2] = { NULL, node_string };
        return rz_cmd_help_search_handler(state->core, 2, argv, RZ_OUTPUT_MODE_JSON);
    }
 
    TSNode command = ts_node_child_by_field_name(node, "command", strlen("command"));
    char *command_str = ts_node_sub_string(command, state->input);
    TSNode args = ts_node_child_by_field_name(node, "args", strlen("args"));
    RzCmdParsedArgs *pr_args = NULL;
    RzCmdStatus res = RZ_CMD_STATUS_INVALID;
    if (!ts_node_is_null(args)) {
        RzCmdDesc *cd = rz_cmd_get_desc(state->core->rcmd, command_str);
        bool do_unwrap = cd && cd->type != RZ_CMD_DESC_TYPE_OLDINPUT;
        pr_args = ts_node_handle_arg_prargs(state, node, args, 1, do_unwrap);
        if (!pr_args) {
            goto err_else;
        }
        rz_cmd_parsed_args_setcmd(pr_args, command_str);
    } else {
        pr_args = rz_cmd_parsed_args_newcmd(command_str);
        if (!pr_args) {
            goto err_else;
        }
    }
 
    // let's try first with the new auto-generated help, if
    // something fails fallback to old behaviour
    bool use_color = state->core->print->flags & RZ_PRINT_FLAGS_COLOR;
    char *help_msg = rz_cmd_get_help(state->core->rcmd, pr_args, use_color);
    if (help_msg) {
        rz_cons_printf("%s", help_msg);
        free(help_msg);
        res = RZ_CMD_STATUS_OK;
    }
err_else:
    rz_cmd_parsed_args_free(pr_args);
    free(command_str);
    return res;
}

References args, argv, cd, command, free(), NULL, RZ_CMD_DESC_TYPE_OLDINPUT, rz_cmd_get_desc(), rz_cmd_get_help(), rz_cmd_help_search_handler(), rz_cmd_parsed_args_free(), rz_cmd_parsed_args_newcmd(), rz_cmd_parsed_args_setcmd(), RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_cons_printf(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_STANDARD, RZ_PRINT_FLAGS_COLOR, ts_node_child_by_field_name(), ts_node_handle_arg_prargs(), ts_node_is_null(), and ts_node_sub_string().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [4/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

html_disable_stmt

)

Definition at line 5040 of file cmd.c.

                                                   {
    TSNode command = ts_node_child_by_field_name(node, "command", strlen("command"));
    int scr_html = rz_config_get_i(state->core->config, "scr.html");
    rz_config_set_i(state->core->config, "scr.html", 0);
    int scr_color = rz_config_get_i(state->core->config, "scr.color");
    rz_config_set_i(state->core->config, "scr.color", COLOR_MODE_DISABLED);
    RzCmdStatus res = handle_ts_stmt(state, command);
    if (scr_html != -1) {
        rz_cons_flush();
        rz_config_set_i(state->core->config, "scr.html", scr_html);
    }
    if (scr_color != -1) {
        rz_config_set_i(state->core->config, "scr.color", scr_color);
    }
    return res;
}

References COLOR_MODE_DISABLED, command, handle_ts_stmt(), rz_config_get_i(), rz_config_set_i(), rz_cons_flush(), and ts_node_child_by_field_name().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [5/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

html_enable_stmt

)

Definition at line 5057 of file cmd.c.

                                                  {
    TSNode command = ts_node_child_by_field_name(node, "command", strlen("command"));
    int scr_html = rz_config_get_i(state->core->config, "scr.html");
    rz_config_set_i(state->core->config, "scr.html", true);
    RzCmdStatus res = handle_ts_stmt(state, command);
    if (scr_html != -1) {
        rz_cons_flush();
        rz_config_set_i(state->core->config, "scr.html", scr_html);
    }
    return res;
}

References command, handle_ts_stmt(), rz_config_get_i(), rz_config_set_i(), rz_cons_flush(), and ts_node_child_by_field_name().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [6/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_bbs_stmt

)

Definition at line 4602 of file cmd.c.

                                               {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, 0);
    ut64 offorig = core->offset;
    ut64 obs = core->blocksize;
    if (!fcn) {
        return RZ_CMD_STATUS_INVALID;
    }
 
    RzListIter *iter;
    RzAnalysisBlock *bb;
    RzCmdStatus ret = RZ_CMD_STATUS_OK;
    rz_list_sort(fcn->bbs, bb_cmp);
    rz_list_foreach (fcn->bbs, iter, bb) {
        rz_core_seek(core, bb->addr, true);
        rz_core_block_size(core, bb->size);
        RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
        UPDATE_CMD_STATUS_RES(ret, cmd_res, err);
    }
err:
    rz_core_block_size(core, obs);
    rz_core_seek(core, offorig, true);
    return ret;
}

References rz_analysis_bb_t::addr, rz_core_t::analysis, bb_cmp(), rz_analysis_function_t::bbs, rz_core_t::blocksize, command, err, handle_ts_stmt_tmpseek(), obs, rz_core_t::offset, duplicate_flag_t::ret, rz_analysis_get_fcn_in(), RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_core_block_size(), rz_core_seek(), rz_list_sort(), rz_analysis_bb_t::size, ts_node_named_child(), UPDATE_CMD_STATUS_RES, and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [7/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_comment_stmt

)

Definition at line 4704 of file cmd.c.

                                                   {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode filter_node = ts_node_named_child(node, 1);
    char *glob = !ts_node_is_null(filter_node)
        ? ts_node_sub_string(filter_node, state->input)
        : NULL;
    ut64 off = core->offset;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    RzIntervalTreeIter it;
    RzAnalysisMetaItem *meta;
    rz_interval_tree_foreach (&core->analysis->meta, it, meta) {
        if (meta->type != RZ_META_TYPE_COMMENT) {
            continue;
        }
        if (!glob || (meta->str && rz_str_glob(meta->str, glob))) {
            rz_core_seek(core, rz_interval_tree_iter_get(&it)->start, true);
            RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
            UPDATE_CMD_STATUS_RES(res, cmd_res, err);
        }
    }
err:
    rz_core_seek(core, off, false);
    free(glob);
    return res;
}

References rz_core_t::analysis, command, err, free(), handle_ts_stmt_tmpseek(), rz_analysis_t::meta, NULL, off, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_core_seek(), rz_interval_tree_foreach, rz_interval_tree_iter_get(), RZ_META_TYPE_COMMENT, rz_str_glob(), start, rz_analysis_meta_item_t::str, ts_node_is_null(), ts_node_named_child(), ts_node_sub_string(), rz_analysis_meta_item_t::type, UPDATE_CMD_STATUS_RES, and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [8/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_dbgmap_stmt

)

Definition at line 4928 of file cmd.c.

                                                  {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    RzDebug *dbg = core->dbg;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    if (dbg && dbg->cur && dbg->maps) {
        RzList *dbg_maps_addrs = rz_list_newf((RzListFree)free);
        if (!dbg_maps_addrs) {
            return RZ_CMD_STATUS_INVALID;
        }
 
        RzDebugMap *map;
        RzListIter *iter;
        rz_list_foreach (dbg->maps, iter, map) {
            int *val = RZ_NEW(int);
            *val = map->addr;
            rz_list_append(dbg_maps_addrs, val);
        }
 
        int *map_addr;
        rz_list_foreach (dbg_maps_addrs, iter, map_addr) {
            rz_core_seek(core, *map_addr, true);
            RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
            UPDATE_CMD_STATUS_RES(res, cmd_res, err);
        }
    err:
        rz_list_free(dbg_maps_addrs);
    }
    return res;
}

References command, rz_debug_t::cur, dbg, rz_core_t::dbg, err, free(), handle_ts_stmt_tmpseek(), map(), rz_debug_t::maps, RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_core_seek(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_NEW, ts_node_named_child(), UPDATE_CMD_STATUS_RES, and val.

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [9/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_dbta_stmt

)

Definition at line 4408 of file cmd.c.

                                                {
    return iter_dbt_commands(state, node, DBT_COMMANDS_MODE_ADDR);
}

References DBT_COMMANDS_MODE_ADDR, and iter_dbt_commands().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [10/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_dbtb_stmt

)

Definition at line 4412 of file cmd.c.

                                                {
    return iter_dbt_commands(state, node, DBT_COMMANDS_MODE_BP);
}

References DBT_COMMANDS_MODE_BP, and iter_dbt_commands().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [11/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_dbts_stmt

)

Definition at line 4416 of file cmd.c.

                                                {
    return iter_dbt_commands(state, node, DBT_COMMANDS_MODE_SP);
}

References DBT_COMMANDS_MODE_SP, and iter_dbt_commands().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [12/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_file_lines_stmt

)

Definition at line 4420 of file cmd.c.

                                                      {
    RzCore *core = state->core;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    ut64 orig_offset = core->offset;
    FILE *fd = rz_sys_fopen(arg_str, "r");
    if (!fd) {
        res = RZ_CMD_STATUS_INVALID;
        goto arg_out;
    }
 
    core->rcmd->macro.counter = 0;
    while (!feof(fd)) {
        char buf[1024];
        buf[0] = '\0';
        if (!fgets(buf, sizeof(buf), fd)) {
            break;
        }
        ut64 addr = rz_num_math(core->num, buf);
        rz_core_seek(core, addr, true);
        RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
        core->rcmd->macro.counter++;
        UPDATE_CMD_STATUS_RES(res, cmd_res, err);
    }
err:
    rz_core_seek(core, orig_offset, true);
    fclose(fd);
 
arg_out:
    free(arg_str);
    return res;
}

References addr, command, rz_cmd_macro_t::counter, err, fd, benchmark::FILE, free(), handle_ts_stmt_tmpseek(), rz_cmd_t::macro, rz_core_t::num, rz_core_t::offset, rz_core_t::rcmd, RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_core_seek(), rz_num_math(), rz_sys_fopen(), ts_node_handle_arg(), ts_node_named_child(), UPDATE_CMD_STATUS_RES, and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [13/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_flags_stmt

)

Definition at line 4323 of file cmd.c.

                                                 {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = NULL;
    if (!ts_node_is_null(arg)) {
        arg_str = ts_node_handle_arg(state, node, arg, 1);
    }
    const RzSpace *flagspace = rz_flag_space_cur(core->flags);
    RzFlagItem *flag;
    RzListIter *iter;
    RzCmdStatus ret = RZ_CMD_STATUS_OK;
    RzList *match_flag_items = rz_list_newf((RzListFree)rz_flag_item_free);
    if (!match_flag_items) {
        return RZ_CMD_STATUS_OK;
    }
 
    /* duplicate flags that match word, to be sure the command is going to
       be executed on flags values at the moment the command is called
       (without side effects) */
    struct duplicate_flag_t u = {
        .ret = match_flag_items,
        .word = arg_str,
    };
    rz_flag_foreach_space(core->flags, flagspace, duplicate_flag, &u);
 
    /* for all flags that match */
    rz_list_foreach (match_flag_items, iter, flag) {
        if (rz_cons_is_breaked()) {
            break;
        }
 
        RZ_LOG_DEBUG("iter_flags_stmt: seek to %" PFMT64x "\n", flag->offset);
        rz_core_seek(core, flag->offset, true);
        RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
        rz_core_task_yield(&core->tasks);
        UPDATE_CMD_STATUS_RES(ret, cmd_res, err);
    }
 
err:
    rz_list_free(match_flag_items);
    free(arg_str);
    return ret;
}

References command, duplicate_flag(), err, rz_core_t::flags, free(), handle_ts_stmt_tmpseek(), NULL, rz_flag_item_t::offset, PFMT64x, duplicate_flag_t::ret, RZ_CMD_STATUS_OK, rz_cons_is_breaked(), rz_core_seek(), rz_core_task_yield(), rz_flag_foreach_space(), rz_flag_item_free(), rz_list_free(), rz_list_newf(), RZ_LOG_DEBUG, rz_core_t::tasks, ts_node_handle_arg(), ts_node_is_null(), ts_node_named_child(), and UPDATE_CMD_STATUS_RES.

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [14/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_function_stmt

)

Definition at line 4959 of file cmd.c.

                                                    {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode filter_node = ts_node_named_child(node, 1);
    char *filter = NULL;
    if (!ts_node_is_null(filter_node)) {
        filter = ts_node_sub_string(filter_node, state->input);
    }
    ut64 obs = core->blocksize;
    ut64 offorig = core->offset;
    RzAnalysisFunction *fcn;
    RzList *list = core->analysis->fcns;
    RzListIter *iter;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    rz_cons_break_push(NULL, NULL);
    rz_list_foreach (list, iter, fcn) {
        if (rz_cons_is_breaked()) {
            break;
        }
        if (!filter || rz_str_glob(fcn->name, filter)) {
            rz_core_seek(core, fcn->addr, true);
            rz_core_block_size(core, rz_analysis_function_linear_size(fcn));
            RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
            UPDATE_CMD_STATUS_RES(res, cmd_res, err);
        }
    }
err:
    rz_cons_break_pop();
    rz_core_block_size(core, obs);
    rz_core_seek(core, offorig, true);
    free(filter);
    return res;
}

References rz_analysis_function_t::addr, rz_core_t::analysis, rz_core_t::blocksize, command, err, rz_analysis_t::fcns, free(), handle_ts_stmt_tmpseek(), list(), rz_analysis_function_t::name, NULL, obs, rz_core_t::offset, rz_analysis_function_linear_size(), RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_core_block_size(), rz_core_seek(), rz_str_glob(), ts_node_is_null(), ts_node_named_child(), ts_node_sub_string(), UPDATE_CMD_STATUS_RES, and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [15/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_hit_stmt

)

Definition at line 4589 of file cmd.c.

                                               {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode search_cmd = ts_node_named_child(node, 1);
    char *command_str = ts_node_sub_string(command, state->input);
    char *cmdhit = strdup(rz_config_get(core->config, "cmd.hit"));
    rz_config_set(core->config, "cmd.hit", command_str);
    RzCmdStatus res = handle_ts_stmt(state, search_cmd);
    rz_config_set(core->config, "cmd.hit", cmdhit);
    free(command_str);
    return res;
}

References command, rz_core_t::config, free(), handle_ts_stmt(), rz_config_get(), rz_config_set(), strdup(), ts_node_named_child(), and ts_node_sub_string().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [16/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_import_stmt

)

Definition at line 4731 of file cmd.c.

                                                  {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    RzBinSymbol *imp;
    ut64 offorig = core->offset;
    RzList *list = rz_bin_get_symbols(core->bin);
    if (!list) {
        return RZ_CMD_STATUS_OK;
    }
 
    RzList *lost = rz_list_newf(free);
    RzListIter *iter;
    rz_list_foreach (list, iter, imp) {
        if (!imp->is_imported) {
            continue;
        }
        ut64 *n = RZ_NEW(ut64);
        *n = imp->vaddr;
        rz_list_append(lost, n);
    }
    ut64 *naddr;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    rz_list_foreach (lost, iter, naddr) {
        ut64 addr = *naddr;
        if (addr != UT64_MAX) {
            rz_core_seek(core, addr, true);
            RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
            UPDATE_CMD_STATUS_RES(res, cmd_res, err);
        }
    }
err:
    rz_core_seek(core, offorig, true);
    rz_list_free(lost);
    return res;
}

References addr, rz_core_t::bin, command, err, free(), handle_ts_stmt_tmpseek(), rz_bin_symbol_t::is_imported, list(), n, rz_core_t::offset, rz_bin_get_symbols(), RZ_CMD_STATUS_OK, rz_core_seek(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_NEW, ts_node_named_child(), UPDATE_CMD_STATUS_RES, ut64(), UT64_MAX, and rz_bin_symbol_t::vaddr.

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [17/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_instrs_stmt

)

Definition at line 4515 of file cmd.c.

                                                  {
    TSNode command = ts_node_named_child(node, 0);
    RzCore *core = state->core;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    ut64 orig_offset = core->offset;
    int bs = core->blocksize;
    RzList *bbl = rz_analysis_get_blocks_in(core->analysis, core->offset);
    if (!bbl || rz_list_empty(bbl)) {
        eprintf("No basic block contains current address\n");
        return RZ_CMD_STATUS_INVALID;
    }
    RzAnalysisBlock *bb = rz_list_get_top(bbl);
    rz_analysis_block_ref(bb);
    rz_list_free(bbl);
 
    int i;
    for (i = 0; i < bb->ninstr; i++) {
        ut64 i_addr = rz_analysis_block_get_op_addr(bb, i);
        int sz = rz_analysis_block_get_op_size(bb, i);
        rz_core_block_size(core, sz);
        rz_core_seek(core, i_addr, true);
        RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
        UPDATE_CMD_STATUS_RES(res, cmd_res, err);
        if (rz_cons_is_breaked()) {
            break;
        }
    }
    rz_analysis_block_unref(bb);
 
err:
    rz_core_block_size(core, bs);
    rz_core_seek(core, orig_offset, true);
    return res;
}

References rz_core_t::analysis, rz_core_t::blocksize, command, eprintf, err, handle_ts_stmt_tmpseek(), i, rz_analysis_bb_t::ninstr, rz_core_t::offset, rz_analysis_block_get_op_addr(), rz_analysis_block_get_op_size(), rz_analysis_block_ref(), rz_analysis_block_unref(), rz_analysis_get_blocks_in(), RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_cons_is_breaked(), rz_core_block_size(), rz_core_seek(), rz_list_free(), rz_list_get_top(), ts_node_named_child(), UPDATE_CMD_STATUS_RES, and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [18/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_interpret_offsetssizes_stmt

)

Definition at line 4666 of file cmd.c.

                                                                  {
    // convert @@@c: command into a @@@= one, by using the output of the
    // in_cmd as addr/blksz of @@@=
    RzCmdStatus res = RZ_CMD_STATUS_INVALID;
    TSNode in_cmd = ts_node_named_child(node, 1);
    substitute_args_init(state, node);
 
    RzList *edits = rz_list_newf((RzListFree)free_tsr2cmd_edit);
    if (!edits) {
        goto edits_err;
    }
 
    char *in_cmd_out = do_handle_substitution_cmd(state, in_cmd);
    if (!in_cmd_out) {
        goto err;
    }
 
    char *in_cmd_out_es = rz_cmd_escape_arg(in_cmd_out, RZ_CMD_ESCAPE_MULTI_ARG);
    free(in_cmd_out);
    struct tsr2cmd_edit *e = create_cmd_edit(state, in_cmd, in_cmd_out_es);
    rz_list_append(edits, e);
 
    TSNode op = ts_node_child(node, 1);
    e = create_cmd_edit(state, op, strdup("@@@="));
    rz_list_append(edits, e);
 
    TSNode new_command;
    if (!substitute_args_do(state, edits, &new_command)) {
        goto err;
    }
    res = handle_ts_stmt(state, new_command);
err:
    rz_list_free(edits);
edits_err:
    substitute_args_fini(state);
    return res;
}

References create_cmd_edit(), do_handle_substitution_cmd(), e, err, free(), free_tsr2cmd_edit(), handle_ts_stmt(), rz_cmd_escape_arg(), RZ_CMD_ESCAPE_MULTI_ARG, RZ_CMD_STATUS_INVALID, rz_list_append(), rz_list_free(), rz_list_newf(), strdup(), substitute_args_do(), substitute_args_fini(), substitute_args_init(), ts_node_child(), and ts_node_named_child().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [19/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_interpret_stmt

)

Definition at line 4628 of file cmd.c.

                                                     {
    // convert @@c: command into a @@= one, by using the output of the
    // in_cmd as addr of @@=
    RzCmdStatus res = RZ_CMD_STATUS_INVALID;
    TSNode in_cmd = ts_node_named_child(node, 1);
    substitute_args_init(state, node);
 
    RzList *edits = rz_list_newf((RzListFree)free_tsr2cmd_edit);
    if (!edits) {
        goto edits_err;
    }
 
    char *in_cmd_out = do_handle_substitution_cmd(state, in_cmd);
    if (!in_cmd_out) {
        goto err;
    }
 
    char *in_cmd_out_es = rz_cmd_escape_arg(in_cmd_out, RZ_CMD_ESCAPE_MULTI_ARG);
    free(in_cmd_out);
    struct tsr2cmd_edit *e = create_cmd_edit(state, in_cmd, in_cmd_out_es);
    rz_list_append(edits, e);
 
    TSNode op = ts_node_child(node, 1);
    e = create_cmd_edit(state, op, strdup("@@="));
    rz_list_append(edits, e);
 
    TSNode new_command;
    if (!substitute_args_do(state, edits, &new_command)) {
        goto err;
    }
    res = handle_ts_stmt(state, new_command);
err:
    rz_list_free(edits);
edits_err:
    substitute_args_fini(state);
    return res;
}

References create_cmd_edit(), do_handle_substitution_cmd(), e, err, free(), free_tsr2cmd_edit(), handle_ts_stmt(), rz_cmd_escape_arg(), RZ_CMD_ESCAPE_MULTI_ARG, RZ_CMD_STATUS_INVALID, rz_list_append(), rz_list_free(), rz_list_newf(), strdup(), substitute_args_do(), substitute_args_fini(), substitute_args_init(), ts_node_child(), and ts_node_named_child().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [20/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_iomap_stmt

)

Definition at line 4906 of file cmd.c.

                                                 {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    int fd = rz_io_fd_get_current(core->io);
    // only iterate maps of current fd
    RzList *maps = rz_io_map_get_for_fd(core->io, fd);
    RzIOMap *map;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    if (maps) {
        RzListIter *iter;
        rz_list_foreach (maps, iter, map) {
            rz_core_seek(core, map->itv.addr, true);
            rz_core_block_size(core, map->itv.size);
            RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
            UPDATE_CMD_STATUS_RES(res, cmd_res, err);
        }
    err:
        rz_list_free(maps);
    }
    return res;
}

References command, err, fd, handle_ts_stmt_tmpseek(), rz_core_t::io, map(), maps(), RZ_CMD_STATUS_OK, rz_core_block_size(), rz_core_seek(), rz_io_fd_get_current(), rz_io_map_get_for_fd(), rz_list_free(), ts_node_named_child(), and UPDATE_CMD_STATUS_RES.

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [21/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_offsets_stmt

)

Definition at line 4507 of file cmd.c.

                                                   {
    return iter_offsets_common(state, node, false);
}

References iter_offsets_common().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [22/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_offsetssizes_stmt

)

Definition at line 4511 of file cmd.c.

                                                        {
    return iter_offsets_common(state, node, true);
}

References iter_offsets_common().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [23/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_register_stmt

)

Definition at line 4767 of file cmd.c.

                                                    {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    ut64 offorig = core->offset;
    RzReg *reg = rz_core_reg_default(core);
    int i;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        RzRegItem *item;
        ut64 value;
        const RzList *head = rz_reg_get_list(reg, i);
        if (!head) {
            continue;
        }
        RzList *list = rz_list_newf(free);
        RzListIter *iter;
        rz_list_foreach (head, iter, item) {
            if (item->size != core->analysis->bits) {
                continue;
            }
            if (item->type != i) {
                continue;
            }
            rz_list_append(list, strdup(item->name));
        }
        const char *item_name;
        rz_list_foreach (list, iter, item_name) {
            value = rz_reg_getv(reg, item_name);
            rz_core_seek(core, value, true);
            rz_cons_printf("%s: ", item_name);
            RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
            UPDATE_CMD_STATUS_RES(res, cmd_res, err);
        }
    err:
        rz_list_free(list);
    }
    rz_core_seek(core, offorig, true);
    return res;
}

References rz_core_t::analysis, rz_analysis_t::bits, command, err, free(), handle_ts_stmt_tmpseek(), test-lz4-versions::head, i, list(), rz_reg_item_t::name, rz_core_t::offset, reg, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_core_reg_default(), rz_core_seek(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_reg_get_list(), rz_reg_getv(), RZ_REG_TYPE_LAST, rz_reg_item_t::size, strdup(), ts_node_named_child(), rz_reg_item_t::type, UPDATE_CMD_STATUS_RES, ut64(), and value.

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [24/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_sections_stmt

)

Definition at line 4898 of file cmd.c.

                                                    {
    return do_iter_sections(state, node, true);
}

References do_iter_sections().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [25/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_segments_stmt

)

Definition at line 4902 of file cmd.c.

                                                    {
    return do_iter_sections(state, node, false);
}

References do_iter_sections().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [26/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_step_stmt

)

Definition at line 4550 of file cmd.c.

                                                {
    TSNode command = ts_node_named_child(node, 0);
    TSNode args = ts_node_named_child(node, 1);
    RzCmdParsedArgs *a = ts_node_handle_arg_prargs(state, node, args, 1, true);
    if (!a || a->argc != 3 + 1) {
        rz_cmd_parsed_args_free(a);
        return RZ_CMD_STATUS_INVALID;
    }
 
    RzCore *core = state->core;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    ut64 orig_offset = core->offset;
    int bs = core->blocksize;
 
    char *from_str = a->argv[1];
    char *to_str = a->argv[2];
    char *step_str = a->argv[3];
    ut64 from = rz_num_math(core->num, from_str);
    ut64 to = rz_num_math(core->num, to_str);
    ut64 step = rz_num_math(core->num, step_str);
 
    ut64 cur;
    for (cur = from; cur < to; cur += step) {
        rz_core_seek(core, cur, true);
        rz_core_block_size(core, step);
        RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
        UPDATE_CMD_STATUS_RES(res, cmd_res, err);
        if (rz_cons_is_breaked()) {
            break;
        }
    }
 
err:
    rz_core_block_size(core, bs);
    rz_core_seek(core, orig_offset, true);
    rz_cmd_parsed_args_free(a);
    return res;
}

References a, args, rz_core_t::blocksize, command, err, from, handle_ts_stmt_tmpseek(), rz_core_t::num, rz_core_t::offset, rz_cmd_parsed_args_free(), RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_cons_is_breaked(), rz_core_block_size(), rz_core_seek(), rz_num_math(), step(), to, ts_node_handle_arg_prargs(), ts_node_named_child(), UPDATE_CMD_STATUS_RES, and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [27/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_string_stmt

)

Definition at line 4839 of file cmd.c.

                                                  {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    RzList *list = rz_bin_get_strings(core->bin);
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    if (list) {
        ut64 offorig = core->offset;
        ut64 obs = core->blocksize;
        RzBinString *s;
        RzList *lost = rz_list_newf(free);
        RzListIter *iter;
        rz_list_foreach (list, iter, s) {
            RzBinString *bs = rz_mem_dup(s, sizeof(RzBinString));
            rz_list_append(lost, bs);
        }
        rz_list_foreach (lost, iter, s) {
            rz_core_block_size(core, s->size);
            rz_core_seek(core, s->vaddr, true);
            RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
            UPDATE_CMD_STATUS_RES(res, cmd_res, err);
        }
    err:
        rz_core_block_size(core, obs);
        rz_core_seek(core, offorig, true);
        rz_list_free(lost);
    }
    return res;
}

References rz_core_t::bin, rz_core_t::blocksize, command, err, free(), handle_ts_stmt_tmpseek(), list(), obs, rz_core_t::offset, rz_bin_get_strings(), RZ_CMD_STATUS_OK, rz_core_block_size(), rz_core_seek(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_mem_dup(), s, ts_node_named_child(), UPDATE_CMD_STATUS_RES, and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [28/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_symbol_stmt

)

Definition at line 4807 of file cmd.c.

                                                  {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    RzBinSymbol *sym;
    ut64 offorig = core->offset;
    ut64 obs = core->blocksize;
    RzList *list = rz_bin_get_symbols(core->bin);
    RzListIter *iter;
    rz_cons_break_push(NULL, NULL);
    RzList *lost = rz_list_newf(free);
    rz_list_foreach (list, iter, sym) {
        RzBinSymbol *bs = rz_mem_dup(sym, sizeof(RzBinSymbol));
        rz_list_append(lost, bs);
    }
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    rz_list_foreach (lost, iter, sym) {
        if (rz_cons_is_breaked()) {
            break;
        }
        rz_core_block_size(core, sym->size);
        rz_core_seek(core, sym->vaddr, true);
        RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
        UPDATE_CMD_STATUS_RES(res, cmd_res, err);
    }
err:
    rz_cons_break_pop();
    rz_list_free(lost);
    rz_core_block_size(core, obs);
    rz_core_seek(core, offorig, true);
    return res;
}

References rz_core_t::bin, rz_core_t::blocksize, command, err, free(), handle_ts_stmt_tmpseek(), list(), NULL, obs, rz_core_t::offset, rz_bin_get_symbols(), RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_core_block_size(), rz_core_seek(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_mem_dup(), rz_bin_symbol_t::size, ts_node_named_child(), UPDATE_CMD_STATUS_RES, ut64(), and rz_bin_symbol_t::vaddr.

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [29/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

iter_threads_stmt

)

Definition at line 4993 of file cmd.c.

                                                   {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    RzDebug *dbg = core->dbg;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    if (dbg && dbg->cur && dbg->cur->threads) {
        int origtid = dbg->tid;
        RzDebugPid *p;
        RzList *list = dbg->cur->threads(dbg, dbg->pid);
        if (!list) {
            return RZ_CMD_STATUS_INVALID;
        }
        RzListIter *iter;
        rz_list_foreach (list, iter, p) {
            rz_debug_select(dbg, dbg->pid, p->pid);
            rz_cons_printf("PID %d\n", p->pid);
            RzCmdStatus cmd_res = handle_ts_stmt(state, command);
            UPDATE_CMD_STATUS_RES(res, cmd_res, err);
        }
    err:
        rz_debug_select(dbg, dbg->pid, origtid);
        rz_list_free(list);
    }
    return res;
}

References command, rz_debug_t::cur, dbg, rz_core_t::dbg, err, handle_ts_stmt(), list(), p, rz_debug_t::pid, RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_debug_select(), rz_list_free(), rz_debug_plugin_t::threads, rz_debug_t::tid, ts_node_named_child(), and UPDATE_CMD_STATUS_RES.

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [30/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

legacy_quoted_stmt

)

Definition at line 3722 of file cmd.c.

                                                    {
    return rz_cmd_int2status(run_cmd_depth(state->core, node_string));
}

References run_cmd_depth().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [31/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

pipe_stmt

)

Definition at line 5069 of file cmd.c.

                                           {
    TSNode command_rizin = ts_node_named_child(node, 0);
    TSNode command_pipe = ts_node_named_child(node, 1);
 
    RzCmdStatus res = RZ_CMD_STATUS_INVALID;
    RzCmdParsedArgs *a = ts_node_handle_arg_prargs(state, node, command_pipe, 1, true);
    if (a && a->argc > 1) {
        res = core_cmd_pipe(state->core, state, command_rizin, a->argc - 1, a->argv + 1);
    }
 
    rz_cmd_parsed_args_free(a);
    return res;
}

References a, core_cmd_pipe(), rz_cmd_parsed_args_free(), RZ_CMD_STATUS_INVALID, ts_node_handle_arg_prargs(), and ts_node_named_child().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [32/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

redirect_stmt

)

Definition at line 3749 of file cmd.c.

                                               {
    bool pipecolor = rz_config_get_b(state->core->config, "scr.color.pipe");
    int ocolor = rz_config_get_i(state->core->config, "scr.color");
    int scr_html = -1;
    RzCmdStatus res = RZ_CMD_STATUS_INVALID, is_append = false, is_html = false;
    int fdn = 1;
 
    TSNode redirect_op = ts_node_child_by_field_name(node, "redirect_operator", strlen("redirect_operator"));
    if (is_ts_fdn_redirect_operator(redirect_op)) {
        // this is the default operation, no html and no append
    } else if (is_ts_fdn_append_operator(redirect_op)) {
        is_append = true;
    } else if (is_ts_html_redirect_operator(redirect_op)) {
        is_html = true;
    } else if (is_ts_html_append_operator(redirect_op)) {
        is_html = true;
        is_append = true;
    } else {
        RZ_LOG_ERROR("This should never happen, redirect_operator is no known type");
        rz_warn_if_reached();
    }
 
    if (is_html) {
        scr_html = rz_config_get_i(state->core->config, "scr.html");
        rz_config_set_i(state->core->config, "scr.html", true);
        pipecolor = true;
    } else {
        TSNode fd_desc = ts_node_named_child(redirect_op, 0);
        if (!ts_node_is_null(fd_desc)) {
            char *fd_str = ts_node_sub_string(fd_desc, state->input);
            fdn = atoi(fd_str);
            free(fd_str);
        }
    }
 
    rz_cons_set_interactive(false);
    // TODO: allow to use editor as the old behaviour
 
    // extract the string of the filename we need to write to
    TSNode arg = ts_node_child_by_field_name(node, "arg", strlen("arg"));
    char *arg_str = ts_node_handle_arg(state, node, arg, 2);
 
    if (arg_str[0] == '$') {
        // redirect output of command to an alias variable
        RZ_LOG_DEBUG("redirect_stmt: alias = '%s'\n", arg_str);
        TSNode command = ts_node_child_by_field_name(node, "command", strlen("command"));
        char *command_str = ts_node_sub_string(command, state->input);
 
        char *output = rz_core_cmd_str(state->core, command_str);
        char *old_alias_value = rz_cmd_alias_get(state->core->rcmd, arg_str, 1);
        char *new_alias_value;
        const char *start_char = "$";
        if (is_append && old_alias_value) {
            start_char = "";
        } else {
            old_alias_value = "";
        }
        new_alias_value = rz_str_newf("%s%s%s", start_char, old_alias_value, output ? output : "");
        free(output);
        rz_cmd_alias_set(state->core->rcmd, arg_str, new_alias_value, 1);
        free(new_alias_value);
        free(command_str);
        res = RZ_CMD_STATUS_OK;
    } else {
        rz_cons_flush();
        RZ_LOG_DEBUG("redirect_stmt: fdn = %d, is_append = %d\n", fdn, is_append);
        int pipefd = rz_cons_pipe_open(arg_str, fdn, is_append);
        if (pipefd != -1) {
            if (!pipecolor) {
                rz_config_set_i(state->core->config, "scr.color", COLOR_MODE_DISABLED);
            }
            TSNode command = ts_node_child_by_field_name(node, "command", strlen("command"));
            res = handle_ts_stmt(state, command);
            rz_cons_flush();
            rz_cons_pipe_close(pipefd);
        } else {
            RZ_LOG_WARN("Could not open pipe to %d", fdn);
        }
    }
    free(arg_str);
    rz_cons_set_last_interactive();
    if (!pipecolor) {
        rz_config_set_i(state->core->config, "scr.color", ocolor);
    }
    if (scr_html != -1) {
        rz_config_set_i(state->core->config, "scr.html", scr_html);
    }
    return res;
}

References COLOR_MODE_DISABLED, command, free(), handle_ts_stmt(), output, rz_cmd_alias_get(), rz_cmd_alias_set(), RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_config_get_b(), rz_config_get_i(), rz_config_set_i(), rz_cons_flush(), rz_cons_pipe_close(), rz_cons_pipe_open(), rz_cons_set_interactive(), rz_cons_set_last_interactive(), rz_core_cmd_str(), RZ_LOG_DEBUG, RZ_LOG_ERROR, RZ_LOG_WARN, rz_str_newf(), rz_warn_if_reached, ts_node_child_by_field_name(), ts_node_handle_arg(), ts_node_is_null(), ts_node_named_child(), and ts_node_sub_string().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [33/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

repeat_stmt

)

Definition at line 3726 of file cmd.c.

                                             {
    TSNode number = ts_node_child_by_field_name(node, "arg", strlen("arg"));
    char *number_str = ts_node_sub_string(number, state->input);
    int rep = atoi(number_str);
    free(number_str);
 
    TSNode command = ts_node_child_by_field_name(node, "command", strlen("command"));
    if (rep > INTERACTIVE_MAX_REP && rz_cons_is_interactive()) {
        if (!rz_cons_yesno('n', "Are you sure to repeat this %d times? (y/N)", rep)) {
            return RZ_CMD_STATUS_INVALID;
        }
    }
 
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    size_t i;
    for (i = 0; i < rep; i++) {
        RzCmdStatus cmd_res = handle_ts_stmt(state, command);
        UPDATE_CMD_STATUS_RES(res, cmd_res, err);
    }
err:
    return res;
}

References command, err, free(), handle_ts_stmt(), i, INTERACTIVE_MAX_REP, RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_cons_is_interactive(), rz_cons_yesno(), ts_node_child_by_field_name(), ts_node_sub_string(), and UPDATE_CMD_STATUS_RES.

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [34/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_arch_stmt

)

Definition at line 4030 of file cmd.c.

                                               {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    char *tmparch, *tmpbits;
    bool is_arch_set = false, is_bits_set = false;
    bool oldfixedarch = core->fixedarch, oldfixedbits = core->fixedbits;
    int cmd_ignbithints = -1;
 
    // change arch and bits
    char *q = strchr(arg_str, ':');
    if (q) {
        *q++ = '\0';
        int bits = rz_num_math(core->num, q);
        is_bits_set = set_tmp_bits(core, bits, &tmpbits, &cmd_ignbithints);
    }
    is_arch_set = set_tmp_arch(core, arg_str, &tmparch);
 
    // execute command with changed settings
    RzCmdStatus res = handle_ts_stmt(state, command);
 
    // restore original settings
    if (is_arch_set) {
        core->fixedarch = oldfixedarch;
        rz_config_set(core->config, "asm.arch", tmparch);
        free(tmparch);
    }
    if (is_bits_set) {
        rz_config_set(core->config, "asm.bits", tmpbits);
        core->fixedbits = oldfixedbits;
        free(tmpbits);
    }
    if (cmd_ignbithints != -1) {
        rz_config_set_i(core->config, "analysis.ignbithints", cmd_ignbithints);
    }
    free(arg_str);
    return res;
}

References bits(), command, rz_core_t::config, rz_core_t::fixedarch, rz_core_t::fixedbits, free(), handle_ts_stmt(), rz_core_t::num, rz_config_set(), rz_config_set_i(), rz_num_math(), set_tmp_arch(), set_tmp_bits(), ts_node_handle_arg(), and ts_node_named_child().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [35/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_bits_stmt

)

Definition at line 4070 of file cmd.c.

                                               {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    bool oldfixedbits = core->fixedbits;
    char *tmpbits;
    int cmd_ignbithints;
 
    int bits = rz_num_math(core->num, arg_str);
    set_tmp_bits(core, bits, &tmpbits, &cmd_ignbithints);
 
    RzCmdStatus res = handle_ts_stmt(state, command);
 
    rz_config_set(core->config, "asm.bits", tmpbits);
    core->fixedbits = oldfixedbits;
    rz_config_set_i(core->config, "analysis.ignbithints", cmd_ignbithints);
 
    free(tmpbits);
    free(arg_str);
    return res;
}

References bits(), command, rz_core_t::config, rz_core_t::fixedbits, free(), handle_ts_stmt(), rz_core_t::num, rz_config_set(), rz_config_set_i(), rz_num_math(), set_tmp_bits(), ts_node_handle_arg(), and ts_node_named_child().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [36/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_blksz_stmt

)

Definition at line 3976 of file cmd.c.

                                                {
    TSNode command = ts_node_named_child(node, 0);
    TSNode blksz = ts_node_named_child(node, 1);
    char *blksz_string = ts_node_handle_arg(state, node, blksz, 1);
    ut64 orig_blksz = state->core->blocksize;
    RZ_LOG_DEBUG("tmp_blksz_stmt, changing blksz to %s\n", blksz_string);
    rz_core_block_size(state->core, rz_num_math(state->core->num, blksz_string));
    RzCmdStatus res = handle_ts_stmt(state, command);
    rz_core_block_size(state->core, orig_blksz);
    free(blksz_string);
    return res;
}

References command, free(), handle_ts_stmt(), rz_core_block_size(), RZ_LOG_DEBUG, rz_num_math(), ts_node_handle_arg(), ts_node_named_child(), and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [37/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_eval_stmt

)

Definition at line 4113 of file cmd.c.

                                               {
    // TODO: support cmd_substitution in tmp_eval_args
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode args = ts_node_named_child(node, 1);
 
    RzConfigHold *hc = rz_config_hold_new(core->config);
    uint32_t i, n_args = ts_node_named_child_count(args);
    for (i = 0; i < n_args; i++) {
        TSNode arg = ts_node_named_child(args, i);
        char *arg_str = ts_node_sub_string(arg, state->input);
        char *eq = strchr(arg_str, '=');
        if (eq) {
            *eq = 0;
            rz_config_hold_s(hc, arg_str, NULL);
            rz_config_set(core->config, arg_str, eq + 1);
        } else {
            eprintf("Missing '=' in e: expression (%s)\n", arg_str);
        }
        free(arg_str);
    }
 
    RzCmdStatus res = handle_ts_stmt(state, command);
 
    rz_config_hold_restore(hc);
    rz_config_hold_free(hc);
    return res;
}

References args, command, rz_core_t::config, eprintf, eq, free(), handle_ts_stmt(), i, NULL, rz_config_hold_free(), rz_config_hold_new(), rz_config_hold_restore(), rz_config_hold_s(), rz_config_set(), ts_node_named_child(), ts_node_named_child_count(), and ts_node_sub_string().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [38/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_fd_stmt

)

Definition at line 4187 of file cmd.c.

                                             {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    int tmpfd = core->io->desc ? core->io->desc->fd : -1;
    rz_io_use_fd(core->io, atoi(arg_str));
    RzCmdStatus res = handle_ts_stmt(state, command);
    rz_io_use_fd(core->io, tmpfd);
    free(arg_str);
    return res;
}

References command, rz_io_t::desc, rz_io_desc_t::fd, free(), handle_ts_stmt(), rz_core_t::io, rz_io_use_fd(), ts_node_handle_arg(), and ts_node_named_child().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [39/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_file_stmt

)

Definition at line 4250 of file cmd.c.

                                               {
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    size_t sz;
    RzCmdStatus res = RZ_CMD_STATUS_INVALID;
 
    char *f = rz_file_slurp(arg_str, &sz);
    if (!f) {
        eprintf("Cannot open '%s'\n", arg_str);
        goto out;
    }
 
    res = handle_tmp_desc(state, command, (ut8 *)f, (int)sz);
 
    free(f);
out:
    free(arg_str);
    return res;
}

References command, eprintf, f, free(), handle_tmp_desc(), out, RZ_CMD_STATUS_INVALID, rz_file_slurp(), ts_node_handle_arg(), and ts_node_named_child().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [40/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_fromto_stmt

)

Definition at line 3989 of file cmd.c.

                                                 {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode fromto = ts_node_named_child(node, 1);
    RzCmdParsedArgs *a = ts_node_handle_arg_prargs(state, node, fromto, 1, true);
    if (!a || a->argc != 2 + 1) {
        rz_cmd_parsed_args_free(a);
        return RZ_CMD_STATUS_INVALID;
    }
 
    char *from_str = a->argv[1];
    char *to_str = a->argv[2];
 
    const char *fromvars[] = { "analysis.from", "diff.from", "graph.from",
        "search.from", "zoom.from", NULL };
    const char *tovars[] = { "analysis.to", "diff.to", "graph.to",
        "search.to", "zoom.to", NULL };
    ut64 from_val = rz_num_math(core->num, from_str);
    ut64 to_val = rz_num_math(core->num, to_str);
    RZ_LOG_DEBUG("tmp_fromto_stmt, changing fromto to (%" PFMT64x ", %" PFMT64x ")\n", from_val, to_val);
 
    RzConfigHold *hc = rz_config_hold_new(core->config);
    int i;
    for (i = 0; fromvars[i]; i++) {
        rz_config_hold_i(hc, fromvars[i], NULL);
        rz_config_set_i(core->config, fromvars[i], from_val);
    }
    for (i = 0; tovars[i]; i++) {
        rz_config_hold_i(hc, tovars[i], NULL);
        rz_config_set_i(core->config, tovars[i], to_val);
    }
 
    RzCmdStatus res = handle_ts_stmt(state, command);
 
    rz_config_hold_restore(hc);
 
    rz_config_hold_free(hc);
    rz_cmd_parsed_args_free(a);
    return res;
}

References a, command, rz_core_t::config, handle_ts_stmt(), i, NULL, rz_core_t::num, PFMT64x, rz_cmd_parsed_args_free(), RZ_CMD_STATUS_INVALID, rz_config_hold_free(), rz_config_hold_i(), rz_config_hold_new(), rz_config_hold_restore(), rz_config_set_i(), RZ_LOG_DEBUG, rz_num_math(), ts_node_handle_arg_prargs(), ts_node_named_child(), and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [41/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_fs_stmt

)

Definition at line 4142 of file cmd.c.

                                             {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    rz_flag_space_push(core->flags, arg_str);
    RzCmdStatus res = handle_ts_stmt(state, command);
    rz_flag_space_pop(core->flags);
    free(arg_str);
    return res;
}

References command, rz_core_t::flags, free(), handle_ts_stmt(), ts_node_handle_arg(), and ts_node_named_child().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [42/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_hex_stmt

)

Definition at line 4306 of file cmd.c.

                                              {
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    int sz;
 
    size_t len = strlen(arg_str);
    ut8 *buf = RZ_NEWS(ut8, len + 1);
    sz = rz_hex_str2bin(arg_str, buf);
 
    RzCmdStatus res = handle_tmp_desc(state, command, buf, sz);
 
    free(buf);
    free(arg_str);
    return res;
}

References command, free(), handle_tmp_desc(), len, rz_hex_str2bin(), RZ_NEWS, ts_node_handle_arg(), and ts_node_named_child().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [43/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_kuery_stmt

)

Definition at line 4170 of file cmd.c.

                                                {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    ut64 orig_offset = state->core->offset;
    char *out = sdb_querys(core->sdb, NULL, 0, arg_str);
    if (out) {
        rz_core_seek(core, rz_num_math(core->num, out), true);
        free(out);
    }
    RzCmdStatus res = handle_ts_stmt_tmpseek(state, command);
    rz_core_seek(state->core, orig_offset, true);
    free(arg_str);
    return res;
}

References command, free(), handle_ts_stmt_tmpseek(), NULL, rz_core_t::num, out, rz_core_seek(), rz_num_math(), rz_core_t::sdb, sdb_querys(), ts_node_handle_arg(), ts_node_named_child(), and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [44/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_nthi_stmt

)

Definition at line 4093 of file cmd.c.

                                               {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
 
    ut64 orig_offset = state->core->offset;
    int index = rz_num_math(core->num, arg_str);
    if (rz_core_seek_bb_instruction(core, index)) {
        core->tmpseek = true;
    }
 
    RzCmdStatus res = handle_ts_stmt_tmpseek(state, command);
 
    rz_core_seek(core, orig_offset, true);
 
    free(arg_str);
    return res;
}

References command, free(), handle_ts_stmt_tmpseek(), rz_core_t::num, rz_core_seek(), rz_core_seek_bb_instruction(), rz_num_math(), rz_core_t::tmpseek, ts_node_handle_arg(), ts_node_named_child(), and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [45/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_reg_stmt

)

Definition at line 4200 of file cmd.c.

                                              {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    ut64 orig_offset = state->core->offset;
    // TODO: add support for operations (e.g. @r:PC+10)
    ut64 regval = rz_debug_reg_get(core->dbg, arg_str);
    rz_core_seek(core, regval, true);
    RzCmdStatus res = handle_ts_stmt_tmpseek(state, command);
    rz_core_seek(core, orig_offset, true);
    free(arg_str);
    return res;
}

References command, rz_core_t::dbg, free(), handle_ts_stmt_tmpseek(), rz_core_seek(), rz_debug_reg_get(), ts_node_handle_arg(), ts_node_named_child(), and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [46/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_reli_stmt

)

Definition at line 4154 of file cmd.c.

                                               {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    ut64 orig_offset = state->core->offset;
    ut64 addr = rz_num_math(core->num, arg_str);
    if (addr) {
        rz_core_seek_opcode(core, addr, false);
    }
    RzCmdStatus res = handle_ts_stmt_tmpseek(state, command);
    rz_core_seek(state->core, orig_offset, true);
    free(arg_str);
    return res;
}

References addr, command, free(), handle_ts_stmt_tmpseek(), rz_core_t::num, rz_core_seek(), rz_core_seek_opcode(), rz_num_math(), ts_node_handle_arg(), ts_node_named_child(), and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [47/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_seek_stmt

)

Definition at line 3952 of file cmd.c.

                                               {
    TSNode command = ts_node_named_child(node, 0);
    TSNode offset = ts_node_named_child(node, 1);
    char *offset_string = ts_node_handle_arg(state, node, offset, 1);
    ut64 offset_val = rz_num_math(state->core->num, offset_string);
    ut64 orig_offset = state->core->offset;
    if (!offset_val && isalpha((int)offset_string[0])) {
        if (!rz_flag_get(state->core->flags, offset_string)) {
            eprintf("Invalid address (%s)\n", offset_string);
            free(offset_string);
            return RZ_CMD_STATUS_INVALID;
        }
    }
    if (offset_string[0] == '-' || offset_string[0] == '+') {
        offset_val += state->core->offset;
    }
    RZ_LOG_DEBUG("tmp_seek_stmt, changing offset to %" PFMT64x "\n", offset_val);
    rz_core_seek(state->core, offset_val, true);
    RzCmdStatus res = handle_ts_stmt_tmpseek(state, command);
    rz_core_seek(state->core, orig_offset, true);
    free(offset_string);
    return res;
}

References command, eprintf, free(), handle_ts_stmt_tmpseek(), isalpha, PFMT64x, RZ_CMD_STATUS_INVALID, rz_core_seek(), rz_flag_get(), RZ_LOG_DEBUG, rz_num_math(), ts_node_handle_arg(), ts_node_named_child(), and ut64().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [48/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_string_stmt

)

Definition at line 4271 of file cmd.c.

                                                 {
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
    int sz;
 
    sz = strlen(arg_str);
    const ut8 *buf = (const ut8 *)arg_str;
 
    RzCmdStatus res = handle_tmp_desc(state, command, buf, sz);
 
    free(arg_str);
    return res;
}

References command, free(), handle_tmp_desc(), ts_node_handle_arg(), and ts_node_named_child().

DEFINE_HANDLE_TS_FCN_AND_SYMBOL() [49/49]

DEFINE_HANDLE_TS_FCN_AND_SYMBOL

(

tmp_value_stmt

)

Definition at line 4286 of file cmd.c.

                                                {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    TSNode arg = ts_node_named_child(node, 1);
    char *arg_str = ts_node_handle_arg(state, node, arg, 1);
 
    ut64 v = rz_num_math(core->num, arg_str);
    ut8 buf[8] = { 0 };
    int be = rz_config_get_i(core->config, "cfg.bigendian");
    int bi = rz_config_get_i(core->config, "asm.bits");
 
    rz_write_ble(buf, v, be, bi);
    int sz = bi / 8;
 
    RzCmdStatus res = handle_tmp_desc(state, command, buf, sz);
 
    free(arg_str);
    return res;
}

References command, rz_core_t::config, free(), handle_tmp_desc(), rz_core_t::num, rz_config_get_i(), rz_num_math(), rz_write_ble(), ts_node_handle_arg(), ts_node_named_child(), ut64(), and v.

do_handle_substitution_cmd()

static char* do_handle_substitution_cmd ( struct tsr2cmd_state *  state, TSNode  inn_cmd  )

static

Definition at line 3373 of file cmd.c.

                                                                                     {
    RzCore *core = state->core;
    int value = core->num->value;
    char *inn_str = ts_node_sub_parent_string(state->substitute_cmd, inn_cmd, state->input);
 
    // save current color and disable it
    int ocolor = rz_config_get_i(core->config, "scr.color");
    rz_config_set_i(core->config, "scr.color", 0);
    core->cmd_in_backticks = true;
 
    // execute the sub command
    char *o_out = inn_str[0] == '!' ? rz_core_cmd_str_pipe(core, inn_str) : rz_core_cmd_str(core, inn_str);
 
    // restore color and cmd_in_backticks
    core->num->value = value;
    core->cmd_in_backticks = false;
    rz_config_set_i(core->config, "scr.color", ocolor);
    free(inn_str);
    if (!o_out) {
        return NULL;
    }
 
    // replace the output of the sub command with the current argument
    char *out = strdup(o_out);
    rz_str_trim(out);
    RZ_LOG_DEBUG("output of inner command: '%s'\n", out);
    free(o_out);
 
    // replace newlines and similar with spaces
    replace_whitespaces(out, ' ');
    return out;
}

References rz_core_t::cmd_in_backticks, rz_core_t::config, free(), NULL, rz_core_t::num, out, replace_whitespaces(), rz_config_get_i(), rz_config_set_i(), rz_core_cmd_str(), rz_core_cmd_str_pipe(), RZ_LOG_DEBUG, rz_str_trim(), strdup(), ts_node_sub_parent_string(), value, and rz_num_t::value.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and handle_cmd_substitution_arg().

do_handle_ts_unescape_arg()

static char* do_handle_ts_unescape_arg ( struct tsr2cmd_state *  state, TSNode  arg, bool  do_unwrap  )

static

Definition at line 3461 of file cmd.c.

                                                                                                {
    if (is_ts_arg(arg)) {
        return do_handle_ts_unescape_arg(state, ts_node_named_child(arg, 0), do_unwrap);
    } else if (is_ts_arg_identifier(arg)) {
        char *arg_str = ts_node_sub_string(arg, state->input);
        char *unescaped_arg = rz_cmd_unescape_arg(arg_str, RZ_CMD_ESCAPE_ONE_ARG);
        free(arg_str);
        return unescaped_arg;
    } else if (is_ts_single_quoted_arg(arg) || is_ts_double_quoted_arg(arg)) {
        char *o_arg_str = ts_node_sub_string(arg, state->input);
        char *arg_str = o_arg_str;
        if (do_unwrap) {
            // remove quotes
            arg_str[strlen(arg_str) - 1] = '\0';
            arg_str++;
        }
        char *res;
        if (is_ts_single_quoted_arg(arg)) {
            res = rz_cmd_unescape_arg(arg_str, RZ_CMD_ESCAPE_SINGLE_QUOTED_ARG);
        } else {
            res = rz_cmd_unescape_arg(arg_str, RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG);
        }
        free(o_arg_str);
        return res;
    } else if (is_ts_concatenation(arg)) {
        uint32_t i, n_children = ts_node_named_child_count(arg);
        RzStrBuf *sb = rz_strbuf_new(NULL);
        for (i = 0; i < n_children; i++) {
            TSNode sub_arg = ts_node_named_child(arg, i);
            char *s = do_handle_ts_unescape_arg(state, sub_arg, do_unwrap);
            rz_strbuf_append(sb, s);
            free(s);
        }
        return rz_strbuf_drain(sb);
    } else {
        return ts_node_sub_string(arg, state->input);
    }
}

References free(), i, NULL, RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG, RZ_CMD_ESCAPE_ONE_ARG, RZ_CMD_ESCAPE_SINGLE_QUOTED_ARG, rz_cmd_unescape_arg(), rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_new(), s, sb, ts_node_named_child(), ts_node_named_child_count(), and ts_node_sub_string().

Referenced by parse_args().

do_iter_offsets()

static RzCmdStatus do_iter_offsets ( RzCore *  core, struct tsr2cmd_state *  state, TSNode *  command, RzCmdParsedArgs *  a, bool  has_size  )

static

Definition at line 4455 of file cmd.c.

                                                                                                                                  {
    RzCmdStatus res = RZ_CMD_STATUS_OK;
 
    const char *s;
    int i;
    ut64 orig_offset = core->offset;
    ut64 orig_blk_sz = core->blocksize;
    rz_cmd_parsed_args_foreach_arg(a, i, s) {
        ut64 addr = rz_num_math(core->num, s);
        ut64 blk_sz = core->blocksize;
        if (has_size) {
            blk_sz = rz_num_math(core->num, a->argv[i++ + 1]);
        }
        rz_core_seek(core, addr, true);
        if (has_size) {
            rz_core_block_size(core, blk_sz);
        }
        RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, *command);
        rz_cons_flush();
        UPDATE_CMD_STATUS_RES(res, cmd_res, err);
    }
 
err:
    if (has_size) {
        rz_core_block_size(core, orig_blk_sz);
    }
    rz_core_seek(core, orig_offset, true);
    return res;
}

References a, addr, rz_core_t::blocksize, command, err, handle_ts_stmt_tmpseek(), i, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_cons_flush(), rz_core_block_size(), rz_core_seek(), rz_num_math(), s, UPDATE_CMD_STATUS_RES, and ut64().

Referenced by iter_offsets_common().

do_iter_sections()

static RzCmdStatus do_iter_sections ( struct tsr2cmd_state *  state, TSNode  node, bool  show_sections  )

static

Definition at line 4868 of file cmd.c.

                                                                                                  {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    RzBinObject *obj = rz_bin_cur_object(core->bin);
    if (!obj) {
        return false;
    }
    RzCmdStatus res = RZ_CMD_STATUS_OK;
    ut64 offorig = core->offset;
    ut64 bszorig = core->blocksize;
    RzBinSection *sec;
    RzListIter *iter;
    rz_list_foreach (obj->sections, iter, sec) {
        if ((sec->is_segment && show_sections) || (!sec->is_segment && !show_sections)) {
            continue;
        }
        if (sec->vaddr == UT64_MAX) {
            continue;
        }
        rz_core_seek(core, sec->vaddr, true);
        rz_core_block_size(core, sec->vsize);
        RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
        UPDATE_CMD_STATUS_RES(res, cmd_res, err);
    }
err:
    rz_core_block_size(core, bszorig);
    rz_core_seek(core, offorig, true);
    return res;
}

References rz_core_t::bin, rz_core_t::blocksize, command, err, handle_ts_stmt_tmpseek(), rz_bin_section_t::is_segment, rz_core_t::offset, rz_bin_cur_object(), RZ_CMD_STATUS_OK, rz_core_block_size(), rz_core_seek(), rz_bin_object_t::sections, ts_node_named_child(), UPDATE_CMD_STATUS_RES, ut64(), UT64_MAX, rz_bin_section_t::vaddr, and rz_bin_section_t::vsize.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL().

duplicate_flag()

static bool duplicate_flag ( RzFlagItem *  flag, void *  u  )

static

Definition at line 172 of file cmd.c.

                                                      {
    struct duplicate_flag_t *user = (struct duplicate_flag_t *)u;
    /* filter per flag spaces */
    if (!user->word || rz_str_glob(flag->name, user->word)) {
        RzFlagItem *cloned_item = rz_flag_item_clone(flag);
        if (!cloned_item) {
            return false;
        }
        rz_list_append(user->ret, cloned_item);
    }
    return true;
}

References rz_flag_item_t::name, duplicate_flag_t::ret, rz_flag_item_clone(), rz_list_append(), rz_str_glob(), and duplicate_flag_t::word.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and rz_core_cmd_foreach().

find_ch_after_macro()

static char* find_ch_after_macro ( char *  ptr, char  ch  )

static

Definition at line 1181 of file cmd.c.

                                                     {
    int depth = 0;
    while (*ptr) {
        if (depth == 0 && *ptr == ch) {
            return ptr;
        }
        if (*ptr == '(') {
            depth++;
        } else if (*ptr == ')') {
            depth--;
        }
        ptr++;
    }
    return NULL;
}

References NULL.

Referenced by rz_core_cmd_subst(), and rz_core_cmd_subst_i().

find_eoq()

static char* find_eoq ( char *  p )

static

Definition at line 1360 of file cmd.c.

                               {
    for (; *p; p++) {
        if (*p == '"') {
            break;
        }
        if (*p == '\\' && p[1] == '"') {
            p++;
        }
    }
    return p;
}

References p.

Referenced by rz_core_cmd_subst_i().

findSeparator()

static char* findSeparator ( char *  p )

static

Definition at line 1372 of file cmd.c.

                                    {
    char *q = strchr(p, '+');
    if (q) {
        return q;
    }
    return strchr(p, '-');
}

References p.

Referenced by rz_core_cmd_subst_i().

foreach_pairs()

static void foreach_pairs ( RzCore *  core, const char *  cmd, const char *  each  )

static

Definition at line 2421 of file cmd.c.

                                                                           {
    const char *arg;
    int pair = 0;
    for (arg = each;;) {
        if (!arg) {
            return;
        }
        char *next = strchr(arg, ' ');
        if (next) {
            *next = 0;
        }
        if (arg && *arg) {
            ut64 n = rz_num_get(NULL, arg);
            if (pair % 2) {
                rz_core_block_size(core, n);
                rz_core_cmd0(core, cmd);
            } else {
                rz_core_seek(core, n, true);
            }
            pair++;
        }
        if (!next) {
            break;
        }
        arg = next + 1;
    }
}

References arg(), cmd, n, NULL, rz_core_block_size(), rz_core_cmd0(), rz_core_seek(), rz_num_get(), and ut64().

Referenced by rz_core_cmd_foreach3().

foreachOffset()

static void foreachOffset ( RzCore *  core, const char *  _cmd, const char *  each  )

static

Definition at line 2737 of file cmd.c.

                                                                            {
    char *cmd = strdup(_cmd);
    char *nextLine = NULL;
    ut64 addr;
    /* foreach list of items */
    while (each) {
        // skip spaces
        while (*each == ' ') {
            each++;
        }
        // stahp if empty string
        if (!*each) {
            break;
        }
        // find newline
        char *nl = strchr(each, '\n');
        if (nl) {
            *nl = 0;
            nextLine = nl + 1;
        } else {
            nextLine = NULL;
        }
        // chop comment in line
        nl = strchr(each, '#');
        if (nl) {
            *nl = 0;
        }
        // space separated numbers
        while (each && *each) {
            // find spaces
            while (*each == ' ') {
                each++;
            }
            char *str = strchr(each, ' ');
            if (str) {
                *str = '\0';
                addr = rz_num_math(core->num, each);
                *str = ' ';
                each = str + 1;
            } else {
                if (!*each) {
                    break;
                }
                addr = rz_num_math(core->num, each);
                each = NULL;
            }
            rz_core_seek(core, addr, true);
            rz_core_cmd(core, cmd, 0);
            rz_cons_flush();
        }
        each = nextLine;
    }
    free(cmd);
}

References addr, cmd, free(), NULL, rz_core_t::num, rz_cons_flush(), rz_core_cmd(), rz_core_seek(), rz_num_math(), cmd_descs_generate::str, strdup(), and ut64().

Referenced by rz_core_cmd_foreach().

free_tsr2cmd_edit()

void free_tsr2cmd_edit

(

struct tsr2cmd_edit *

edit

)

Definition at line 3367 of file cmd.c.

                                                  {
    free(edit->new_text);
    free(edit->old_text);
    free(edit);
}

References free(), tsr2cmd_edit::new_text, and tsr2cmd_edit::old_text.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and substitute_args().

get_help_wrong_cmd()

static void get_help_wrong_cmd ( RzCore *  core, const char *  cmdname  )

static

Definition at line 3617 of file cmd.c.

                                                                  {
    char *cmdname_help = rz_str_newf("%s?", cmdname);
    if (!cmdname_help) {
        return;
    }
    RzCmdParsedArgs *help_pra = rz_cmd_parsed_args_newcmd(cmdname_help);
    if (!help_pra) {
        goto cmdname_err;
    }
    bool use_color = core->print->flags & RZ_PRINT_FLAGS_COLOR;
    char *help_msg = rz_cmd_get_help(core->rcmd, help_pra, use_color);
    if (!help_msg) {
        goto help_pra_err;
    }
    eprintf("%s", help_msg);
    free(help_msg);
help_pra_err:
    rz_cmd_parsed_args_free(help_pra);
cmdname_err:
    free(cmdname_help);
}

References eprintf, rz_print_t::flags, free(), rz_core_t::print, rz_core_t::rcmd, rz_cmd_get_help(), rz_cmd_parsed_args_free(), rz_cmd_parsed_args_newcmd(), RZ_PRINT_FLAGS_COLOR, and rz_str_newf().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL().

handle_cmd_substitution_arg()

static void handle_cmd_substitution_arg ( struct tsr2cmd_state *  state, TSNode  arg, RzList *  edits  )

static

Definition at line 3406 of file cmd.c.

                                                                                                {
    TSNode inn_cmd = ts_node_child(arg, 1);
    rz_return_if_fail(!ts_node_is_null(inn_cmd));
    char *out = do_handle_substitution_cmd(state, inn_cmd);
    if (!out) {
        return;
    }
 
    char *res = NULL;
    // escape special chars to prevent creation of new tokens when parsing again
    if (is_ts_double_quoted_arg(ts_node_parent(arg))) {
        res = rz_cmd_escape_arg(out, RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG);
    } else if (is_ts_pf_arg(ts_node_parent(arg))) {
        res = rz_cmd_escape_arg(out, RZ_CMD_ESCAPE_PF_ARG);
    } else {
        res = rz_cmd_escape_arg(out, RZ_CMD_ESCAPE_MULTI_ARG);
    }
    free(out);
    struct tsr2cmd_edit *e = create_cmd_edit(state, arg, res);
    rz_list_append(edits, e);
}

References create_cmd_edit(), do_handle_substitution_cmd(), e, free(), NULL, out, rz_cmd_escape_arg(), RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG, RZ_CMD_ESCAPE_MULTI_ARG, RZ_CMD_ESCAPE_PF_ARG, rz_list_append(), rz_return_if_fail, ts_node_child(), ts_node_is_null(), and ts_node_parent().

Referenced by handle_substitution_args().

handle_substitution_args()

static void handle_substitution_args ( struct tsr2cmd_state *  state, TSNode  args, RzList *  edits  )

static

Definition at line 3445 of file cmd.c.

                                                                                              {
    if (is_group_of_args(args)) {
        uint32_t n_children = ts_node_named_child_count(args);
        uint32_t i;
        for (i = 0; i < n_children; i++) {
            TSNode arg = ts_node_named_child(args, i);
            handle_substitution_args(state, arg, edits);
        }
    } else if (is_ts_cmd_substitution_arg(args)) {
        handle_cmd_substitution_arg(state, args, edits);
    } else if (is_arg(args)) {
        TSNode arg = ts_node_named_child(args, 0);
        handle_substitution_args(state, arg, edits);
    }
}

References args, handle_cmd_substitution_arg(), i, is_arg(), is_group_of_args(), ts_node_named_child(), and ts_node_named_child_count().

Referenced by substitute_args().

handle_tmp_desc()

static bool handle_tmp_desc ( struct tsr2cmd_state *  state, TSNode  command, const ut8 *  buf, int  sz  )

static

Definition at line 4215 of file cmd.c.

                                                                                                 {
    RzCore *core = state->core;
    int pamode = !core->io->va;
    RzCmdStatus res = RZ_CMD_STATUS_INVALID, o_fixedblock = core->fixedblock;
    RzBuffer *b = rz_buf_new_with_bytes(buf, sz);
    int cur_fd = rz_io_fd_get_current(core->io);
    RzIODesc *d = rz_io_open_buffer(core->io, b, RZ_PERM_RWX, 0);
    if (!d) {
        eprintf("Cannot open io buffer\n");
        goto out_buf;
    }
    if (pamode) {
        rz_config_set_i(core->config, "io.va", 1);
    }
    rz_io_map_new(core->io, d->fd, d->perm, 0, core->offset, rz_buf_size(b));
    ut32 obsz = core->blocksize;
    rz_core_block_size(core, rz_buf_size(b));
    core->fixedblock = true;
    rz_core_block_read(core);
 
    res = handle_ts_stmt(state, command);
 
    core->fixedblock = o_fixedblock;
    if (pamode) {
        rz_config_set_i(core->config, "io.va", 0);
    }
    rz_io_desc_close(d);
    rz_core_block_size(core, obsz);
    rz_io_use_fd(core->io, cur_fd);
 
out_buf:
    rz_buf_free(b);
    return res;
}

References b, rz_core_t::blocksize, command, rz_core_t::config, d, eprintf, rz_core_t::fixedblock, handle_ts_stmt(), rz_core_t::io, rz_core_t::offset, out_buf, rz_buf_free(), rz_buf_new_with_bytes(), rz_buf_size(), RZ_CMD_STATUS_INVALID, rz_config_set_i(), rz_core_block_read(), rz_core_block_size(), rz_io_desc_close(), rz_io_fd_get_current(), rz_io_map_new(), rz_io_open_buffer(), rz_io_use_fd(), RZ_PERM_RWX, and rz_io_t::va.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL().

handle_ts_stmt()

static RzCmdStatus handle_ts_stmt ( struct tsr2cmd_state *  state, TSNode  node  )

static

Definition at line 5083 of file cmd.c.

                                                                            {
    RzCmdStatus ret = RZ_CMD_STATUS_INVALID;
    RzCore *core = state->core;
    RzCmd *cmd = core->rcmd;
 
    // NOTE: code copied from rz_core_cmd, needs rewrite when all the "remote"
    // concept is re-considered.
    if (core->cmdremote) {
        if (*state->input == 'q') {
            RZ_FREE(core->cmdremote);
            return RZ_CMD_STATUS_OK;
        } else if (*state->input != '=' && strncmp(state->input, "!=", 2)) {
            if (core->cmdremote[0]) {
                char *s = rz_str_newf("%s %s", core->cmdremote, state->input);
                rz_core_rtr_cmd(core, s);
                free(s);
            } else {
                char *res = rz_io_system(core->io, state->input);
                if (res) {
                    rz_cons_printf("%s\n", res);
                    free(res);
                }
            }
            return RZ_CMD_STATUS_OK;
        }
    }
 
    TSSymbol node_symbol = ts_node_symbol(node);
    ts_handler handler = ht_up_find(cmd->ts_symbols_ht, node_symbol, NULL);
 
    bool is_lastcmd = state->core->is_lastcmd;
    state->core->is_lastcmd = false;
    if (handler) {
        ret = handler(state, node);
    } else {
        RZ_LOG_WARN("No handler for this kind of command `%s`\n", ts_node_type(node));
    }
    if (state->log && !state->core->is_lastcmd) {
        free(state->core->lastcmd);
        state->core->lastcmd = ts_node_sub_string(node, state->input);
    }
    state->core->is_lastcmd = is_lastcmd;
    return ret;
}

References cmd, rz_core_t::cmdremote, free(), rz_core_t::io, NULL, rz_core_t::rcmd, RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_core_rtr_cmd(), RZ_FREE, rz_io_system(), RZ_LOG_WARN, rz_str_newf(), s, ts_node_sub_string(), ts_node_symbol(), and ts_node_type().

Referenced by core_cmd_raw_node(), DEFINE_HANDLE_TS_FCN(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), handle_tmp_desc(), and handle_ts_stmt_tmpseek().

handle_ts_stmt_tmpseek()

static RzCmdStatus handle_ts_stmt_tmpseek ( struct tsr2cmd_state *  state, TSNode  node  )

static

Definition at line 5128 of file cmd.c.

                                                                                    {
    // TODO: remove tmpseek when no commands will change behaviour based on `@` (tmpseek)
    RzCore *core = state->core;
    bool saved_tmpseek = core->tmpseek;
    core->tmpseek = true;
    RzCmdStatus ret = handle_ts_stmt(state, node);
    core->tmpseek = saved_tmpseek;
    return ret;
}

References handle_ts_stmt(), and rz_core_t::tmpseek.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), do_iter_offsets(), do_iter_sections(), and iter_dbt_commands().

help_search_cmd_desc_entry()

static bool help_search_cmd_desc_entry ( RzCmd *  cmd, const RzCmdDesc *  cd, void *  user  )

static

Definition at line 3845 of file cmd.c.

                                                                                    {
    rz_return_val_if_fail(cd, false);
    RzHelpSearch *hs = (RzHelpSearch *)user;
    if (hs->pj) {
        rz_cmd_get_help_json(cmd, cd, hs->pj);
    } else {
        rz_cmd_get_help_strbuf(cmd, cd, hs->color, hs->sb);
    }
    return true;
}

References cd, cmd, hs, rz_cmd_get_help_json(), rz_cmd_get_help_strbuf(), and rz_return_val_if_fail.

Referenced by rz_cmd_help_search_handler().

is_arg()

static bool is_arg ( TSNode  args )

static

Definition at line 3436 of file cmd.c.

                                {
    return is_ts_arg(args) || is_ts_pf_arg(args);
}

References args.

Referenced by handle_substitution_args(), and is_handled_args().

is_group_of_args()

static bool is_group_of_args ( TSNode  args )

static

Definition at line 3428 of file cmd.c.

                                          {
    return is_ts_args(args) || is_ts_concatenation(args) ||
        is_ts_double_quoted_arg(args) ||
        is_ts_pf_concatenation(args) || is_ts_pf_args(args) ||
        is_ts_pf_dot_cmd_args(args) || is_ts_pf_new_args(args) ||
        is_ts_grep_specifier(args);
}

References args.

Referenced by handle_substitution_args(), and is_handled_args().

is_handled_args()

static bool is_handled_args ( TSNode  args )

static

Definition at line 3440 of file cmd.c.

                                         {
    return is_group_of_args(args) || is_arg(args) ||
        is_ts_cmd_substitution_arg(args) || is_ts_grep_specifier(args);
}

References args, is_arg(), and is_group_of_args().

Referenced by substitute_args().

is_macro_command()

static bool is_macro_command ( const char *  ptr )

static

Definition at line 1173 of file cmd.c.

                                              {
    ptr = rz_str_trim_head_ro(ptr);
    while (IS_DIGIT(*ptr)) {
        ptr++;
    }
    return *ptr == '(';
}

References IS_DIGIT, and rz_str_trim_head_ro().

Referenced by rz_core_cmd_subst(), and rz_core_cmd_subst_i().

iter_dbt_commands()

static bool iter_dbt_commands ( struct tsr2cmd_state *  state, TSNode  node, enum dbt_commands_mode  mode  )

static

Definition at line 4374 of file cmd.c.

                                                                                                     {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    RzList *list = rz_debug_frames(core->dbg, UT64_MAX);
    ut64 orig_offset = core->offset;
    RzDebugFrame *frame;
    RzListIter *iter;
    RzCmdStatus res = RZ_CMD_STATUS_OK;
 
    rz_list_foreach (list, iter, frame) {
        switch (mode) {
        case DBT_COMMANDS_MODE_ADDR:
            rz_core_seek(core, frame->addr, true);
            break;
        case DBT_COMMANDS_MODE_SP:
            rz_core_seek(core, frame->sp, true);
            break;
        case DBT_COMMANDS_MODE_BP:
            rz_core_seek(core, frame->bp, true);
            break;
        default:
            rz_warn_if_reached();
            return RZ_CMD_STATUS_INVALID;
        }
        RzCmdStatus cmd_res = handle_ts_stmt_tmpseek(state, command);
        rz_cons_newline();
        UPDATE_CMD_STATUS_RES(res, cmd_res, err);
    }
err:
    rz_core_seek(core, orig_offset, true);
    rz_list_free(list);
    return res;
}

References rz_debug_frame_t::addr, rz_debug_frame_t::bp, command, rz_core_t::dbg, DBT_COMMANDS_MODE_ADDR, DBT_COMMANDS_MODE_BP, DBT_COMMANDS_MODE_SP, err, handle_ts_stmt_tmpseek(), list(), rz_core_t::offset, RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, rz_cons_newline(), rz_core_seek(), rz_debug_frames(), rz_list_free(), rz_warn_if_reached, rz_debug_frame_t::sp, ts_node_named_child(), UPDATE_CMD_STATUS_RES, ut64(), and UT64_MAX.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL().

iter_offsets_common()

static RzCmdStatus iter_offsets_common ( struct tsr2cmd_state *  state, TSNode  node, bool  has_size  )

static

Definition at line 4485 of file cmd.c.

                                                                                                {
    RzCore *core = state->core;
    TSNode command = ts_node_named_child(node, 0);
    if (ts_node_named_child_count(node) < 2) {
        // no offsets provided, all's good.
        return RZ_CMD_STATUS_OK;
    }
 
    TSNode args = ts_node_named_child(node, 1);
 
    RzCmdParsedArgs *a = ts_node_handle_arg_prargs(state, node, args, 1, true);
    if (!a || (has_size && (a->argc - 1) % 2 != 0)) {
        RZ_LOG_ERROR("Cannot parse args\n");
        rz_cmd_parsed_args_free(a);
        return RZ_CMD_STATUS_INVALID;
    }
 
    RzCmdStatus res = do_iter_offsets(core, state, &command, a, has_size);
    rz_cmd_parsed_args_free(a);
    return res;
}

References a, args, command, do_iter_offsets(), rz_cmd_parsed_args_free(), RZ_CMD_STATUS_INVALID, RZ_CMD_STATUS_OK, RZ_LOG_ERROR, ts_node_handle_arg_prargs(), ts_node_named_child(), and ts_node_named_child_count().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL().

lang_run_file()

static int lang_run_file ( RzCore *  core, RzLang *  lang, const char *  file  )

static

Definition at line 421 of file cmd.c.

                                                                       {
    rz_core_sysenv_begin(core);
    return rz_lang_run_file(core->lang, file);
}

References rz_core_t::lang, rz_core_sysenv_begin(), and rz_lang_run_file().

Referenced by rz_core_run_script().

langFromHashbang()

static char* langFromHashbang ( RzCore *  core, const char *  file  )

static

Definition at line 426 of file cmd.c.

                                                              {
    int fd = rz_sys_open(file, O_RDONLY, 0);
    if (fd != -1) {
        char firstLine[128] = { 0 };
        int len = read(fd, (ut8 *)firstLine, sizeof(firstLine) - 1);
        if (len < 1) {
            close(fd);
            return NULL;
        }
        firstLine[len] = 0;
        if (!strncmp(firstLine, "#!/", 3)) {
            // I CAN HAS A HASHBANG
            char *nl = strchr(firstLine, '\n');
            if (nl) {
                *nl = 0;
            }
            nl = strchr(firstLine, ' ');
            if (nl) {
                *nl = 0;
            }
            nl = strdup(firstLine + 2);
            close(fd);
            return nl;
        }
        close(fd);
    }
    return NULL;
}

References close, fd, len, NULL, O_RDONLY, read(), rz_sys_open(), and strdup().

Referenced by rz_core_run_script().

parse_args()

static RzCmdParsedArgs* parse_args ( struct tsr2cmd_state *  state, TSNode  args, bool  do_unwrap  )

static

Definition at line 3500 of file cmd.c.

                                                                                             {
    if (ts_node_is_null(args)) {
        return rz_cmd_parsed_args_newargs(0, NULL);
    } else if (is_ts_args(args)) {
        uint32_t n_children = ts_node_named_child_count(args);
        uint32_t i;
        char **unescaped_args = RZ_NEWS0(char *, n_children);
        for (i = 0; i < n_children; i++) {
            TSNode arg = ts_node_named_child(args, i);
            unescaped_args[i] = do_handle_ts_unescape_arg(state, arg, do_unwrap);
        }
        RzCmdParsedArgs *res = rz_cmd_parsed_args_newargs(n_children, unescaped_args);
        for (i = 0; i < n_children; i++) {
            free(unescaped_args[i]);
        }
        free(unescaped_args);
        return res;
    } else {
        char *unescaped_args[] = { do_handle_ts_unescape_arg(state, args, do_unwrap) };
        RzCmdParsedArgs *res = rz_cmd_parsed_args_newargs(1, unescaped_args);
        free(unescaped_args[0]);
        return res;
    }
}

References args, do_handle_ts_unescape_arg(), free(), i, NULL, rz_cmd_parsed_args_newargs(), RZ_NEWS0, ts_node_is_null(), ts_node_named_child(), and ts_node_named_child_count().

Referenced by ts_node_handle_arg_prargs().

parse_tmp_evals()

static char* parse_tmp_evals ( RzCore *  core, const char *  str  )

static

Definition at line 1134 of file cmd.c.

                                                            {
    char *s = strdup(str);
    int i, argc = rz_str_split(s, ',');
    char *res = strdup("");
    if (!s || !res) {
        free(s);
        free(res);
        return NULL;
    }
    for (i = 0; i < argc; i++) {
        char *eq, *kv = (char *)rz_str_word_get0(s, i);
        if (!kv) {
            break;
        }
        eq = strchr(kv, '=');
        if (eq) {
            *eq = 0;
            const char *ov = rz_config_get(core->config, kv);
            if (!ov) {
                continue;
            }
            char *cmd = rz_str_newf("e %s=%s;", kv, ov);
            if (!cmd) {
                free(s);
                free(res);
                return NULL;
            }
            res = rz_str_prepend(res, cmd);
            free(cmd);
            rz_config_set(core->config, kv, eq + 1);
            *eq = '=';
        } else {
            eprintf("Missing '=' in e: expression (%s)\n", kv);
        }
    }
    free(s);
    return res;
}

References cmd, rz_core_t::config, eprintf, eq, free(), i, NULL, rz_config_get(), rz_config_set(), rz_str_newf(), rz_str_prepend(), rz_str_split(), rz_str_word_get0(), s, cmd_descs_generate::str, and strdup().

Referenced by rz_core_cmd_subst_i().

recursive_help()

static void recursive_help ( RzCore *  core, int  detail, const char *  cmd_prefix  )

static

Definition at line 205 of file cmd.c.

                                                                             {
    const ut8 *p;
    RzCmdDescriptor *desc = &core->root_cmd_descriptor;
    for (p = (const ut8 *)cmd_prefix; *p && *p < RZ_ARRAY_SIZE(desc->sub); p++) {
        if (!(desc = desc->sub[*p])) {
            return;
        }
    }
    recursive_help_go(core, detail, desc);
}

References desc, p, recursive_help_go(), rz_core_t::root_cmd_descriptor, and RZ_ARRAY_SIZE.

Referenced by rz_core_cmd_subst_i().

recursive_help_go()

static void recursive_help_go ( RzCore *  core, int  detail, RzCmdDescriptor *  desc  )

static

Definition at line 185 of file cmd.c.

                                                                               {
    int i;
    if (desc->help_msg) {
        rz_core_cmd_help(core, desc->help_msg);
    }
    if (detail >= 1) {
        if (desc->help_detail) {
            rz_core_cmd_help(core, desc->help_detail);
        }
        if (detail >= 2 && desc->help_detail2) {
            rz_core_cmd_help(core, desc->help_detail2);
        }
    }
    for (i = 32; i < RZ_ARRAY_SIZE(desc->sub); i++) {
        if (desc->sub[i]) {
            recursive_help_go(core, detail, desc->sub[i]);
        }
    }
}

References desc, i, RZ_ARRAY_SIZE, and rz_core_cmd_help().

Referenced by recursive_help().

replace_whitespaces()

static void replace_whitespaces ( char *  s, char  ch  )

static

Definition at line 3352 of file cmd.c.

                                                  {
    while (*s) {
        if (*s == '#') {
            while (*s && *s != '\r' && *s != '\n') {
                *s = ch;
                s++;
            }
        }
        if (isspace(*s)) {
            *s = ch;
        }
        s++;
    }
}

References isspace, and s.

Referenced by do_handle_substitution_cmd().

run_cmd_depth()

static int run_cmd_depth ( RzCore *  core, char *  cmd  )

static

Definition at line 5296 of file cmd.c.

                                                  {
    char *rcmd;
    int ret = false;
 
    if (core->cons->context->cmd_depth < 1) {
        eprintf("rz_core_cmd: That was too deep (%s)...\n", cmd);
        return false;
    }
    core->cons->context->cmd_depth--;
    for (rcmd = cmd;;) {
        char *ptr = strchr(rcmd, '\n');
        if (ptr) {
            *ptr = '\0';
        }
        ret = rz_core_cmd_subst(core, rcmd);
        if (ret == -1) {
            eprintf("|ERROR| Invalid command '%s' (0x%02x)\n", rcmd, *rcmd);
            break;
        }
        if (!ptr) {
            break;
        }
        rcmd = ptr + 1;
    }
    core->cons->context->cmd_depth++;
    return ret;
}

References cmd, rz_cons_context_t::cmd_depth, rz_core_t::cons, rz_cons_t::context, tsr2cmd_state::core, eprintf, and rz_core_cmd_subst().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL().

rz_basefind_compute_handler()

RZ_IPI RzCmdStatus rz_basefind_compute_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 5603 of file cmd.c.

                                                                                                                   {
    ut32 pointer_size = 0;
    if (argc != 2 || RZ_STR_ISEMPTY(argv[1])) {
        pointer_size = 32;
    } else if (!strcmp(argv[1], "32")) {
        pointer_size = 32;
    } else if (!strcmp(argv[1], "64")) {
        pointer_size = 64;
    }
    return bool2status(rz_core_bin_basefind_print(core, pointer_size, state));
}

References argv, bool2status(), rz_core_bin_basefind_print(), and RZ_STR_ISEMPTY.

Referenced by rzshell_cmddescs_init().

rz_cmd_alias()

RZ_IPI int rz_cmd_alias	(	void *	data,
		const char *	input
	)

Definition at line 278 of file cmd.c.

                                                       {
    RzCore *core = (RzCore *)data;
    if (*input == '?') {
        rz_core_cmd_help(core, help_msg_dollar);
        return 0;
    }
    int i = strlen(input);
    char *buf = malloc(i + 2);
    if (!buf) {
        return 0;
    }
    *buf = '$'; // prefix aliases with a dollar
    memcpy(buf + 1, input, i + 1);
    char *q = strchr(buf, ' ');
    char *def = strchr(buf, '=');
    char *desc = strchr(buf, '?');
    char *nonl = strchr(buf, 'n');
 
    int defmode = 0;
    if (def && def > buf) {
        char *prev = def - 1;
        switch (*prev) {
        case ':':
            defmode = *prev;
            *prev = 0;
            break;
        case '+':
            defmode = *prev;
            *prev = 0;
            break;
        case '-':
            defmode = *prev;
            *prev = 0;
            break;
        }
    }
 
    /* create alias */
    if ((def && q && (def < q)) || (def && !q)) {
        *def++ = 0;
        size_t len = strlen(def);
        if (defmode) {
            ut64 at = rz_num_math(core->num, def);
            switch (defmode) {
            case ':':
                rz_flag_set(core->flags, buf + 1, at, 1);
                return 1;
            case '+':
                at = rz_num_get(core->num, buf + 1) + at;
                rz_flag_set(core->flags, buf + 1, at, 1);
                return 1;
            case '-':
                at = rz_num_get(core->num, buf + 1) - at;
                rz_flag_set(core->flags, buf + 1, at, 1);
                return 1;
            }
        }
        /* Remove quotes */
        if (len > 0 && (def[0] == '\'') && (def[len - 1] == '\'')) {
            def[len - 1] = 0x00;
            def++;
        }
        if (!q || (q && q > def)) {
            if (*def) {
                if (!strcmp(def, "-")) {
                    char *v = rz_cmd_alias_get(core->rcmd, buf, 0);
                    char *n = rz_core_editor(core, NULL, v);
                    if (n) {
                        rz_cmd_alias_set(core->rcmd, buf, n, 0);
                        free(n);
                    }
                } else {
                    rz_cmd_alias_set(core->rcmd, buf, def, 0);
                }
            } else {
                rz_cmd_alias_del(core->rcmd, buf);
            }
        }
        /* Show command for alias */
    } else if (desc && !q) {
        *desc = 0;
        char *v = rz_cmd_alias_get(core->rcmd, buf, 0);
        if (v) {
            if (nonl == desc + 1) {
                rz_cons_print(v);
            } else {
                rz_cons_println(v);
            }
            free(buf);
            return 1;
        } else {
            eprintf("unknown key '%s'\n", buf);
        }
    } else if (buf[1] == '*') {
        /* Show aliases */
        int i, count = 0;
        char **keys = rz_cmd_alias_keys(core->rcmd, &count);
        for (i = 0; i < count; i++) {
            char *v = rz_cmd_alias_get(core->rcmd, keys[i], 0);
            char *q = rz_base64_encode_dyn((const ut8 *)v, strlen(v));
            if (buf[2] == '*') {
                rz_cons_printf("%s=%s\n", keys[i], v);
            } else {
                rz_cons_printf("%s=base64:%s\n", keys[i], q);
            }
            free(q);
        }
    } else if (!buf[1]) {
        int i, count = 0;
        char **keys = rz_cmd_alias_keys(core->rcmd, &count);
        for (i = 0; i < count; i++) {
            rz_cons_println(keys[i]);
        }
    } else {
        /* Execute alias */
        if (q) {
            *q = 0;
        }
        char *v = rz_cmd_alias_get(core->rcmd, buf, 0);
        if (v) {
            if (*v == '$') {
                rz_cons_strcat(v + 1);
                rz_cons_newline();
            } else if (q) {
                char *out = rz_str_newf("%s %s", v, q + 1);
                rz_core_cmd0(core, out);
                free(out);
            } else {
                rz_core_cmd0(core, v);
            }
        } else {
            ut64 at = rz_num_get(core->num, buf + 1);
            if (at != UT64_MAX) {
                rz_core_seek(core, at, true);
            } else {
                eprintf("Unknown alias '%s'\n", buf + 1);
            }
        }
    }
    free(buf);
    return 0;
}

References count, def(), desc, eprintf, rz_core_t::flags, free(), help_msg_dollar, i, input(), keys, len, malloc(), memcpy(), n, NULL, rz_core_t::num, out, rz_core_t::rcmd, rz_base64_encode_dyn(), rz_cmd_alias_del(), rz_cmd_alias_get(), rz_cmd_alias_keys(), rz_cmd_alias_set(), rz_cons_newline(), rz_cons_printf(), rz_cons_println(), rz_cons_strcat(), rz_core_cmd0(), rz_core_cmd_help(), rz_core_editor(), rz_core_seek(), rz_flag_set(), rz_num_get(), rz_num_math(), rz_str_newf(), ut64(), UT64_MAX, and v.

Referenced by rz_core_cmd_init(), and rzshell_cmddescs_init().

rz_cmd_help_search_handler()

RZ_IPI RzCmdStatus rz_cmd_help_search_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzOutputMode	mode
	)

Definition at line 3856 of file cmd.c.

                                                                                                            {
    RzCmdStatus status = RZ_CMD_STATUS_OK;
    RzCmdDesc *begin = NULL;
 
    if (argc == 2) {
        begin = rz_cmd_get_desc(core->rcmd, argv[1]);
        if (!begin) {
            RZ_LOG_ERROR("Command '%s' does not exist.\n", argv[1]);
            status = RZ_CMD_STATUS_ERROR;
            goto exit_status;
        }
    }
 
    RzHelpSearch hs = {
        .color = core->print->flags & RZ_PRINT_FLAGS_COLOR,
        .pj = NULL,
        .sb = NULL,
    };
 
    if (mode & RZ_OUTPUT_MODE_JSON) {
        hs.pj = pj_new();
        if (!hs.pj) {
            status = RZ_CMD_STATUS_ERROR;
            goto exit_status;
        }
        pj_o(hs.pj);
    } else {
        hs.sb = rz_strbuf_new(NULL);
        if (!hs.sb) {
            status = RZ_CMD_STATUS_ERROR;
            goto exit_status;
        }
    }
 
    rz_cmd_foreach_cmdname(core->rcmd, begin, help_search_cmd_desc_entry, &hs);
 
    if (mode & RZ_OUTPUT_MODE_JSON) {
        pj_end(hs.pj);
        rz_cons_printf("%s\n", pj_string(hs.pj));
        pj_free(hs.pj);
    } else {
        char *help = rz_strbuf_drain(hs.sb);
        rz_cons_printf("%s", help);
        free(help);
    }
exit_status:
    return status;
}

References argv, exit_status, rz_print_t::flags, free(), cmd_descs_generate::help, help_search_cmd_desc_entry(), hs, NULL, pj_end(), pj_free(), pj_new(), pj_o(), pj_string(), rz_core_t::print, rz_core_t::rcmd, rz_cmd_foreach_cmdname(), rz_cmd_get_desc(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), RZ_LOG_ERROR, RZ_OUTPUT_MODE_JSON, RZ_PRINT_FLAGS_COLOR, rz_strbuf_drain(), rz_strbuf_new(), and status.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and rzshell_cmddescs_init().

rz_cmd_kuery()

RZ_IPI int rz_cmd_kuery	(	void *	data,
		const char *	input
	)

Definition at line 642 of file cmd.c.

                                                       {
    char buf[1024], *out, *tofree;
    RzCore *core = (RzCore *)data;
    const char *sp, *p = "[sdb]> ";
    Sdb *s = core->sdb;
 
    char *cur_pos = NULL, *cur_cmd = NULL, *next_cmd = NULL;
    char *temp_pos = NULL, *temp_cmd = NULL;
 
    switch (input[0]) {
    case 'j':
        tofree = out = sdb_querys(s, NULL, 0, "analysis/**");
        if (!out) {
            rz_cons_println("No Output from sdb");
            break;
        }
        PJ *pj = pj_new();
        if (!pj) {
            free(out);
            break;
        }
        pj_o(pj);
        pj_ko(pj, "analysis");
        pj_ka(pj, "cur_cmd");
 
        while (*out) {
            cur_pos = strchr(out, '\n');
            if (!cur_pos) {
                break;
            }
            cur_cmd = rz_str_ndup(out, cur_pos - out);
            pj_s(pj, cur_cmd);
 
            free(next_cmd);
            next_cmd = rz_str_newf("analysis/%s/*", cur_cmd);
            char *query_result = sdb_querys(s, NULL, 0, next_cmd);
 
            if (!query_result) {
                out = cur_pos + 1;
                continue;
            }
 
            char *temp = query_result;
            while (*temp) {
                temp_pos = strchr(temp, '\n');
                if (!temp_pos) {
                    break;
                }
                temp_cmd = rz_str_ndup(temp, temp_pos - temp);
                pj_s(pj, temp_cmd);
                free(temp_cmd);
                temp = temp_pos + 1;
            }
            out = cur_pos + 1;
            free(query_result);
        }
        pj_end(pj);
        pj_end(pj);
        pj_end(pj);
        rz_cons_println(pj_string(pj));
        pj_free(pj);
        RZ_FREE(next_cmd);
        free(next_cmd);
        free(cur_cmd);
        free(tofree);
        break;
 
    case ' ':
        rz_core_kuery_print(core, input + 1);
        break;
    // case 's': rz_pair_save (s, input + 3); break;
    // case 'l': rz_pair_load (sdb, input + 3); break;
    case '\0':
        sdb_foreach(s, callback_foreach_kv, NULL);
        break;
    // TODO: add command to list all namespaces // sdb_ns_foreach ?
    case 's': // "ks"
        if (core->http_up) {
            return false;
        }
        if (!rz_cons_is_interactive()) {
            return false;
        }
        if (input[1] == ' ') {
            char *n, *o, *p = strdup(input + 2);
            // TODO: slash split here? or inside sdb_ns ?
            for (n = o = p; n; o = n) {
                n = strchr(o, '/'); // SDB_NS_SEPARATOR NAMESPACE
                if (n) {
                    *n++ = 0;
                }
                s = sdb_ns(s, o, 1);
            }
            free(p);
        }
        if (!s) {
            s = core->sdb;
        }
        RzLine *line = core->cons->line;
        if (!line->sdbshell_hist) {
            line->sdbshell_hist = rz_list_newf(free);
            rz_list_append(line->sdbshell_hist, rz_str_new("\0"));
        }
        RzList *sdb_hist = line->sdbshell_hist;
        rz_line_set_hist_callback(line, &rz_line_hist_sdb_up, &rz_line_hist_sdb_down);
        for (;;) {
            rz_line_set_prompt(p);
            if (rz_cons_fgets(buf, sizeof(buf), 0, NULL) < 1) {
                break;
            }
            if (!*buf) {
                break;
            }
            if (sdb_hist) {
                if ((rz_list_length(sdb_hist) == 1) || (rz_list_length(sdb_hist) > 1 && strcmp(rz_list_get_n(sdb_hist, 1), buf))) {
                    rz_list_insert(sdb_hist, 1, strdup(buf));
                }
                line->sdbshell_hist_iter = sdb_hist->head;
            }
            out = sdb_querys(s, NULL, 0, buf);
            if (out) {
                rz_cons_println(out);
                rz_cons_flush();
            }
        }
        rz_line_set_hist_callback(core->cons->line, &rz_line_hist_cmd_up, &rz_line_hist_cmd_down);
        break;
    case 'o': // "ko"
        if (input[1] == ' ') {
            char *fn = strdup(input + 2);
            if (!fn) {
                eprintf("Unable to allocate memory\n");
                return 0;
            }
            char *ns = strchr(fn, ' ');
            if (ns) {
                Sdb *db;
                *ns++ = 0;
                if (rz_file_exists(fn)) {
                    db = sdb_ns_path(core->sdb, ns, 1);
                    if (db) {
                        Sdb *newdb = sdb_new(NULL, fn, 0);
                        if (newdb) {
                            sdb_drain(db, newdb);
                        } else {
                            eprintf("Cannot open sdb '%s'\n", fn);
                        }
                    } else {
                        eprintf("Cannot find sdb '%s'\n", ns);
                    }
                } else {
                    eprintf("Cannot open file\n");
                }
            } else {
                eprintf("Missing sdb namespace\n");
            }
            free(fn);
        } else {
            eprintf("Usage: ko [file] [namespace]\n");
        }
        break;
    case 'd': // "kd"
        if (input[1] == ' ') {
            char *fn = strdup(input + 2);
            char *ns = strchr(fn, ' ');
            if (ns) {
                *ns++ = 0;
                Sdb *db = sdb_ns_path(core->sdb, ns, 0);
                if (db) {
                    sdb_file(db, fn);
                    sdb_sync(db);
                } else {
                    eprintf("Cannot find sdb '%s'\n", ns);
                }
            } else {
                eprintf("Missing sdb namespace\n");
            }
            free(fn);
        } else {
            eprintf("Usage: kd [file] [namespace]\n");
        }
        break;
    case '?':
        rz_core_cmd_help(core, help_msg_k);
        break;
    }
 
    if (input[0] == '\0') {
        /* nothing more to do, the command has been parsed. */
        return 0;
    }
 
    sp = strchr(input + 1, ' ');
    if (sp) {
        char *inp = strdup(input);
        inp[(size_t)(sp - input)] = 0;
        s = sdb_ns(core->sdb, inp + 1, 1);
        out = sdb_querys(s, NULL, 0, sp + 1);
        if (out) {
            rz_cons_println(out);
            free(out);
        }
        free(inp);
        return 0;
    }
    return 0;
}

References callback_foreach_kv(), rz_core_t::cons, eprintf, fn, free(), rz_list_t::head, help_msg_k, rz_core_t::http_up, input(), rz_cons_t::line, setup::line, n, NULL, out, p, pj_end(), pj_free(), pj_ka(), pj_ko(), pj_new(), pj_o(), pj_s(), pj_string(), rz_cons_fgets(), rz_cons_flush(), rz_cons_is_interactive(), rz_cons_println(), rz_core_cmd_help(), rz_core_kuery_print(), rz_file_exists(), RZ_FREE, rz_line_hist_cmd_down(), rz_line_hist_cmd_up(), rz_line_hist_sdb_down(), rz_line_hist_sdb_up(), rz_line_set_hist_callback(), rz_line_set_prompt(), rz_list_append(), rz_list_get_n(), rz_list_insert(), rz_list_length(), rz_list_newf(), rz_str_ndup(), rz_str_new(), rz_str_newf(), s, rz_core_t::sdb, sdb_drain(), sdb_file(), sdb_foreach(), sdb_new(), sdb_ns(), sdb_ns_path(), sdb_querys(), sdb_sync(), sp, and strdup().

Referenced by rz_core_cmd_init(), and rzshell_cmddescs_init().

rz_cmd_panels()

RZ_IPI int rz_cmd_panels	(	void *	data,
		const char *	input
	)

Definition at line 850 of file cmd.c.

                                                        {
    RzCore *core = (RzCore *)data;
    if (core->vmode) {
        return false;
    }
    if (!rz_cons_is_interactive()) {
        eprintf("Panel mode requires scr.interactive=true.\n");
        return false;
    }
    char *sp = strchr(input, ' ');
    switch (input[0]) {
    case ' ': // "v [name]"
        if (core->panels) {
            rz_load_panels_layout(core, input + 1);
        }
        rz_config_set(core->config, "scr.layout", input + 1);
        return true;
    case '=': // "v= [name]"
        rz_save_panels_layout(core, input + 1);
        rz_config_set(core->config, "scr.layout", input + 1);
        return true;
    case 'i': // "vi [file]"
        if (sp) {
            char *r = rz_core_editor(core, sp + 1, NULL);
            if (r) {
                free(r);
            } else {
                eprintf("Cannot open file (%s)\n", sp + 1);
            }
        }
        return false;
    case 0:
        rz_core_visual_panels_root(core, core->panels_root);
        return true;
    default:
        rz_core_cmd_help(core, help_msg_v);
        return false;
    }
}

References rz_core_t::config, eprintf, free(), help_msg_v, input(), NULL, rz_core_t::panels, rz_core_t::panels_root, r, rz_config_set(), rz_cons_is_interactive(), rz_core_cmd_help(), rz_core_editor(), rz_core_visual_panels_root(), rz_load_panels_layout(), rz_save_panels_layout(), sp, and rz_core_t::vmode.

Referenced by rz_core_cmd_init(), and rzshell_cmddescs_init().

rz_cmd_visual()

RZ_IPI int rz_cmd_visual	(	void *	data,
		const char *	input
	)

Definition at line 891 of file cmd.c.

                                                        {
    RzCore *core = (RzCore *)data;
    if (core->http_up) {
        return false;
    }
    if (!rz_cons_is_interactive()) {
        eprintf("Visual mode requires scr.interactive=true.\n");
        return false;
    }
    return rz_core_visual((RzCore *)data, input);
}

References eprintf, rz_core_t::http_up, input(), rz_cons_is_interactive(), and rz_core_visual().

Referenced by rz_core_cmd_init(), and rzshell_cmddescs_init().

rz_core_cmd()

RZ_API int rz_core_cmd	(	RzCore *	core,
		const char *	cstr,
		int	log
	)

Definition at line 5328 of file cmd.c.

                                                                {
    return rz_cmd_status2int(core_cmd_tsrzcmd(core, cstr, false, log));
}

References tsr2cmd_state::core, and core_cmd_tsrzcmd().

Referenced by __handleComment(), _cb_hit(), _CbInRangeSearchV(), cmd_task_runner(), core_cmd_raw(), do_analysis_search(), do_ref_search(), do_syscall_search(), foreachOffset(), rz_cmd_debug_dmi(), rz_cmd_help(), rz_core_bin_load(), rz_core_cmd0(), rz_core_cmd_buffer(), rz_core_cmd_command(), rz_core_cmd_foreach(), rz_core_cmd_foreach3(), rz_core_cmd_pipe_old(), rz_core_cmd_str_pipe(), rz_core_cmdf(), rz_core_file_open(), rz_core_flush(), rz_core_prompt_exec(), rz_core_rtr_gdb_cb(), rz_core_visual_analysis_classes(), rz_core_visual_bit_editor(), rz_core_visual_classes(), rz_core_visual_cmd(), rz_core_visual_comments(), rz_core_visual_config(), rz_core_visual_prompt(), rz_core_visual_trackflags(), rz_core_visual_view_rop(), rz_interpret_handler(), rz_interpret_output_handler(), and set_prompt().

rz_core_cmd0()

RZ_API int rz_core_cmd0	(	RzCore *	core,
		const char *	cmd
	)

Definition at line 5428 of file cmd.c.

                                                       {
    return rz_core_cmd(core, cmd, 0);
}

References cmd, tsr2cmd_state::core, and rz_core_cmd().

Referenced by __cons_cb_fkey(), __handle_console(), __panels_process(), addVar(), agraph_print(), cb_iova(), cmd_analysis_graph(), cmd_print_format(), convert_dot_to_image(), core_cmd0_wrapper(), core_file_do_load_for_debug(), do_analysis_search(), dot_trace_traverse(), foreach_pairs(), on_fcn_delete(), on_fcn_new(), on_fcn_rename(), perform_analysis(), rz_analysis_aefa(), rz_analyze_all_functions_esil_handler(), rz_analyze_all_functions_handler(), rz_cmd_alias(), rz_cmd_print(), rz_cmd_search(), rz_core_analysis_recover_golang_functions(), rz_core_bind(), rz_core_cmd_foreach(), rz_core_cmd_foreach3(), rz_core_cmd_lastcmd_repeat(), rz_core_cmd_subst(), rz_core_cmd_subst_i(), rz_core_cmpwatch_show(), rz_core_debug_breakpoint_hit(), rz_core_debug_syscall_hit(), rz_core_file_open(), rz_core_magic_at(), rz_core_print_examine(), rz_core_rtr_http_run(), rz_core_visual(), rz_core_visual_analysis(), rz_core_visual_browse(), rz_core_visual_classes(), rz_core_visual_cmd(), rz_core_visual_debugtraces(), rz_core_visual_define(), rz_core_visual_esil(), rz_core_visual_graph(), rz_core_visual_hud(), rz_core_visual_trackflags(), rz_core_visual_view_graph(), rz_core_visual_view_rop(), rz_core_visual_xrefs(), rz_flag_hexdump_handler(), rz_history_list_or_exec_handler(), rz_interpret_script_handler(), rz_main_rizin(), seek_to_node(), visual_nkey(), visual_offset(), and visual_refresh().

rz_core_cmd0_rzshell()

RZ_API RzCmdStatus rz_core_cmd0_rzshell	(	RzCore *	core,
		const char *	cmd
	)

Definition at line 5424 of file cmd.c.

                                                                       {
    return rz_core_cmd_rzshell(core, cmd, 0);
}

References cmd, tsr2cmd_state::core, and rz_core_cmd_rzshell().

Referenced by rz_cmd_analysis().

rz_core_cmd_buffer()

RZ_API int rz_core_cmd_buffer	(	RzCore *	core,
		const char *	buf
	)

Definition at line 5395 of file cmd.c.

                                                             {
    char *ptr, *optr, *str = strdup(buf);
    if (!str) {
        return false;
    }
    optr = str;
    ptr = strchr(str, '\n');
    while (ptr) {
        *ptr = '\0';
        rz_core_cmd(core, optr, 0);
        optr = ptr + 1;
        ptr = strchr(str, '\n');
    }
    rz_core_cmd(core, optr, 0);
    free(str);
    return true;
}

References tsr2cmd_state::core, free(), rz_core_cmd(), cmd_descs_generate::str, and strdup().

rz_core_cmd_command()

RZ_API int rz_core_cmd_command	(	RzCore *	core,
		const char *	command
	)

Definition at line 5360 of file cmd.c.

                                                                  {
    int ret, len;
    char *buf, *rcmd;
    rz_core_sysenv_begin(core);
    rcmd = buf = rz_sys_cmd_str(command, 0, &len);
    if (!buf) {
        return -1;
    }
    ret = rz_core_cmd(core, rcmd, 0);
    rz_core_sysenv_end(core);
    free(buf);
    return ret;
}

References command, tsr2cmd_state::core, free(), len, rz_core_cmd(), rz_core_sysenv_begin(), rz_core_sysenv_end(), and rz_sys_cmd_str().

rz_core_cmd_file()

RZ_API int rz_core_cmd_file	(	RzCore *	core,
		const char *	file
	)

Definition at line 5341 of file cmd.c.

                                                            {
    char *data = rz_file_abspath(file);
    if (!data) {
        return false;
    }
    char *odata = rz_file_slurp(data, NULL);
    free(data);
    if (!odata) {
        return false;
    }
    if (!rz_core_cmd_lines(core, odata)) {
        eprintf("Failed to run script '%s'\n", file);
        free(odata);
        return false;
    }
    free(odata);
    return true;
}

References tsr2cmd_state::core, eprintf, free(), NULL, rz_core_cmd_lines(), rz_file_abspath(), and rz_file_slurp().

Referenced by cmd_print_format(), load_theme(), rz_core_parse_rizinrc(), rz_core_run_script(), and rz_main_rizin().

rz_core_cmd_foreach()

RZ_API int rz_core_cmd_foreach	(	RzCore *	core,
		const char *	cmd,
		char *	each
	)

Definition at line 2798 of file cmd.c.

                                                                          {
    int i, j;
    char ch;
    char *word = NULL;
    char *str, *ostr = NULL;
    RzListIter *iter;
    RzFlagItem *flag;
    ut64 oseek, addr;
 
    for (; *cmd == ' '; cmd++) {
        ;
    }
 
    oseek = core->offset;
    ostr = str = strdup(each);
    rz_cons_break_push(NULL, NULL); // pop on return
    switch (each[0]) {
    case '/': // "@@/"
    {
        char *cmdhit = strdup(rz_config_get(core->config, "cmd.hit"));
        rz_config_set(core->config, "cmd.hit", cmd);
        rz_core_cmd0(core, each);
        rz_config_set(core->config, "cmd.hit", cmdhit);
        free(cmdhit);
    }
        free(ostr);
        return 0;
    case '?': // "@@?"
        rz_core_cmd_help(core, help_msg_at_at);
        break;
    case 'b': // "@@b" - function basic blocks
    {
        RzListIter *iter;
        RzAnalysisBlock *bb;
        RzAnalysisFunction *fcn = rz_analysis_get_function_at(core->analysis, core->offset);
        int bs = core->blocksize;
        if (fcn) {
            rz_list_sort(fcn->bbs, bb_cmp);
            rz_list_foreach (fcn->bbs, iter, bb) {
                rz_core_block_size(core, bb->size);
                rz_core_seek(core, bb->addr, true);
                rz_core_cmd(core, cmd, 0);
                if (rz_cons_is_breaked()) {
                    break;
                }
            }
        }
        rz_core_block_size(core, bs);
        goto out_finish;
    } break;
    case 's': // "@@s" - sequence
    {
        char *str = each + 1;
        if (*str == ':' || *str == ' ') {
            str++;
        }
        int count = rz_str_split(str, ' ');
        if (count == 3) {
            ut64 cur;
            ut64 from = rz_num_math(core->num, rz_str_word_get0(str, 0));
            ut64 to = rz_num_math(core->num, rz_str_word_get0(str, 1));
            ut64 step = rz_num_math(core->num, rz_str_word_get0(str, 2));
            for (cur = from; cur <= to; cur += step) {
                (void)rz_core_seek(core, cur, true);
                rz_core_cmd(core, cmd, 0);
                if (rz_cons_is_breaked()) {
                    break;
                }
            }
        } else {
            eprintf("Usage: cmd @@s:from to step\n");
        }
        goto out_finish;
    } break;
    case 'i': // "@@i" - function instructions
    {
        RzListIter *iter;
        RzAnalysisBlock *bb;
        int i;
        RzAnalysisFunction *fcn = rz_analysis_get_function_at(core->analysis, core->offset);
        if (fcn) {
            rz_list_sort(fcn->bbs, bb_cmp);
            rz_list_foreach (fcn->bbs, iter, bb) {
                for (i = 0; i < bb->op_pos_size; i++) {
                    ut64 addr = bb->addr + bb->op_pos[i];
                    rz_core_seek(core, addr, true);
                    rz_core_cmd(core, cmd, 0);
                    if (rz_cons_is_breaked()) {
                        break;
                    }
                }
            }
        }
        goto out_finish;
    } break;
    case 'f': // "@@f"
        if (each[1] == ':') {
            RzAnalysisFunction *fcn;
            RzListIter *iter;
            if (core->analysis) {
                rz_list_foreach (core->analysis->fcns, iter, fcn) {
                    if (each[2] && strstr(fcn->name, each + 2)) {
                        rz_core_seek(core, fcn->addr, true);
                        rz_core_cmd(core, cmd, 0);
                        if (rz_cons_is_breaked()) {
                            break;
                        }
                    }
                }
            }
            goto out_finish;
        } else {
            RzAnalysisFunction *fcn;
            RzListIter *iter;
            if (core->analysis) {
                RzConsGrep grep = core->cons->context->grep;
                rz_list_foreach (core->analysis->fcns, iter, fcn) {
                    char *buf;
                    rz_core_seek(core, fcn->addr, true);
                    rz_cons_push();
                    rz_core_cmd(core, cmd, 0);
                    buf = rz_cons_get_buffer_dup();
                    rz_cons_pop();
                    rz_cons_strcat(buf);
                    free(buf);
                    if (rz_cons_is_breaked()) {
                        break;
                    }
                }
                core->cons->context->grep = grep;
            }
            goto out_finish;
        }
        break;
    case 't': // "@@t"
    {
        RzDebugPid *p;
        int pid = core->dbg->pid;
        if (core->dbg->cur && core->dbg->cur->pids) {
            RzList *list = core->dbg->cur->pids(core->dbg, RZ_MAX(0, pid));
            rz_list_foreach (list, iter, p) {
                rz_cons_printf("# PID %d\n", p->pid);
                rz_debug_select(core->dbg, p->pid, p->pid);
                rz_core_cmd(core, cmd, 0);
                rz_cons_newline();
            }
            rz_list_free(list);
        }
        rz_debug_select(core->dbg, pid, pid);
        goto out_finish;
    } break;
    case 'c': // "@@c:"
        if (each[1] == ':') {
            char *arg = rz_core_cmd_str(core, each + 2);
            if (arg) {
                foreachOffset(core, cmd, arg);
                free(arg);
            }
        }
        break;
    case '=': // "@@="
        foreachOffset(core, cmd, str + 1);
        break;
    case 'd': // "@@d"
        if (each[1] == 'b' && each[2] == 't') {
            ut64 oseek = core->offset;
            RzDebugFrame *frame;
            RzListIter *iter;
            RzList *list;
            list = rz_debug_frames(core->dbg, UT64_MAX);
            i = 0;
            rz_list_foreach (list, iter, frame) {
                switch (each[3]) {
                case 'b':
                    rz_core_seek(core, frame->bp, true);
                    break;
                case 's':
                    rz_core_seek(core, frame->sp, true);
                    break;
                default:
                case 'a':
                    rz_core_seek(core, frame->addr, true);
                    break;
                }
                rz_core_cmd(core, cmd, 0);
                rz_cons_newline();
                i++;
            }
            rz_core_seek(core, oseek, false);
            rz_list_free(list);
        } else {
            eprintf("Invalid for-each statement. Use @@=dbt[abs]\n");
        }
        break;
    case 'k': // "@@k"
        /* foreach list of items */
        {
            char *out = sdb_querys(core->sdb, NULL, 0, str + ((str[1]) ? 2 : 1));
            if (out) {
                each = out;
                do {
                    while (*each == ' ') {
                        each++;
                    }
                    if (!*each) {
                        break;
                    }
                    str = strchr(each, ' ');
                    if (str) {
                        *str = '\0';
                        addr = rz_num_math(core->num, each);
                        *str = ' ';
                    } else {
                        addr = rz_num_math(core->num, each);
                    }
                    // eprintf ("; 0x%08"PFMT64x":\n", addr);
                    each = str + 1;
                    rz_core_seek(core, addr, true);
                    rz_core_cmd(core, cmd, 0);
                    rz_cons_flush();
                } while (str != NULL);
                free(out);
            }
        }
        break;
    case '.': // "@@."
        if (each[1] == '(') {
            char cmd2[1024];
            // XXX what's this 999 ?
            i = 0;
            for (core->rcmd->macro.counter = 0; i < 999; core->rcmd->macro.counter++) {
                if (rz_cons_is_breaked()) {
                    break;
                }
                rz_cmd_macro_call(&core->rcmd->macro, each + 2);
                if (!core->rcmd->macro.brk_value) {
                    break;
                }
                addr = core->rcmd->macro._brk_value;
                sprintf(cmd2, "%s @ 0x%08" PFMT64x "", cmd, addr);
                eprintf("0x%08" PFMT64x " (%s)\n", addr, cmd2);
                rz_core_seek(core, addr, true);
                rz_core_cmd(core, cmd2, 0);
                i++;
            }
        } else {
            char buf[1024];
            char cmd2[1024];
            FILE *fd = rz_sys_fopen(each + 1, "r");
            if (fd) {
                core->rcmd->macro.counter = 0;
                while (!feof(fd)) {
                    buf[0] = '\0';
                    if (!fgets(buf, sizeof(buf), fd)) {
                        break;
                    }
                    addr = rz_num_math(core->num, buf);
                    eprintf("0x%08" PFMT64x ": %s\n", addr, cmd);
                    sprintf(cmd2, "%s @ 0x%08" PFMT64x "", cmd, addr);
                    rz_core_seek(core, addr, true); // XXX
                    rz_core_cmd(core, cmd2, 0);
                    core->rcmd->macro.counter++;
                }
                fclose(fd);
            } else {
                eprintf("cannot open file '%s' to read offsets\n", each + 1);
            }
        }
        break;
    default:
        core->rcmd->macro.counter = 0;
        for (; *each == ' '; each++) {
            ;
        }
        i = 0;
        while (str[i]) {
            j = i;
            for (; str[j] && str[j] == ' '; j++) {
                ; // skip spaces
            }
            for (i = j; str[i] && str[i] != ' '; i++) {
                ; // find EOS
            }
            ch = str[i];
            str[i] = '\0';
            word = strdup(str + j);
            if (!word) {
                break;
            }
            str[i] = ch;
            {
                const RzSpace *flagspace = rz_flag_space_cur(core->flags);
                RzList *match_flag_items = rz_list_newf((RzListFree)rz_flag_item_free);
                if (!match_flag_items) {
                    break;
                }
 
                /* duplicate flags that match word, to be sure
                   the command is going to be executed on flags
                   values at the moment the command is called
                   (without side effects) */
                struct duplicate_flag_t u = {
                    .ret = match_flag_items,
                    .word = word,
                };
                rz_flag_foreach_space(core->flags, flagspace, duplicate_flag, &u);
 
                /* for all flags that match */
                rz_list_foreach (match_flag_items, iter, flag) {
                    if (rz_cons_is_breaked()) {
                        break;
                    }
 
                    char *buf = NULL;
                    rz_core_seek(core, flag->offset, true);
                    rz_cons_push();
                    rz_core_cmd(core, cmd, 0);
                    buf = rz_cons_get_buffer_dup();
                    rz_cons_pop();
                    rz_cons_strcat(buf);
                    free(buf);
                    rz_core_task_yield(&core->tasks);
                }
 
                rz_list_free(match_flag_items);
                core->rcmd->macro.counter++;
                RZ_FREE(word);
            }
        }
    }
    rz_cons_break_pop();
    // XXX: use rz_core_seek here
    core->offset = oseek;
 
    free(word);
    free(ostr);
    return true;
out_finish:
    free(ostr);
    rz_cons_break_pop();
    return false;
}

References rz_cmd_macro_t::_brk_value, addr, rz_analysis_function_t::addr, rz_analysis_bb_t::addr, rz_debug_frame_t::addr, rz_core_t::analysis, bb_cmp(), rz_analysis_function_t::bbs, rz_core_t::blocksize, rz_debug_frame_t::bp, rz_cmd_macro_t::brk_value, cmd, rz_core_t::config, rz_core_t::cons, rz_cons_t::context, count, rz_cmd_macro_t::counter, rz_debug_t::cur, rz_core_t::dbg, duplicate_flag(), eprintf, rz_analysis_t::fcns, fd, benchmark::FILE, rz_core_t::flags, foreachOffset(), free(), from, rz_cons_context_t::grep, help_msg_at_at, i, list(), rz_cmd_t::macro, rz_analysis_function_t::name, NULL, rz_core_t::num, rz_core_t::offset, rz_flag_item_t::offset, rz_analysis_bb_t::op_pos, rz_analysis_bb_t::op_pos_size, out, p, PFMT64x, rz_debug_t::pid, pid, rz_debug_plugin_t::pids, rz_core_t::rcmd, duplicate_flag_t::ret, rz_analysis_get_function_at(), rz_cmd_macro_call(), rz_config_get(), rz_config_set(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_flush(), rz_cons_get_buffer_dup(), rz_cons_is_breaked(), rz_cons_newline(), rz_cons_pop(), rz_cons_printf(), rz_cons_push(), rz_cons_strcat(), rz_core_block_size(), rz_core_cmd(), rz_core_cmd0(), rz_core_cmd_help(), rz_core_cmd_str(), rz_core_seek(), rz_core_task_yield(), rz_debug_frames(), rz_debug_select(), rz_flag_foreach_space(), rz_flag_item_free(), RZ_FREE, rz_list_free(), rz_list_newf(), rz_list_sort(), RZ_MAX, rz_num_math(), rz_str_split(), rz_str_word_get0(), rz_sys_fopen(), rz_core_t::sdb, sdb_querys(), rz_analysis_bb_t::size, rz_debug_frame_t::sp, sprintf, step(), cmd_descs_generate::str, strdup(), rz_core_t::tasks, to, ut64(), UT64_MAX, and duplicate_flag_t::word.

Referenced by rz_core_cmd_subst_i().

rz_core_cmd_foreach3()

RZ_API int rz_core_cmd_foreach3	(	RzCore *	core,
		const char *	cmd,
		char *	each
	)

Definition at line 2449 of file cmd.c.

                                                                           { // "@@@"
    RzDebug *dbg = core->dbg;
    RzList *list;
    const RzList *head;
    RzListIter *iter;
    int i;
    const char *filter = NULL;
 
    if (each[0] && each[1] == ':') {
        filter = each + 2;
    }
 
    switch (each[0]) {
    case '=':
        foreach_pairs(core, cmd, each + 1);
        break;
    case '?':
        rz_core_cmd_help(core, help_msg_at_at_at);
        break;
    case 'c':
        if (filter) {
            char *arg = rz_core_cmd_str(core, filter);
            foreach_pairs(core, cmd, arg);
            free(arg);
        } else {
            eprintf("Usage: @@@c:command   # same as @@@=`command`\n");
        }
        break;
    case 'C': {
        char *glob = filter ? rz_str_trim_dup(filter) : NULL;
        RzIntervalTreeIter it;
        RzAnalysisMetaItem *meta;
        rz_interval_tree_foreach (&core->analysis->meta, it, meta) {
            if (meta->type != RZ_META_TYPE_COMMENT) {
                continue;
            }
            if (!glob || (meta->str && rz_str_glob(meta->str, glob))) {
                rz_core_seek(core, rz_interval_tree_iter_get(&it)->start, true);
                rz_core_cmd0(core, cmd);
            }
        }
        free(glob);
        break;
    }
    case 'm': {
        int fd = rz_io_fd_get_current(core->io);
        // only iterate maps of current fd
        RzList *maps = rz_io_map_get_for_fd(core->io, fd);
        RzIOMap *map;
        if (maps) {
            RzListIter *iter;
            rz_list_foreach (maps, iter, map) {
                rz_core_seek(core, map->itv.addr, true);
                rz_core_block_size(core, map->itv.size);
                rz_core_cmd0(core, cmd);
            }
            rz_list_free(maps);
        }
    } break;
    case 'M':
        if (dbg && dbg->cur && dbg->maps) {
            RzDebugMap *map;
            rz_list_foreach (dbg->maps, iter, map) {
                rz_core_seek(core, map->addr, true);
                // rz_core_block_size (core, map->size);
                rz_core_cmd0(core, cmd);
            }
        }
        break;
    case 't':
        // iterate over all threads
        if (dbg && dbg->cur && dbg->cur->threads) {
            int origpid = dbg->pid;
            RzDebugPid *p;
            list = dbg->cur->threads(dbg, dbg->pid);
            if (!list) {
                return false;
            }
            rz_list_foreach (list, iter, p) {
                rz_core_cmdf(core, "dp %d", p->pid);
                rz_cons_printf("PID %d\n", p->pid);
                rz_core_cmd0(core, cmd);
            }
            rz_core_cmdf(core, "dp %d", origpid);
            rz_list_free(list);
        }
        break;
    case 'r': // @@@r
    {
        RzReg *reg = rz_core_reg_default(core);
        ut64 offorig = core->offset;
        for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
            RzRegItem *item;
            ut64 value;
            head = rz_reg_get_list(reg, i);
            if (!head) {
                continue;
            }
            RzList *list = rz_list_newf(free);
            rz_list_foreach (head, iter, item) {
                if (item->size != core->analysis->bits) {
                    continue;
                }
                if (item->type != i) {
                    continue;
                }
                rz_list_append(list, strdup(item->name));
            }
            const char *item_name;
            rz_list_foreach (list, iter, item_name) {
                value = rz_reg_getv(reg, item_name);
                rz_core_seek(core, value, true);
                rz_cons_printf("%s: ", item_name);
                rz_core_cmd0(core, cmd);
            }
            rz_list_free(list);
        }
        rz_core_seek(core, offorig, true);
    } break;
    case 'i': // @@@i
    {
        RzBinImport *imp;
        ut64 offorig = core->offset;
        list = rz_bin_get_imports(core->bin);
        RzList *lost = rz_list_newf(free);
        rz_list_foreach (list, iter, imp) {
            char *impflag = rz_str_newf("sym.imp.%s", imp->name);
            ut64 addr = rz_num_math(core->num, impflag);
            ut64 *n = RZ_NEW(ut64);
            *n = addr;
            rz_list_append(lost, n);
            free(impflag);
        }
        ut64 *naddr;
        rz_list_foreach (lost, iter, naddr) {
            ut64 addr = *naddr;
            if (addr && addr != UT64_MAX) {
                rz_core_seek(core, addr, true);
                rz_core_cmd0(core, cmd);
            }
        }
        rz_core_seek(core, offorig, true);
        rz_list_free(lost);
    } break;
    case 'S': // "@@@S"
    {
        RzBinObject *obj = rz_bin_cur_object(core->bin);
        if (obj) {
            ut64 offorig = core->offset;
            ut64 bszorig = core->blocksize;
            RzBinSection *sec;
            RzListIter *iter;
            rz_list_foreach (obj->sections, iter, sec) {
                rz_core_seek(core, sec->vaddr, true);
                rz_core_block_size(core, sec->vsize);
                rz_core_cmd0(core, cmd);
            }
            rz_core_block_size(core, bszorig);
            rz_core_seek(core, offorig, true);
        }
    }
#if ATTIC
        if (each[1] == 'S') {
            RzListIter *it;
            RzBinSection *sec;
            RzBinObject *obj = rz_bin_cur_object(core->bin);
            int cbsz = core->blocksize;
            rz_list_foreach (obj->sections, it, sec) {
                ut64 addr = sec->vaddr;
                ut64 size = sec->vsize;
                // TODO:
                // if (RZ_BIN_SCN_EXECUTABLE & sec->perm) {
                //  continue;
                //}
                rz_core_seek_size(core, addr, size);
                rz_core_cmd(core, cmd, 0);
            }
            rz_core_block_size(core, cbsz);
        }
#endif
        break;
    case 's':
        if (each[1] == 't') { // strings
            list = rz_bin_get_strings(core->bin);
            if (list) {
                ut64 offorig = core->offset;
                ut64 obs = core->blocksize;
                RzBinString *s;
                RzList *lost = rz_list_newf(free);
                rz_list_foreach (list, iter, s) {
                    RzBinString *bs = rz_mem_dup(s, sizeof(RzBinString));
                    rz_list_append(lost, bs);
                }
                rz_list_foreach (lost, iter, s) {
                    rz_core_block_size(core, s->size);
                    rz_core_seek(core, s->vaddr, true);
                    rz_core_cmd0(core, cmd);
                }
                rz_core_block_size(core, obs);
                rz_core_seek(core, offorig, true);
                rz_list_free(lost);
            }
        } else {
            // symbols
            RzBinSymbol *sym;
            ut64 offorig = core->offset;
            ut64 obs = core->blocksize;
            list = rz_bin_get_symbols(core->bin);
            rz_cons_break_push(NULL, NULL);
            RzList *lost = rz_list_newf(free);
            rz_list_foreach (list, iter, sym) {
                RzBinSymbol *bs = rz_mem_dup(sym, sizeof(RzBinSymbol));
                rz_list_append(lost, bs);
            }
            rz_list_foreach (lost, iter, sym) {
                if (rz_cons_is_breaked()) {
                    break;
                }
                rz_core_block_size(core, sym->size);
                rz_core_seek(core, sym->vaddr, true);
                rz_core_cmd0(core, cmd);
            }
            rz_cons_break_pop();
            rz_list_free(lost);
            rz_core_block_size(core, obs);
            rz_core_seek(core, offorig, true);
        }
        break;
    case 'f': // flags
    {
        // TODO: honor ^C
        char *glob = filter ? rz_str_trim_dup(filter) : NULL;
        ut64 off = core->offset;
        ut64 obs = core->blocksize;
        RzList *flags = rz_list_newf(free);
        rz_flag_foreach_glob(core->flags, glob, copy_into_flagitem_list, flags);
        RzListIter *iter;
        RzFlagItem *f;
        rz_list_foreach (flags, iter, f) {
            rz_core_block_size(core, f->size);
            rz_core_seek(core, f->offset, true);
            rz_core_cmd0(core, cmd);
        }
        rz_core_seek(core, off, false);
        rz_core_block_size(core, obs);
        free(glob);
    } break;
    case 'F': // functions
    {
        ut64 obs = core->blocksize;
        ut64 offorig = core->offset;
        RzAnalysisFunction *fcn;
        list = core->analysis->fcns;
        rz_cons_break_push(NULL, NULL);
        rz_list_foreach (list, iter, fcn) {
            if (rz_cons_is_breaked()) {
                break;
            }
            if (!filter || rz_str_glob(fcn->name, filter)) {
                rz_core_seek(core, fcn->addr, true);
                rz_core_block_size(core, rz_analysis_function_linear_size(fcn));
                rz_core_cmd0(core, cmd);
            }
        }
        rz_cons_break_pop();
        rz_core_block_size(core, obs);
        rz_core_seek(core, offorig, true);
    } break;
    case 'b': {
        RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, 0);
        ut64 offorig = core->offset;
        ut64 obs = core->blocksize;
        if (fcn) {
            RzListIter *iter;
            RzAnalysisBlock *bb;
            rz_list_foreach (fcn->bbs, iter, bb) {
                rz_core_seek(core, bb->addr, true);
                rz_core_block_size(core, bb->size);
                rz_core_cmd0(core, cmd);
            }
            rz_core_block_size(core, obs);
            rz_core_seek(core, offorig, true);
        }
    } break;
    }
    return 0;
}

References addr, rz_analysis_function_t::addr, rz_analysis_bb_t::addr, rz_core_t::analysis, rz_analysis_function_t::bbs, rz_core_t::bin, rz_analysis_t::bits, rz_core_t::blocksize, cmd, copy_into_flagitem_list(), rz_debug_t::cur, dbg, rz_core_t::dbg, eprintf, f, rz_analysis_t::fcns, fd, rz_core_t::flags, flags, foreach_pairs(), free(), test-lz4-versions::head, help_msg_at_at_at, i, rz_core_t::io, list(), map(), maps(), rz_debug_t::maps, rz_analysis_t::meta, n, rz_analysis_function_t::name, rz_bin_import_t::name, rz_reg_item_t::name, NULL, rz_core_t::num, obs, off, rz_core_t::offset, p, rz_debug_t::pid, reg, rz_analysis_function_linear_size(), rz_analysis_get_fcn_in(), rz_bin_cur_object(), rz_bin_get_imports(), rz_bin_get_strings(), rz_bin_get_symbols(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_cons_printf(), rz_core_block_size(), rz_core_cmd(), rz_core_cmd0(), rz_core_cmd_help(), rz_core_cmd_str(), rz_core_cmdf(), rz_core_reg_default(), rz_core_seek(), rz_flag_foreach_glob(), rz_interval_tree_foreach, rz_interval_tree_iter_get(), rz_io_fd_get_current(), rz_io_map_get_for_fd(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_mem_dup(), RZ_META_TYPE_COMMENT, RZ_NEW, rz_num_math(), rz_reg_get_list(), rz_reg_getv(), RZ_REG_TYPE_LAST, rz_str_glob(), rz_str_newf(), rz_str_trim_dup(), s, rz_bin_object_t::sections, rz_analysis_bb_t::size, rz_bin_symbol_t::size, rz_reg_item_t::size, start, rz_analysis_meta_item_t::str, strdup(), rz_debug_plugin_t::threads, rz_analysis_meta_item_t::type, rz_reg_item_t::type, ut64(), UT64_MAX, rz_bin_section_t::vaddr, rz_bin_symbol_t::vaddr, value, and rz_bin_section_t::vsize.

Referenced by rz_core_cmd_subst_i().

rz_core_cmd_help()

RZ_API void rz_core_cmd_help	(	const RzCore *	core,
		const char *	help[]
	)

Definition at line 163 of file cmd.c.

                                                                     {
    rz_cons_cmd_help(help, core->print->flags & RZ_PRINT_FLAGS_COLOR);
}

References rz_print_t::flags, cmd_descs_generate::help, rz_core_t::print, rz_cons_cmd_help(), and RZ_PRINT_FLAGS_COLOR.

Referenced by __printPattern(), cmd_agraph_edge(), cmd_agraph_node(), cmd_analysis_esil(), cmd_analysis_graph(), cmd_dbg_map_jemalloc(), cmd_dcu(), cmd_debug_pid(), cmd_help_exclamation(), cmd_help_percent(), cmd_print_bars(), cmd_print_blocks(), cmd_print_format(), cmd_print_fromage(), cmd_print_gadget(), cmd_print_op(), cmd_print_pv(), do_analysis_search(), do_esil_search(), find_autocomplete(), helpCmdTasks(), print_format_help_help_help_help(), recursive_help_go(), rz_cmd_alias(), rz_cmd_analysis(), rz_cmd_debug(), rz_cmd_debug_continue_syscall(), rz_cmd_debug_continue_until(), rz_cmd_debug_dmi(), rz_cmd_help(), rz_cmd_kuery(), rz_cmd_macro(), rz_cmd_panels(), rz_cmd_print(), rz_cmd_remote(), rz_cmd_search(), rz_core_cmd_foreach(), rz_core_cmd_foreach3(), rz_core_cmd_subst_i(), rz_core_debug_esil(), rz_core_debug_kill(), rz_core_hack_help(), rz_equal_g_handler_old(), rz_equal_h_handler_old(), and rz_equal_H_handler_old().

rz_core_cmd_init()

RZ_API void rz_core_cmd_init

(

RzCore *

core

)

Definition at line 5562 of file cmd.c.

                                           {
    struct {
        const char *cmd;
        const char *description;
        RzCmdCb cb;
    } cmds[] = {
        { "$", "alias", rz_cmd_alias },
        { "(", "macro", rz_cmd_macro },
        { "/", "search kw, pattern aes", rz_cmd_search },
        { "?", "help message", rz_cmd_help },
        { "a", "analysis", rz_cmd_analysis },
        { "d", "debugger operations", rz_cmd_debug },
        { "k", "perform sdb query", rz_cmd_kuery },
        { "p", "print current block", rz_cmd_print },
        { "V", "enter visual mode", rz_cmd_visual },
        { "v", "enter visual mode", rz_cmd_panels },
        { "x", "alias for px", rz_cmd_hexdump },
    };
 
    core->rcmd = rz_core_cmd_new(!!core->cons);
    core->rcmd->macro.user = core;
    core->rcmd->macro.num = core->num;
    core->rcmd->macro.cmd = core_cmd0_wrapper;
    core->rcmd->nullcallback = rz_core_cmd_nullcallback;
    core->rcmd->macro.cb_printf = (PrintfCallback)rz_cons_printf;
    rz_cmd_set_data(core->rcmd, core);
    core->cmd_descriptors = rz_list_newf(free);
 
    size_t i;
    for (i = 0; i < RZ_ARRAY_SIZE(cmds); i++) {
        if (cmds[i].cb) {
            rz_cmd_add(core->rcmd, cmds[i].cmd, cmds[i].cb);
        }
    }
    DEPRECATED_DEFINE_CMD_DESCRIPTOR_SPECIAL(core, $, dollar);
 
    DEPRECATED_DEFINE_CMD_DESCRIPTOR(core, k);
    cmd_descriptor_init(core);
    rzshell_cmddescs_init(core);
}

References cb, rz_cmd_macro_t::cb_printf, rz_cmd_macro_t::cmd, cmd, cmd_descriptor_init(), rz_core_t::cmd_descriptors, rz_core_t::cons, core_cmd0_wrapper(), DEPRECATED_DEFINE_CMD_DESCRIPTOR, DEPRECATED_DEFINE_CMD_DESCRIPTOR_SPECIAL, setup::description, free(), i, k, rz_cmd_t::macro, rz_cmd_t::nullcallback, rz_cmd_macro_t::num, rz_core_t::num, rz_core_t::rcmd, RZ_ARRAY_SIZE, rz_cmd_add(), rz_cmd_alias(), rz_cmd_analysis(), rz_cmd_debug(), rz_cmd_help(), rz_cmd_hexdump(), rz_cmd_kuery(), rz_cmd_macro(), rz_cmd_panels(), rz_cmd_print(), rz_cmd_search(), rz_cmd_set_data(), rz_cmd_visual(), rz_cons_printf(), rz_core_cmd_new(), rz_core_cmd_nullcallback(), rz_list_newf(), rzshell_cmddescs_init(), and rz_cmd_macro_t::user.

Referenced by rz_core_init().

rz_core_cmd_lastcmd_repeat()

RZ_IPI bool rz_core_cmd_lastcmd_repeat	(	RzCore *	core,
		bool	next
	)

Definition at line 216 of file cmd.c.

                                                                {
    int res = -1;
    // Fix for backtickbug px`~`
    if (!core->lastcmd || core->cons->context->cmd_depth < 1) {
        return false;
    }
    switch (*core->lastcmd) {
    case '.':
        if (core->lastcmd[1] == '(') { // macro call
            res = rz_core_cmd0(core, core->lastcmd);
        }
        break;
    case 'd': // debug
        res = rz_core_cmd0(core, core->lastcmd);
        switch (core->lastcmd[1]) {
        case 's':
        case 'c':
            rz_core_seek_to_register(core, "PC", false);
            rz_core_cmd0(core, "pd 1");
        }
        break;
    case 'p': // print
    case 'x':
    case '$':
        if (!strncmp(core->lastcmd, "pd", 2)) {
            if (core->lastcmd[2] == ' ') {
                ut64 addr = rz_num_math(core->num, core->lastcmd + 3);
                rz_core_seek_opcode(core, addr, false);
            } else {
                rz_core_cmd0(core, "so `pi~?`");
            }
        } else {
            if (next) {
                rz_core_seek(core, core->offset + core->blocksize, true);
            } else {
                if (core->blocksize > core->offset) {
                    rz_core_seek(core, 0, true);
                } else {
                    rz_core_seek(core, core->offset - core->blocksize, true);
                }
            }
        }
        res = rz_core_cmd0(core, core->lastcmd);
        break;
    }
    core->is_lastcmd = true;
    return res != -1;
}

References addr, rz_core_t::blocksize, rz_cons_context_t::cmd_depth, rz_core_t::cons, rz_cons_t::context, rz_core_t::is_lastcmd, rz_core_t::lastcmd, rz_core_t::num, rz_core_t::offset, rz_core_cmd0(), rz_core_seek(), rz_core_seek_opcode(), rz_core_seek_to_register(), rz_num_math(), and ut64().

Referenced by DEFINE_HANDLE_TS_FCN(), rz_core_cmd_nullcallback(), rz_core_cmd_subst(), rz_interpret_handler(), and rz_repeat_forward_handler().

rz_core_cmd_lines()

RZ_API int rz_core_cmd_lines	(	RzCore *	core,
		const char *	lines
	)

Definition at line 5336 of file cmd.c.

                                                              {
    RzCmdStatus status = core_cmd_tsrzcmd(core, lines, true, false);
    return status == RZ_CMD_STATUS_OK;
}

References tsr2cmd_state::core, core_cmd_tsrzcmd(), lines(), RZ_CMD_STATUS_OK, and status.

Referenced by run_commands(), rz_core_cmd_file(), and rz_core_run_script().

rz_core_cmd_lines_rzshell()

RZ_API RzCmdStatus rz_core_cmd_lines_rzshell	(	RzCore *	core,
		const char *	lines
	)

Definition at line 5332 of file cmd.c.

                                                                              {
    return core_cmd_tsrzcmd(core, lines, true, false);
}

References tsr2cmd_state::core, core_cmd_tsrzcmd(), and lines().

rz_core_cmd_new()

RZ_API RzCmd* rz_core_cmd_new

(

bool

has_cons

)

Create an instance of RzCmd for the Rizin language.

Definition at line 5220 of file cmd.c.

                                             {
    RzCmd *res = rz_cmd_new(has_cons);
    if (!res) {
        return NULL;
    }
 
    TSLanguage *lang = tree_sitter_rzcmd();
    res->language = lang;
    res->ts_symbols_ht = ht_up_new0();
    struct ts_data_symbol_map *entry = map_ts_stmt_handlers;
    while (entry->name) {
        TSSymbol symbol = ts_language_symbol_for_name(lang, entry->name, strlen(entry->name), true);
        ht_up_insert(res->ts_symbols_ht, symbol, entry->data);
        entry++;
    }
 
    entry = map_ts_symbols;
    while (entry->name) {
        TSSymbol *sym_ptr = entry->data;
        *sym_ptr = ts_language_symbol_for_name(lang, entry->name, strlen(entry->name), true);
        entry++;
    }
    return res;
}

References rz_cmd_t::language, map_ts_stmt_handlers, map_ts_symbols, entry::name, NULL, rz_cmd_new(), tree_sitter_rzcmd(), ts_language_symbol_for_name(), and rz_cmd_t::ts_symbols_ht.

Referenced by rz_core_cmd_init().

rz_core_cmd_nullcallback()

static int rz_core_cmd_nullcallback ( void *  data )

static

Definition at line 265 of file cmd.c.

                                                {
    RzCore *core = (RzCore *)data;
    if (core->cons->context->breaked) {
        core->cons->context->breaked = false;
        return 0;
    }
    if (!core->cmdrepeat) {
        return 0;
    }
    rz_core_cmd_lastcmd_repeat(core, true);
    return 1;
}

References rz_cons_context_t::breaked, rz_core_t::cmdrepeat, rz_core_t::cons, rz_cons_t::context, and rz_core_cmd_lastcmd_repeat().

Referenced by rz_core_cmd_init(), and rz_core_cmd_subst().

rz_core_cmd_pipe_old()

RZ_API int rz_core_cmd_pipe_old	(	RzCore *	core,
		char *	rizin_cmd,
		char *	shell_cmd
	)

Definition at line 1058 of file cmd.c.

                                                                                {
#if __UNIX__
    int stdout_fd, fds[2];
    int child;
#endif
    int si, olen, ret = -1, pipecolor = -1;
    char *str, *out = NULL;
 
    si = rz_cons_is_interactive();
    rz_config_set_i(core->config, "scr.interactive", 0);
    if (!rz_config_get_i(core->config, "scr.color.pipe")) {
        pipecolor = rz_config_get_i(core->config, "scr.color");
        rz_config_set_i(core->config, "scr.color", COLOR_MODE_DISABLED);
    }
    if (*shell_cmd == '!') {
        rz_cons_grep_parsecmd(shell_cmd, "\"");
        olen = 0;
        out = NULL;
        // TODO: implement foo
        str = rz_core_cmd_str(core, rizin_cmd);
        rz_sys_cmd_str_full(shell_cmd + 1, str, &out, &olen, NULL);
        free(str);
        rz_cons_memcat(out, olen);
        free(out);
        ret = 0;
    }
#if __UNIX__
    rz_str_trim_head(rizin_cmd);
    rz_str_trim_head(shell_cmd);
 
    rz_sys_signal(SIGPIPE, SIG_IGN);
    stdout_fd = dup(1);
    if (stdout_fd != -1) {
        if (rz_sys_pipe(fds, true) == 0) {
            child = rz_sys_fork();
            if (child == -1) {
                eprintf("Cannot fork\n");
                close(stdout_fd);
            } else if (child) {
                dup2(fds[1], 1);
                rz_sys_pipe_close(fds[1]);
                rz_sys_pipe_close(fds[0]);
                rz_core_cmd(core, rizin_cmd, 0);
                rz_cons_flush();
                close(1);
                wait(&ret);
                dup2(stdout_fd, 1);
                close(stdout_fd);
            } else {
                close(fds[1]);
                dup2(fds[0], 0);
                // dup2 (1, 2); // stderr goes to stdout
                rz_sys_execl("/bin/sh", "sh", "-c", shell_cmd, (const char *)NULL);
                close(stdout_fd);
            }
        } else {
            eprintf("rz_core_cmd_pipe: Could not pipe\n");
        }
    }
#elif __WINDOWS__
    rz_w32_cmd_pipe(core, rizin_cmd, shell_cmd);
#else
#ifdef _MSC_VER
#pragma message("rz_core_cmd_pipe UNIMPLEMENTED FOR THIS PLATFORM")
#else
#warning rz_core_cmd_pipe UNIMPLEMENTED FOR THIS PLATFORM
#endif
    eprintf("rz_core_cmd_pipe: unimplemented for this platform\n");
#endif
    if (pipecolor != -1) {
        rz_config_set_i(core->config, "scr.color", pipecolor);
    }
    rz_config_set_i(core->config, "scr.interactive", si);
    return ret;
}

References close, COLOR_MODE_DISABLED, rz_core_t::config, dup, dup2, eprintf, free(), NULL, out, duplicate_flag_t::ret, rz_config_get_i(), rz_config_set_i(), rz_cons_flush(), rz_cons_grep_parsecmd(), rz_cons_is_interactive(), rz_cons_memcat(), rz_core_cmd(), rz_core_cmd_str(), rz_str_trim_head(), rz_sys_cmd_str_full(), rz_sys_execl(), rz_sys_fork(), rz_sys_pipe(), rz_sys_pipe_close(), rz_sys_signal(), si, and cmd_descs_generate::str.

Referenced by rz_core_cmd_subst_i().

rz_core_cmd_raw()

RZ_API ut8* rz_core_cmd_raw	(	RzCore *	core,
		const char *	cmd,
		int *	length
	)

Executes a rizin command and returns the raw stdout and its length.

Definition at line 5521 of file cmd.c.

                                                                        {
    rz_return_val_if_fail(core && cmd && length, NULL);
    return core_cmd_raw(core, cmd, length);
}

References cmd, tsr2cmd_state::core, core_cmd_raw(), length, NULL, and rz_return_val_if_fail.

rz_core_cmd_rzshell()

RZ_API RzCmdStatus rz_core_cmd_rzshell	(	RzCore *	core,
		const char *	cstr,
		int	log
	)

Definition at line 5324 of file cmd.c.

                                                                                {
    return core_cmd_tsrzcmd(core, cstr, false, log);
}

References tsr2cmd_state::core, and core_cmd_tsrzcmd().

Referenced by rz_core_bin_pdb_load(), and rz_core_cmd0_rzshell().

rz_core_cmd_str()

RZ_API char* rz_core_cmd_str	(	RzCore *	core,
		const char *	cmd
	)

Executes a rizin command and returns the stdout as a string.

Definition at line 5513 of file cmd.c.

                                                            {
    rz_return_val_if_fail(core && cmd, NULL);
    return (char *)core_cmd_raw(core, cmd, NULL);
}

References cmd, tsr2cmd_state::core, core_cmd_raw(), NULL, and rz_return_val_if_fail.

Referenced by __handle_cmd_str_cache(), __init_menu_color_settings_layout(), __load_cmdf(), __print_stack_cb(), agraph_print(), cmd_pCd(), cmd_pCD(), cmd_pCx(), cmd_print_pv(), cmd_task_runner(), core_analysis_graph_label(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), disasm_strings(), do_handle_substitution_cmd(), execute_command(), readline_callback(), rz_cmd_debug(), rz_core_bind(), rz_core_cmd_foreach(), rz_core_cmd_foreach3(), rz_core_cmd_pipe_old(), rz_core_cmd_str_pipe(), rz_core_cmd_strf(), rz_core_cmd_subst_i(), rz_core_disassemble_bytes(), rz_core_disassemble_instr(), rz_core_gadget_print(), rz_core_init(), rz_core_rtr_cmds(), rz_core_rtr_pushout(), rz_core_serve(), rz_core_visual_analysis_refresh(), rz_core_visual_analysis_refresh_column(), rz_core_visual_colors(), rz_core_visual_esil(), rz_interpret_handler(), set_prompt(), and visual_refresh().

rz_core_cmd_str_pipe()

RZ_API char* rz_core_cmd_str_pipe	(	RzCore *	core,
		const char *	cmd
	)

Definition at line 5438 of file cmd.c.

                                                                 {
    char *tmp = NULL;
    char *p = (*cmd != '"') ? strchr(cmd, '|') : NULL;
    if (!p && *cmd != '!' && *cmd != '.') {
        return rz_core_cmd_str(core, cmd);
    }
    rz_cons_reset();
    if (rz_file_mkstemp("cmd", &tmp) != -1) {
        int pipefd = rz_cons_pipe_open(tmp, 1, 0);
        if (pipefd == -1) {
            rz_file_rm(tmp);
            free(tmp);
            return rz_core_cmd_str(core, cmd);
        }
        char *_cmd = strdup(cmd);
        rz_core_cmd(core, _cmd, 0);
        rz_cons_flush();
        rz_cons_pipe_close(pipefd);
        if (rz_file_exists(tmp)) {
            char *s = rz_file_slurp(tmp, NULL);
            rz_file_rm(tmp);
            free(tmp);
            free(_cmd);
            return s ? s : strdup("");
        }
        eprintf("slurp %s fails\n", tmp);
        rz_file_rm(tmp);
        free(tmp);
        free(_cmd);
        return rz_core_cmd_str(core, cmd);
    }
    return NULL;
}

References cmd, tsr2cmd_state::core, eprintf, free(), NULL, p, rz_cons_flush(), rz_cons_pipe_close(), rz_cons_pipe_open(), rz_cons_reset(), rz_core_cmd(), rz_core_cmd_str(), rz_file_exists(), rz_file_mkstemp(), rz_file_rm(), rz_file_slurp(), s, strdup(), and autogen_x86imm::tmp.

Referenced by do_handle_substitution_cmd(), rz_core_cmd_subst_i(), rz_core_rtr_http_run(), and rz_interpret_output_handler().

rz_core_cmd_strf()

RZ_API char* rz_core_cmd_strf	(	RzCore *	core,
		const char *	fmt,
			...
	)

Definition at line 5472 of file cmd.c.

                                                                  {
    char string[4096];
    char *ret;
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(string, sizeof(string), fmt, ap);
    ret = rz_core_cmd_str(core, string);
    va_end(ap);
    return ret;
}

References tsr2cmd_state::core, rz_core_cmd_str(), and vsnprintf.

Referenced by __core_visual_view_graph_update(), core_analysis_graph_construct_nodes(), disasm_strings(), get_body(), graph_construct_nodes(), print_fcn_arg(), rz_analysis_function_xrefs_handler(), rz_analysis_xrefs_to_graph_cmd_handler(), rz_cmd_print(), rz_core_analysis_var_display(), rz_core_bin_fields_print(), rz_core_bind(), rz_core_print_bb_custom(), rz_core_run_script(), rz_core_visual_debugtraces(), rz_core_visual_view_rop(), rz_core_visual_xrefs(), and rz_resolve_jemalloc().

rz_core_cmd_subst()

static int rz_core_cmd_subst ( RzCore *  core, char *  cmd  )

static

Definition at line 1197 of file cmd.c.

                                                      {
    ut64 rep = strtoull(cmd, NULL, 10);
    int ret = 0, orep;
    char *colon = NULL, *icmd = NULL;
    bool tmpseek = false;
    bool original_tmpseek = core->tmpseek;
 
    if (rz_str_startswith(cmd, "GET /cmd/")) {
        memmove(cmd, cmd + 9, strlen(cmd + 9) + 1);
        char *http = strstr(cmd, "HTTP");
        if (http) {
            *http = 0;
            http--;
            if (*http == ' ') {
                *http = 0;
            }
        }
        rz_cons_printf("HTTP/1.0 %d %s\r\n%s"
                   "Connection: close\r\nContent-Length: %d\r\n\r\n",
            200, "OK", "", -1);
        return rz_core_cmd0(core, cmd);
    }
 
    /* must store a local orig_offset because there can be
     * nested call of this function */
    ut64 orig_offset = core->offset;
    icmd = strdup(cmd);
    if (!icmd) {
        goto beach;
    }
 
    if (core->max_cmd_depth - core->cons->context->cmd_depth == 1) {
        core->prompt_offset = core->offset;
    }
    cmd = (char *)rz_str_trim_head_ro(icmd);
    rz_str_trim_tail(cmd);
    // lines starting with # are ignored (never reach cmd_hash()), except #! and #?
    if (!*cmd) {
        if (core->cmdrepeat > 0) {
            rz_core_cmd_lastcmd_repeat(core, true);
            ret = rz_core_cmd_nullcallback(core);
        }
        goto beach;
    }
    if (!icmd || (cmd[0] == '#' && cmd[1] != '!' && cmd[1] != '?')) {
        goto beach;
    }
    if (*icmd && !strchr(icmd, '"')) {
        char *hash;
        for (hash = icmd + 1; *hash; hash++) {
            if (*hash == '\\') {
                hash++;
                if (*hash == '#') {
                    continue;
                }
            }
            if (*hash == '#') {
                break;
            }
        }
        if (hash && *hash) {
            *hash = 0;
            rz_str_trim_tail(icmd);
        }
    }
    if (*cmd != '"') {
        if (!strchr(cmd, '\'')) { // allow | awk '{foo;bar}' // ignore ; if there's a single quote
            if (is_macro_command(cmd)) {
                colon = find_ch_after_macro(cmd, ';');
            } else {
                colon = strchr(cmd, ';');
            }
            if (colon) {
                *colon = 0;
            }
        }
    } else {
        colon = NULL;
    }
    if (rep > 0) {
        while (IS_DIGIT(*cmd)) {
            cmd++;
        }
        // do not repeat null cmd
        if (!*cmd) {
            goto beach;
        }
    }
    if (rep < 1) {
        rep = 1;
    }
    // XXX if output is a pipe then we don't want to be interactive
    if (rep > INTERACTIVE_MAX_REP) {
        if (rz_cons_is_interactive()) {
            if (!rz_cons_yesno('n', "Are you sure to repeat this %" PFMT64d " times? (y/N)", rep)) {
                goto beach;
            }
        }
    }
    // TODO: store in core->cmdtimes to speedup ?
    const char *cmdrep = core->cmdtimes ? core->cmdtimes : "";
    orep = rep;
 
    rz_cons_break_push(NULL, NULL);
 
    int ocur_enabled = core->print && core->print->cur_enabled;
    while (rep-- && *cmd) {
        if (core->print) {
            core->print->cur_enabled = false;
            if (ocur_enabled && core->seltab >= 0) {
                if (core->seltab == core->curtab) {
                    core->print->cur_enabled = true;
                }
            }
        }
        if (rz_cons_is_breaked()) {
            break;
        }
        char *cr = strdup(cmdrep);
        core->break_loop = false;
        ret = rz_core_cmd_subst_i(core, cmd, colon, (rep == orep - 1) ? &tmpseek : NULL);
        if (ret && *cmd == 'q') {
            free(cr);
            goto beach;
        }
        if (core->break_loop) {
            free(cr);
            break;
        }
        if (cr && *cr && orep > 1) {
            // XXX: do not flush here, we need rz_cons_push () and rz_cons_pop()
            rz_cons_flush();
            // XXX: we must import register flags in C
            rz_core_reg_update_flags(core);
            (void)rz_core_cmd0(core, cr);
        }
        free(cr);
    }
 
    rz_cons_break_pop();
 
    if (tmpseek) {
        rz_core_seek(core, orig_offset, true);
        core->tmpseek = original_tmpseek;
    }
    if (core->print) {
        core->print->cur_enabled = ocur_enabled;
    }
    if (colon && colon[1]) {
        for (++colon; *colon == ';'; colon++) {
            ;
        }
        rz_core_cmd_subst(core, colon);
    } else {
        if (!*icmd) {
            rz_core_cmd_nullcallback(core);
        }
    }
beach:
    free(icmd);
    return ret;
}

References rz_core_t::break_loop, cmd, rz_cons_context_t::cmd_depth, rz_core_t::cmdrepeat, rz_core_t::cmdtimes, rz_core_t::cons, rz_cons_t::context, rz_print_t::cur_enabled, rz_core_t::curtab, find_ch_after_macro(), free(), INTERACTIVE_MAX_REP, IS_DIGIT, is_macro_command(), rz_core_t::max_cmd_depth, NULL, rz_core_t::offset, PFMT64d, rz_core_t::print, rz_core_t::prompt_offset, duplicate_flag_t::ret, rz_cons_break_pop(), rz_cons_break_push(), rz_cons_flush(), rz_cons_is_breaked(), rz_cons_is_interactive(), rz_cons_printf(), rz_cons_yesno(), rz_core_cmd0(), rz_core_cmd_lastcmd_repeat(), rz_core_cmd_nullcallback(), rz_core_cmd_subst_i(), rz_core_reg_update_flags(), rz_core_seek(), rz_str_startswith(), rz_str_trim_head_ro(), rz_str_trim_tail(), rz_core_t::seltab, strdup(), rz_core_t::tmpseek, and ut64().

Referenced by run_cmd_depth(), and rz_core_cmd_subst_i().

rz_core_cmd_subst_i()

static int rz_core_cmd_subst_i ( RzCore *  core, char *  cmd, char *  colon, bool *  tmpseek  )

static

Definition at line 1404 of file cmd.c.

                                                                                    {
    RzList *tmpenvs = rz_list_newf(tmpenvs_free);
    const char *quotestr = "`";
    const char *tick = NULL;
    char *ptr, *ptr2, *str;
    char *arroba = NULL;
    char *grep = NULL;
    RzIODesc *tmpdesc = NULL;
    int pamode = !core->io->va;
    int i, ret = 0, pipefd;
    bool usemyblock = false;
    int scr_html = -1;
    int scr_color = -1;
    bool eos = false;
    bool haveQuote = false;
    bool oldfixedarch = core->fixedarch;
    bool oldfixedbits = core->fixedbits;
    bool cmd_tmpseek = false;
    ut64 tmpbsz = core->blocksize;
    int cmd_ignbithints = -1;
 
    if (!cmd) {
        rz_list_free(tmpenvs);
        return 0;
    }
    rz_str_trim(cmd);
 
    char *$0 = strstr(cmd, "$(");
    if ($0) {
        char *$1 = strchr($0 + 2, ')');
        if ($1) {
            *$0 = '`';
            *$1 = '`';
            memmove($0 + 1, $0 + 2, strlen($0 + 2) + 1);
        } else {
            eprintf("Unterminated $() block\n");
        }
    }
 
    /* quoted / raw command */
    switch (*cmd) {
    case '.':
        if (cmd[1] == '"') { /* interpret */
            rz_list_free(tmpenvs);
            return rz_cmd_call(core->rcmd, cmd);
        }
        break;
    case '"':
        for (; *cmd;) {
            int pipefd = -1;
            ut64 oseek = UT64_MAX;
            char *line, *p;
            haveQuote = *cmd == '"';
            if (haveQuote) {
                cmd++;
                p = *cmd ? find_eoq(cmd) : NULL;
                if (!p || !*p) {
                    eprintf("Missing \" in (%s).", cmd);
                    rz_list_free(tmpenvs);
                    return false;
                }
                *p++ = 0;
                if (!*p) {
                    eos = true;
                }
            } else {
                char *sc = strchr(cmd, ';');
                if (sc) {
                    *sc = 0;
                }
                rz_core_cmd0(core, cmd);
                if (!sc) {
                    break;
                }
                cmd = sc + 1;
                continue;
            }
            char op0 = 0;
            if (*p) {
                // workaround :D
                if (p[0] == '@') {
                    p--;
                }
                while (p[1] == ';' || IS_WHITESPACE(p[1])) {
                    p++;
                }
                if (p[1] == '@' || (p[1] && p[2] == '@')) {
                    char *q = strchr(p + 1, '"');
                    if (q) {
                        op0 = *q;
                        *q = 0;
                    }
                    haveQuote = q != NULL;
                    oseek = core->offset;
                    rz_core_seek(core, rz_num_math(core->num, p + 2), true);
                    if (q) {
                        *p = '"';
                        p = q;
                    } else {
                        p = strchr(p + 1, ';');
                    }
                }
                if (p && *p && p[1] == '>') {
                    str = p + 2;
                    while (*str == '>') {
                        str++;
                    }
                    str = (char *)rz_str_trim_head_ro(str);
                    rz_cons_flush();
                    const bool append = p[2] == '>';
                    pipefd = rz_cons_pipe_open(str, 1, append);
                }
            }
            line = strdup(cmd);
            line = rz_str_replace(line, "\\\"", "\"", true);
            if (p && *p && p[1] == '|') {
                str = (char *)rz_str_trim_head_ro(p + 2);
                rz_core_cmd_pipe_old(core, cmd, str);
            } else {
                rz_cmd_call(core->rcmd, line);
            }
            free(line);
            if (oseek != UT64_MAX) {
                rz_core_seek(core, oseek, true);
            }
            if (pipefd != -1) {
                rz_cons_flush();
                rz_cons_pipe_close(pipefd);
            }
            if (!p) {
                break;
            }
            if (eos) {
                break;
            }
            if (haveQuote) {
                if (*p == ';') {
                    cmd = p + 1;
                } else {
                    if (*p == '"') {
                        cmd = p;
                    } else {
                        *p = op0;
                        cmd = p;
                    }
                }
            } else {
                cmd = p + 1;
            }
        }
        rz_list_free(tmpenvs);
        return true;
    case '(':
        if (cmd[1] != '*' && !strstr(cmd, ")()")) {
            rz_list_free(tmpenvs);
            return rz_cmd_call(core->rcmd, cmd);
        }
        break;
    case '?':
        if (cmd[1] == '>') {
            rz_core_cmd_help(core, help_msg_greater_sign);
            rz_list_free(tmpenvs);
            return true;
        }
    }
 
    // TODO must honor `
    /* comments */
    if (*cmd != '#') {
        ptr = (char *)rz_str_firstbut(cmd, '#', "`\""); // TODO: use quotestr here
        if (ptr && (ptr[1] == ' ' || ptr[1] == '\t')) {
            *ptr = '\0';
        }
    }
 
    /* multiple commands */
    // TODO: must honor " and ` boundaries
    // ptr = strrchr (cmd, ';');
    if (*cmd != '#') {
        if (is_macro_command(cmd)) {
            ptr = find_ch_after_macro(cmd, ';');
        } else {
            ptr = (char *)rz_str_lastbut(cmd, ';', quotestr);
        }
        if (colon && ptr) {
            int ret;
            *ptr = '\0';
            if (rz_core_cmd_subst(core, cmd) == -1) {
                rz_list_free(tmpenvs);
                return -1;
            }
            cmd = ptr + 1;
            ret = rz_core_cmd_subst(core, cmd);
            *ptr = ';';
            rz_list_free(tmpenvs);
            return ret;
            // rz_cons_flush ();
        }
    }
 
    // TODO must honor " and `
    /* pipe console to shell process */
    // ptr = strchr (cmd, '|');
    ptr = (char *)rz_str_lastbut(cmd, '|', quotestr);
    if (ptr) {
        if (ptr > cmd) {
            char *ch = ptr - 1;
            if (*ch == '\\') {
                memmove(ch, ptr, strlen(ptr) + 1);
                goto escape_pipe;
            }
        }
        char *ptr2 = strchr(cmd, '`');
        if (!ptr2 || (ptr2 && ptr2 > ptr)) {
            if (!tick || (tick && tick > ptr)) {
                *ptr = '\0';
                cmd = rz_str_trim_nc(cmd);
                if (!strcmp(ptr + 1, "?")) { // "|?"
                    rz_core_cmd_help(core, help_msg_vertical_bar);
                    rz_list_free(tmpenvs);
                    return ret;
                } else if (!strncmp(ptr + 1, "H", 1)) { // "|H"
                    scr_html = rz_config_get_i(core->config, "scr.html");
                    rz_config_set_i(core->config, "scr.html", true);
                } else if (!strcmp(ptr + 1, ".")) { // "|."
                    ret = *cmd ? rz_core_cmdf(core, ".%s", cmd) : 0;
                    rz_list_free(tmpenvs);
                    return ret;
                } else if (ptr[1]) { // "| grep .."
                    int value = core->num->value;
                    if (*cmd) {
                        rz_core_cmd_pipe_old(core, cmd, ptr + 1);
                    } else {
                        char *res = rz_io_system(core->io, ptr + 1);
                        if (res) {
                            rz_cons_printf("%s\n", res);
                            free(res);
                        }
                    }
                    core->num->value = value;
                    rz_list_free(tmpenvs);
                    return 0;
                } else { // "|"
                    scr_html = rz_config_get_i(core->config, "scr.html");
                    rz_config_set_i(core->config, "scr.html", 0);
                    scr_color = rz_config_get_i(core->config, "scr.color");
                    rz_config_set_i(core->config, "scr.color", COLOR_MODE_DISABLED);
                }
            }
        }
    }
escape_pipe:
 
    // TODO must honor " and `
    /* bool conditions */
    ptr = (char *)rz_str_lastbut(cmd, '&', quotestr);
    // ptr = strchr (cmd, '&');
    while (ptr && *ptr && ptr[1] == '&') {
        *ptr = '\0';
        ret = rz_cmd_call(core->rcmd, cmd);
        if (ret == -1) {
            eprintf("command error(%s)\n", cmd);
            if (scr_html != -1) {
                rz_config_set_i(core->config, "scr.html", scr_html);
            }
            if (scr_color != -1) {
                rz_config_set_i(core->config, "scr.color", scr_color);
            }
            rz_list_free(tmpenvs);
            return ret;
        }
        for (cmd = ptr + 2; cmd && *cmd == ' '; cmd++) {
            ;
        }
        ptr = strchr(cmd, '&');
    }
 
    ptr = strstr(cmd, "?*");
    if (ptr && (ptr == cmd || ptr[-1] != '~')) {
        ptr[0] = 0;
        if (*cmd != '#') {
            int detail = 0;
            if (cmd < ptr && ptr[-1] == '?') {
                detail++;
                if (cmd < ptr - 1 && ptr[-2] == '?') {
                    detail++;
                }
            }
            rz_cons_break_push(NULL, NULL);
            recursive_help(core, detail, cmd);
            rz_cons_break_pop();
            rz_cons_grep_parsecmd(ptr + 2, "`");
            if (scr_html != -1) {
                rz_config_set_i(core->config, "scr.html", scr_html);
            }
            if (scr_color != -1) {
                rz_config_set_i(core->config, "scr.color", scr_color);
            }
            rz_list_free(tmpenvs);
            return 0;
        }
    }
 
    /* pipe console to file */
    ptr = (char *)rz_str_firstbut(cmd, '>', "\"");
    // TODO honor `
    if (ptr) {
        if (ptr > cmd) {
            char *ch = ptr - 1;
            if (*ch == '\\') {
                memmove(ch, ptr, strlen(ptr) + 1);
                goto escape_redir;
            }
        }
        if (ptr[0] && ptr[1] == '?') {
            rz_core_cmd_help(core, help_msg_greater_sign);
            rz_list_free(tmpenvs);
            return true;
        }
        int fdn = 1;
        int pipecolor = rz_config_get_i(core->config, "scr.color.pipe");
        int use_editor = false;
        int ocolor = rz_config_get_i(core->config, "scr.color");
        *ptr = '\0';
        str = ptr + 1 + (ptr[1] == '>');
        rz_str_trim(str);
        if (!*str) {
            eprintf("No output?\n");
            goto next2;
        }
        /* rz_cons_flush() handles interactive output (to the terminal)
         * differently (e.g. asking about too long output). This conflicts
         * with piping to a file. Disable it while piping. */
        if (ptr > (cmd + 1) && IS_WHITECHAR(ptr[-2])) {
            char *fdnum = ptr - 1;
            if (*fdnum == 'H') { // "H>"
                scr_html = rz_config_get_i(core->config, "scr.html");
                rz_config_set_i(core->config, "scr.html", true);
                pipecolor = true;
                *fdnum = 0;
            } else {
                if (IS_DIGIT(*fdnum)) {
                    fdn = *fdnum - '0';
                }
                *fdnum = 0;
            }
        }
        rz_cons_set_interactive(false);
        if (!strcmp(str, "-")) {
            use_editor = true;
            str = rz_file_temp("dumpedit");
            rz_config_set_i(core->config, "scr.color", COLOR_MODE_DISABLED);
        }
        const bool appendResult = (ptr[1] == '>');
        if (*str == '$') {
            // pipe to alias variable
            // register output of command as an alias
            char *o = rz_core_cmd_str(core, cmd);
            if (appendResult) {
                char *oldText = rz_cmd_alias_get(core->rcmd, str, 1);
                if (oldText) {
                    char *two = rz_str_newf("%s%s", oldText, o);
                    if (two) {
                        rz_cmd_alias_set(core->rcmd, str, two, 1);
                        free(two);
                    }
                } else {
                    char *n = rz_str_newf("$%s", o);
                    rz_cmd_alias_set(core->rcmd, str, n, 1);
                    free(n);
                }
            } else {
                char *n = rz_str_newf("$%s", o);
                rz_cmd_alias_set(core->rcmd, str, n, 1);
                free(n);
            }
            ret = 0;
            free(o);
        } else if (fdn > 0) {
            // pipe to file (or append)
            pipefd = rz_cons_pipe_open(str, fdn, appendResult);
            if (pipefd != -1) {
                if (!pipecolor) {
                    rz_config_set_i(core->config, "scr.color", COLOR_MODE_DISABLED);
                }
                ret = rz_core_cmd_subst(core, cmd);
                rz_cons_flush();
                rz_cons_pipe_close(pipefd);
            }
        }
        rz_cons_set_last_interactive();
        if (!pipecolor) {
            rz_config_set_i(core->config, "scr.color", ocolor);
        }
        if (use_editor) {
            const char *editor = rz_config_get(core->config, "cfg.editor");
            if (editor && *editor) {
                rz_sys_cmdf("%s '%s'", editor, str);
                rz_file_rm(str);
            } else {
                eprintf("No cfg.editor configured\n");
            }
            rz_config_set_i(core->config, "scr.color", ocolor);
            free(str);
        }
        if (scr_html != -1) {
            rz_config_set_i(core->config, "scr.html", scr_html);
        }
        if (scr_color != -1) {
            rz_config_set_i(core->config, "scr.color", scr_color);
        }
        rz_list_free(tmpenvs);
        return ret;
    }
escape_redir:
next2:
    /* sub commands */
    ptr = strchr(cmd, '`');
    if (ptr) {
        if (ptr > cmd) {
            char *ch = ptr - 1;
            if (*ch == '\\') {
                memmove(ch, ptr, strlen(ptr) + 1);
                goto escape_backtick;
            }
        }
        bool empty = false;
        int oneline = 1;
        if (ptr[1] == '`') {
            memmove(ptr, ptr + 1, strlen(ptr));
            oneline = 0;
            empty = true;
        }
        ptr2 = strchr(ptr + 1, '`');
        if (empty) {
            /* do nothing */
        } else if (!ptr2) {
            eprintf("parse: Missing backtick in expression.\n");
            goto fail;
        } else {
            int value = core->num->value;
            *ptr = '\0';
            *ptr2 = '\0';
            if (ptr[1] == '!') {
                str = rz_core_cmd_str_pipe(core, ptr + 1);
            } else {
                // Color disabled when doing backticks ?e `pi 1`
                int ocolor = rz_config_get_i(core->config, "scr.color");
                rz_config_set_i(core->config, "scr.color", 0);
                core->cmd_in_backticks = true;
                str = rz_core_cmd_str(core, ptr + 1);
                core->cmd_in_backticks = false;
                rz_config_set_i(core->config, "scr.color", ocolor);
            }
            if (!str) {
                goto fail;
            }
            // ignore contents if first char is pipe or comment
            if (*str == '|' || *str == '*') {
                eprintf("rz_core_cmd_subst_i: invalid backticked command\n");
                free(str);
                goto fail;
            }
            if (oneline && str) {
                for (i = 0; str[i]; i++) {
                    if (str[i] == '\n') {
                        str[i] = ' ';
                    }
                }
            }
            str = rz_str_append(str, ptr2 + 1);
            cmd = rz_str_append(strdup(cmd), str);
            core->num->value = value;
            ret = rz_core_cmd_subst(core, cmd);
            free(cmd);
            if (scr_html != -1) {
                rz_config_set_i(core->config, "scr.html", scr_html);
            }
            free(str);
            rz_list_free(tmpenvs);
            return ret;
        }
    }
escape_backtick:
    // TODO must honor " and `
    if (*cmd != '"' && *cmd) {
        const char *s = strstr(cmd, "~?");
        if (s) {
            bool showHelp = false;
            if (cmd == s) {
                // ~?
                // ~??
                showHelp = true;
            } else {
                // pd~?
                // pd~??
                if (!strcmp(s, "~??")) {
                    showHelp = true;
                }
            }
            if (showHelp) {
                rz_cons_grep_help();
                rz_list_free(tmpenvs);
                return true;
            }
        }
    }
    if (*cmd != '.') {
        grep = rz_cons_grep_strip(cmd, quotestr);
    }
 
    /* temporary seek commands */
    // if (*cmd != '(' && *cmd != '"') {
    if (*cmd != '"') {
        ptr = strchr(cmd, '@');
        if (ptr == cmd + 1 && *cmd == '?') {
            ptr = NULL;
        }
    } else {
        ptr = NULL;
    }
 
    cmd_tmpseek = core->tmpseek = ptr != NULL;
    int rc = 0;
    if (ptr) {
        char *f, *ptr2 = strchr(ptr + 1, '!');
        ut64 addr = core->offset;
        bool addr_is_set = false;
        char *tmpbits = NULL;
        const char *offstr = NULL;
        bool is_bits_set = false;
        bool is_arch_set = false;
        char *tmpeval = NULL;
        char *tmpasm = NULL;
        bool flgspc_changed = false;
        int tmpfd = -1;
        size_t sz;
        int len;
        ut8 *buf;
 
        *ptr++ = '\0';
    repeat_arroba:
        arroba = (ptr[0] && ptr[1] && ptr[2]) ? strchr(ptr + 2, '@') : NULL;
        if (arroba) {
            *arroba = 0;
        }
 
        for (; *ptr == ' '; ptr++) {
            // nothing to see here
        }
        if (*ptr && ptr[1] == ':') {
            /* do nothing here */
        } else {
            ptr--;
        }
 
        rz_str_trim_tail(ptr);
 
        if (ptr[1] == '?') {
            rz_core_cmd_help(core, help_msg_at);
        } else if (ptr[1] == '%') { // "@%"
            char *k = strdup(ptr + 2);
            char *v = strchr(k, '=');
            if (v) {
                *v++ = 0;
                rz_sys_setenv(k, v);
                rz_list_append(tmpenvs, k);
            } else {
                free(k);
            }
        } else if (ptr[1] == '.') { // "@."
            if (ptr[2] == '.') { // "@.."
                if (ptr[3] == '.') { // "@..."
                    ut64 addr = rz_num_tail(core->num, core->offset, ptr + 4);
                    rz_core_block_size(core, RZ_ABS((st64)addr - (st64)core->offset));
                    goto fuji;
                } else {
                    addr = rz_num_tail(core->num, core->offset, ptr + 3);
                    rz_core_seek(core, addr, true);
                    cmd_tmpseek = core->tmpseek = true;
                    goto fuji;
                }
            } else {
                // WAT DU
                eprintf("TODO: what do you expect for @. import offset from file maybe?\n");
            }
        } else if (ptr[0] && ptr[1] == ':' && ptr[2]) {
            switch (ptr[0]) {
            case 'F': // "@F:" // temporary flag space
                flgspc_changed = rz_flag_space_push(core->flags, ptr + 2);
                break;
            case 'B': // "@B:#" // seek to the last instruction in current bb
            {
                int index = (int)rz_num_math(core->num, ptr + 2);
                if (rz_core_seek_bb_instruction(core, index)) {
                    cmd_tmpseek = core->tmpseek = true;
                }
                break;
            } break;
            case 'f': // "@f:" // slurp file in block
                f = rz_file_slurp(ptr + 2, &sz);
                if (f) {
                    {
                        RzBuffer *b = rz_buf_new_with_bytes((const ut8 *)f, (ut64)sz);
                        RzIODesc *d = rz_io_open_buffer(core->io, b, RZ_PERM_RWX, 0);
                        if (d) {
                            if (tmpdesc) {
                                rz_io_desc_close(tmpdesc);
                            }
                            tmpdesc = d;
                            if (pamode) {
                                rz_config_set_i(core->config, "io.va", 1);
                            }
                            rz_io_map_new(core->io, d->fd, d->perm, 0, core->offset, rz_buf_size(b));
                        }
                    }
                } else {
                    eprintf("cannot open '%s'\n", ptr + 3);
                }
                break;
            case 'r': // "@r:" // regname
                if (ptr[1] == ':') {
                    ut64 regval;
                    char *mander = strdup(ptr + 2);
                    char *sep = findSeparator(mander);
                    if (sep) {
                        char ch = *sep;
                        *sep = 0;
                        regval = rz_debug_reg_get(core->dbg, mander);
                        *sep = ch;
                        char *numexpr = rz_str_newf("0x%" PFMT64x "%s", regval, sep);
                        regval = rz_num_math(core->num, numexpr);
                        free(numexpr);
                    } else {
                        regval = rz_debug_reg_get(core->dbg, ptr + 2);
                    }
                    rz_core_seek(core, regval, true);
                    cmd_tmpseek = core->tmpseek = true;
                    free(mander);
                }
                break;
            case 'b': // "@b:" // bits
                is_bits_set = set_tmp_bits(core, rz_num_math(core->num, ptr + 2), &tmpbits, &cmd_ignbithints);
                break;
            case 'i': // "@i:"
            {
                ut64 addr = rz_num_math(core->num, ptr + 2);
                if (addr) {
                    rz_core_seek_opcode(core, addr, false);
                    cmd_tmpseek = core->tmpseek = true;
                }
            } break;
            case 'e': // "@e:"
            {
                char *cmd = parse_tmp_evals(core, ptr + 2);
                if (!tmpeval) {
                    tmpeval = cmd;
                } else {
                    tmpeval = rz_str_prepend(tmpeval, cmd);
                    free(cmd);
                }
            } break;
            case 'v': // "@v:" // value (honors asm.bits and cfg.bigendian)
                if (ptr[1] == ':') {
                    ut8 buf[8] = { 0 };
                    ut64 v = rz_num_math(core->num, ptr + 2);
                    int be = rz_config_get_i(core->config, "cfg.bigendian");
                    int bi = rz_config_get_i(core->config, "asm.bits");
                    if (bi == 64) {
                        rz_write_ble64(buf, v, be);
                        len = 8;
                    } else {
                        rz_write_ble32(buf, v, be);
                        len = 4;
                    }
                    rz_core_block_size(core, RZ_ABS(len));
                    RzBuffer *b = rz_buf_new_with_bytes(buf, len);
                    RzIODesc *d = rz_io_open_buffer(core->io, b, RZ_PERM_RWX, 0);
                    if (d) {
                        if (tmpdesc) {
                            rz_io_desc_close(tmpdesc);
                        }
                        tmpdesc = d;
                        if (pamode) {
                            rz_config_set_i(core->config, "io.va", 1);
                        }
                        rz_io_map_new(core->io, d->fd, d->perm, 0, core->offset, rz_buf_size(b));
                        rz_core_block_size(core, len);
                        rz_core_block_read(core);
                    }
                } else {
                    eprintf("Invalid @v: syntax\n");
                }
                break;
            case 'x': // "@x:" // hexpairs
                if (ptr[1] == ':') {
                    buf = malloc(strlen(ptr + 2) + 1);
                    if (buf) {
                        len = rz_hex_str2bin(ptr + 2, buf);
                        rz_core_block_size(core, RZ_ABS(len));
                        if (len > 0) {
                            RzBuffer *b = rz_buf_new_with_bytes(buf, len);
                            RzIODesc *d = rz_io_open_buffer(core->io, b, RZ_PERM_RWX, 0);
                            if (d) {
                                if (tmpdesc) {
                                    rz_io_desc_close(tmpdesc);
                                }
                                tmpdesc = d;
                                if (pamode) {
                                    rz_config_set_i(core->config, "io.va", 1);
                                }
                                rz_io_map_new(core->io, d->fd, d->perm, 0, core->offset, rz_buf_size(b));
                                rz_core_block_size(core, len);
                                rz_core_block_read(core);
                            }
                        } else {
                            eprintf("Error: Invalid hexpairs for @x:\n");
                        }
                        free(buf);
                    } else {
                        eprintf("cannot allocate\n");
                    }
                } else {
                    eprintf("Invalid @x: syntax\n");
                }
                break;
            case 'k': // "@k"
            {
                char *out = sdb_querys(core->sdb, NULL, 0, ptr + ((ptr[1]) ? 2 : 1));
                if (out) {
                    rz_core_seek(core, rz_num_math(core->num, out), true);
                    free(out);
                    usemyblock = true;
                }
            } break;
            case 'o': // "@o:3"
                if (ptr[1] == ':') {
                    tmpfd = core->io->desc ? core->io->desc->fd : -1;
                    rz_io_use_fd(core->io, atoi(ptr + 2));
                }
                break;
            case 'a': // "@a:"
                if (ptr[1] == ':') {
                    char *q = strchr(ptr + 2, ':');
                    if (q) {
                        *q++ = 0;
                        int bits = rz_num_math(core->num, q);
                        is_bits_set = set_tmp_bits(core, bits, &tmpbits, &cmd_ignbithints);
                    }
                    is_arch_set = set_tmp_arch(core, ptr + 2, &tmpasm);
                } else {
                    eprintf("Usage: pd 10 @a:arm:32\n");
                }
                break;
            case 's': // "@s:" // wtf syntax
            {
                len = strlen(ptr + 2);
                rz_core_block_size(core, len);
                const ut8 *buf = (const ut8 *)rz_str_trim_head_ro(ptr + 2);
 
                if (len > 0) {
                    RzBuffer *b = rz_buf_new_with_bytes(buf, len);
                    RzIODesc *d = rz_io_open_buffer(core->io, b, RZ_PERM_RWX, 0);
                    if (!core->io->va) {
                        rz_config_set_i(core->config, "io.va", 1);
                    }
                    if (d) {
                        if (tmpdesc) {
                            rz_io_desc_close(tmpdesc);
                        }
                        tmpdesc = d;
                        if (pamode) {
                            rz_config_set_i(core->config, "io.va", 1);
                        }
                        rz_io_map_new(core->io, d->fd, d->perm, 0, core->offset, rz_buf_size(b));
                        rz_core_block_size(core, len);
                        // rz_core_block_read (core);
                    }
                }
            } break;
            default:
                goto ignore;
            }
            *ptr = '@';
            /* trim whitespaces before the @ */
            /* Fixes pd @x:9090 */
            char *trim = ptr - 2;
            while (trim > cmd) {
                if (!IS_WHITESPACE(*trim)) {
                    break;
                }
                *trim = 0;
                trim--;
            }
            goto next_arroba;
        }
    ignore:
        rz_str_trim_head(ptr + 1);
        cmd = rz_str_trim_nc(cmd);
        if (ptr2) {
            if (strlen(ptr + 1) == 13 && strlen(ptr2 + 1) == 6 &&
                !memcmp(ptr + 1, "0x", 2) &&
                !memcmp(ptr2 + 1, "0x", 2)) {
                /* 0xXXXX:0xYYYY */
            } else if (strlen(ptr + 1) == 9 && strlen(ptr2 + 1) == 4) {
                /* XXXX:YYYY */
            } else {
                *ptr2 = '\0';
                if (!ptr2[1]) {
                    goto fail;
                }
                rz_core_block_size(
                    core, rz_num_math(core->num, ptr2 + 1));
            }
        }
 
        rz_str_trim_head(ptr + 1);
        offstr = ptr + 1;
 
        addr = (*offstr == '{') ? core->offset : rz_num_math(core->num, offstr);
        addr_is_set = true;
 
        if (isalpha((ut8)ptr[1]) && !addr) {
            if (!rz_flag_get(core->flags, ptr + 1)) {
                eprintf("Invalid address (%s)\n", ptr + 1);
                goto fail;
            }
        } else {
            char ch = *offstr;
            if (ch == '-' || ch == '+') {
                addr = core->offset + addr;
            }
        }
        // remap thhe tmpdesc if any
        if (addr) {
            RzIODesc *d = tmpdesc;
            if (d) {
                rz_io_map_new(core->io, d->fd, d->perm, 0, addr, rz_io_desc_size(d));
            }
        }
    next_arroba:
        if (arroba) {
            ptr = arroba + 1;
            *arroba = '@';
            arroba = NULL;
            goto repeat_arroba;
        }
        core->fixedblock = !!tmpdesc;
        if (core->fixedblock) {
            rz_core_block_read(core);
        }
        if (ptr[1] == '@') {
            if (ptr[2] == '@') {
                char *rule = ptr + 3;
                while (*rule && *rule == ' ') {
                    rule++;
                }
                ret = rz_core_cmd_foreach3(core, cmd, rule);
            } else {
                ret = rz_core_cmd_foreach(core, cmd, ptr + 2);
            }
        } else {
            bool tmpseek = false;
            const char *fromvars[] = { "analysis.from", "diff.from", "graph.from", "search.from", "zoom.from", NULL };
            const char *tovars[] = { "analysis.to", "diff.to", "graph.to", "search.to", "zoom.to", NULL };
            ut64 curfrom[RZ_ARRAY_SIZE(fromvars) - 1], curto[RZ_ARRAY_SIZE(tovars) - 1];
 
            // "@{A B}"
            if (ptr[1] == '{') {
                char *range = ptr + 2;
                char *p = strchr(range, ' ');
                if (!p) {
                    eprintf("Usage: / ABCD @{0x1000 0x3000}\n");
                    eprintf("Run command and define the following vars:\n");
                    eprintf(" (analysis|diff|graph|search|zoom).{from,to}\n");
                    free(tmpeval);
                    free(tmpasm);
                    free(tmpbits);
                    goto fail;
                }
                char *arg = p + 1;
                int arg_len = strlen(arg);
                if (arg_len > 0) {
                    arg[arg_len - 1] = 0;
                }
                *p = '\x00';
                ut64 from = rz_num_math(core->num, range);
                ut64 to = rz_num_math(core->num, arg);
                // save current ranges
                for (i = 0; fromvars[i]; i++) {
                    curfrom[i] = rz_config_get_i(core->config, fromvars[i]);
                }
                for (i = 0; tovars[i]; i++) {
                    curto[i] = rz_config_get_i(core->config, tovars[i]);
                }
                // set new ranges
                for (i = 0; fromvars[i]; i++) {
                    rz_config_set_i(core->config, fromvars[i], from);
                }
                for (i = 0; tovars[i]; i++) {
                    rz_config_set_i(core->config, tovars[i], to);
                }
                tmpseek = true;
            }
            if (usemyblock) {
                if (addr_is_set) {
                    core->offset = addr;
                }
                ret = rz_cmd_call(core->rcmd, rz_str_trim_head_ro(cmd));
            } else {
                if (addr_is_set) {
                    if (ptr[1]) {
                        rz_core_seek(core, addr, true);
                        rz_core_block_read(core);
                    }
                }
                ret = rz_cmd_call(core->rcmd, rz_str_trim_head_ro(cmd));
            }
            if (tmpseek) {
                // restore ranges
                for (i = 0; fromvars[i]; i++) {
                    rz_config_set_i(core->config, fromvars[i], curfrom[i]);
                }
                for (i = 0; tovars[i]; i++) {
                    rz_config_set_i(core->config, tovars[i], curto[i]);
                }
            }
        }
        if (ptr2) {
            *ptr2 = '!';
            rz_core_block_size(core, tmpbsz);
        }
        if (is_arch_set) {
            core->fixedarch = oldfixedarch;
            rz_config_set(core->config, "asm.arch", tmpasm);
            RZ_FREE(tmpasm);
        }
        if (tmpfd != -1) {
            // TODO: reuse tmpfd instead of
            rz_io_use_fd(core->io, tmpfd);
        }
        if (tmpdesc) {
            if (pamode) {
                rz_config_set_i(core->config, "io.va", 0);
            }
            rz_io_desc_close(tmpdesc);
            tmpdesc = NULL;
        }
        if (is_bits_set) {
            rz_config_set(core->config, "asm.bits", tmpbits);
            core->fixedbits = oldfixedbits;
        }
        if (tmpbsz != core->blocksize) {
            rz_core_block_size(core, tmpbsz);
        }
        if (tmpeval) {
            rz_core_cmd0(core, tmpeval);
            RZ_FREE(tmpeval);
        }
        if (flgspc_changed) {
            rz_flag_space_pop(core->flags);
        }
        *ptr = '@';
        rc = ret;
        goto beach;
    }
fuji:
    if (cmd) {
        rz_str_trim_head(cmd);
        rc = rz_cmd_call(core->rcmd, cmd);
    } else {
        rc = false;
    }
beach:
    if (grep) {
        char *old_grep = grep;
        grep = rz_cmd_unescape_arg(old_grep, true);
        free(old_grep);
    }
    rz_cons_grep_process(grep);
    if (scr_html != -1) {
        rz_cons_flush();
        rz_config_set_i(core->config, "scr.html", scr_html);
    }
    if (scr_color != -1) {
        rz_config_set_i(core->config, "scr.color", scr_color);
    }
    rz_list_free(tmpenvs);
    if (tmpdesc) {
        rz_io_desc_close(tmpdesc);
        tmpdesc = NULL;
    }
    core->fixedarch = oldfixedarch;
    core->fixedbits = oldfixedbits;
    if (tmpseek) {
        *tmpseek = cmd_tmpseek;
    }
    if (cmd_ignbithints != -1) {
        rz_config_set_i(core->config, "analysis.ignbithints", cmd_ignbithints);
    }
    return rc;
fail:
    rc = -1;
    goto beach;
}

References addr, append, b, bits(), rz_core_t::blocksize, cmd, rz_core_t::cmd_in_backticks, COLOR_MODE_DISABLED, rz_core_t::config, d, rz_core_t::dbg, rz_io_t::desc, eprintf, f, fail, rz_io_desc_t::fd, find_ch_after_macro(), find_eoq(), findSeparator(), rz_core_t::fixedarch, rz_core_t::fixedbits, rz_core_t::fixedblock, rz_core_t::flags, free(), from, help_msg_at, help_msg_greater_sign, help_msg_vertical_bar, i, int, rz_core_t::io, IS_DIGIT, is_macro_command(), IS_WHITECHAR, IS_WHITESPACE, isalpha, k, len, setup::line, malloc(), n, NULL, rz_core_t::num, rz_core_t::offset, out, p, parse_tmp_evals(), PFMT64x, capstone::range, rz_core_t::rcmd, recursive_help(), duplicate_flag_t::ret, RZ_ABS, RZ_ARRAY_SIZE, rz_buf_new_with_bytes(), rz_buf_size(), rz_cmd_alias_get(), rz_cmd_alias_set(), rz_cmd_call(), rz_cmd_unescape_arg(), rz_config_get(), rz_config_get_i(), rz_config_set(), rz_config_set_i(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_flush(), rz_cons_grep_help(), rz_cons_grep_parsecmd(), rz_cons_grep_process(), rz_cons_grep_strip(), rz_cons_pipe_close(), rz_cons_pipe_open(), rz_cons_printf(), rz_cons_set_interactive(), rz_cons_set_last_interactive(), rz_core_block_read(), rz_core_block_size(), rz_core_cmd0(), rz_core_cmd_foreach(), rz_core_cmd_foreach3(), rz_core_cmd_help(), rz_core_cmd_pipe_old(), rz_core_cmd_str(), rz_core_cmd_str_pipe(), rz_core_cmd_subst(), rz_core_cmdf(), rz_core_seek(), rz_core_seek_bb_instruction(), rz_core_seek_opcode(), rz_debug_reg_get(), rz_file_rm(), rz_file_slurp(), rz_file_temp(), rz_flag_get(), RZ_FREE, rz_hex_str2bin(), rz_io_desc_close(), rz_io_desc_size(), rz_io_map_new(), rz_io_open_buffer(), rz_io_system(), rz_io_use_fd(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_num_math(), rz_num_tail(), RZ_PERM_RWX, rz_str_append(), rz_str_firstbut(), rz_str_lastbut(), rz_str_newf(), rz_str_prepend(), rz_str_replace(), rz_str_trim(), rz_str_trim_head(), rz_str_trim_head_ro(), rz_str_trim_nc(), rz_str_trim_tail(), rz_sys_cmdf(), rz_sys_setenv(), rz_write_ble32(), rz_write_ble64(), s, sc, rz_core_t::sdb, sdb_querys(), set_tmp_arch(), set_tmp_bits(), st64, cmd_descs_generate::str, strdup(), tick, tmpenvs_free(), rz_core_t::tmpseek, to, trim(), ut64(), UT64_MAX, v, rz_io_t::va, value, and rz_num_t::value.

Referenced by rz_core_cmd_subst().

rz_core_cmdf()

RZ_API int rz_core_cmdf	(	RzCore *	core,
		const char *	fmt,
			...
	)

Definition at line 5413 of file cmd.c.

                                                            {
    char string[4096];
    int ret;
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(string, sizeof(string), fmt, ap);
    ret = rz_core_cmd(core, string, 0);
    va_end(ap);
    return ret;
}

References tsr2cmd_state::core, rz_core_cmd(), and vsnprintf.

Referenced by __calculator_cb(), __handle_console(), __writeValueCb(), _CbInRangeSearchV(), annotated_hexdump(), cmd_analysis_graph(), cmd_print_pv(), convert_dotcmd_to_image(), do_asm_search(), initialize_stack(), pr_bb(), rz_cmd_debug(), rz_cmd_disassembly_all_methods_class_handler(), rz_cmd_hexdump(), rz_cmd_print(), rz_cmd_search(), rz_core_analysis_esil_init_mem(), rz_core_bin_apply_sections(), rz_core_bind(), rz_core_cmd_foreach3(), rz_core_cmd_subst_i(), rz_core_esil_cmd(), rz_core_init(), rz_core_print_disasm(), rz_core_print_examine(), rz_core_rtr_http(), rz_core_types_link_print(), rz_core_visual_browse(), rz_core_visual_colors(), rz_core_visual_debugtraces(), rz_core_visual_define(), rz_core_visual_trackflags(), rz_main_rizin(), rz_pointer_handler(), rz_seek_search(), type_format_print(), type_format_print_hexstring(), type_format_print_value(), and type_format_print_variable().

rz_core_disassemble_bytes()

RZ_API char* rz_core_disassemble_bytes	(	RzCore *	core,
		ut64	addr,
		int	b
	)

Definition at line 5385 of file cmd.c.

                                                                       {
    char *cmd, *ret = NULL;
    cmd = rz_str_newf("pD %i @ 0x%08" PFMT64x, b, addr);
    if (cmd) {
        ret = rz_core_cmd_str(core, cmd);
        free(cmd);
    }
    return ret;
}

References addr, b, cmd, tsr2cmd_state::core, free(), NULL, PFMT64x, rz_core_cmd_str(), and rz_str_newf().

rz_core_disassemble_instr()

RZ_API char* rz_core_disassemble_instr	(	RzCore *	core,
		ut64	addr,
		int	l
	)

Definition at line 5375 of file cmd.c.

                                                                       {
    char *cmd, *ret = NULL;
    cmd = rz_str_newf("pd %i @ 0x%08" PFMT64x, l, addr);
    if (cmd) {
        ret = rz_core_cmd_str(core, cmd);
        free(cmd);
    }
    return ret;
}

References addr, cmd, tsr2cmd_state::core, free(), NULL, PFMT64x, rz_core_cmd_str(), and rz_str_newf().

Referenced by rz_analyze_cycles_handler().

rz_core_flush()

RZ_API int rz_core_flush	(	RzCore *	core,
		const char *	cmd
	)

Definition at line 5432 of file cmd.c.

                                                        {
    int ret = rz_core_cmd(core, cmd, 0);
    rz_cons_flush();
    return ret;
}

References cmd, tsr2cmd_state::core, rz_cons_flush(), and rz_core_cmd().

rz_core_kuery_print()

RZ_IPI void rz_core_kuery_print	(	RzCore *	core,
		const char *	k
	)

Definition at line 634 of file cmd.c.

                                                             {
    char *out = sdb_querys(core->sdb, NULL, 0, k);
    if (out) {
        rz_cons_print(out);
    }
    free(out);
}

References free(), k, NULL, out, rz_core_t::sdb, and sdb_querys().

Referenced by rz_cmd_kuery(), and rz_core_types_calling_conventions_print().

rz_core_run_script()

RZ_API bool rz_core_run_script	(	RzCore *	core,
		RZ_NONNULL const char *	file
	)

Definition at line 457 of file cmd.c.

                                                                          {
    rz_return_val_if_fail(file, false);
    bool ret = false;
    RzListIter *iter;
    RzLangPlugin *p;
    char *name;
 
    rz_list_foreach (core->scriptstack, iter, name) {
        if (!strcmp(file, name)) {
            RZ_LOG_WARN("Ignored nested source: '%s'\n", file);
            return false;
        }
    }
    rz_list_push(core->scriptstack, strdup(file));
 
    if (!strcmp(file, "-")) {
        char *out = rz_core_editor(core, NULL, NULL);
        if (out) {
            ret = rz_core_cmd_lines(core, out);
            free(out);
        }
    } else if (rz_str_endswith(file, ".html")) {
        char *httpIndex = strdup(rz_config_get(core->config, "http.index"));
        char *absfile = rz_file_abspath(file);
        rz_config_set(core->config, "http.index", absfile);
        free(absfile);
        rz_equal_H_handler_old(core, "");
        rz_config_set(core->config, "http.index", httpIndex);
        free(httpIndex);
        ret = true;
    } else if (rz_str_endswith(file, ".c")) {
        rz_core_cmd_strf(core, "#!c %s", file);
        ret = true;
    } else if (rz_file_is_c(file)) {
        const char *dir = rz_config_get(core->config, "dir.types");
        char *error_msg = NULL;
        int result = rz_type_parse_file(core->analysis->typedb, file, dir, &error_msg);
        if (error_msg) {
            eprintf("%s", error_msg);
            free(error_msg);
        }
        ret = result != 0;
    } else {
        p = rz_lang_get_by_extension(core->lang, file);
        if (p) {
            rz_lang_use(core->lang, p->name);
            ret = lang_run_file(core, core->lang, file);
        } else {
// XXX this is an ugly hack, we need to use execve here and specify args properly
#if __WINDOWS__
#define cmdstr(x) rz_str_newf(x " %s", file);
#else
#define cmdstr(x) rz_str_newf(x " '%s'", file);
#endif
            const char *p = rz_str_lchr(file, '.');
            if (p) {
                const char *ext = p + 1;
                /* TODO: handle this inside rz_lang_pipe with new APIs */
                if (!strcmp(ext, "js")) {
                    char *cmd = cmdstr("node");
                    rz_lang_use(core->lang, "pipe");
                    lang_run_file(core, core->lang, cmd);
                    free(cmd);
                    ret = 1;
                } else if (!strcmp(ext, "exe")) {
#if __WINDOWS__
                    char *cmd = rz_str_newf("%s", file);
#else
                    char *cmd = cmdstr("wine");
#endif
                    rz_lang_use(core->lang, "pipe");
                    lang_run_file(core, core->lang, cmd);
                    free(cmd);
                    ret = 1;
                } else if (!strcmp(ext, "zig")) {
                    char *cmd = cmdstr("zig run");
                    rz_lang_use(core->lang, "pipe");
                    lang_run_file(core, core->lang, cmd);
                    free(cmd);
                    ret = 1;
                } else if (!strcmp(ext, "d")) {
                    char *cmd = cmdstr("dmd -run");
                    rz_lang_use(core->lang, "pipe");
                    lang_run_file(core, core->lang, cmd);
                    free(cmd);
                    ret = 1;
                } else if (!strcmp(ext, "go")) {
                    char *cmd = cmdstr("go run");
                    rz_lang_use(core->lang, "pipe");
                    lang_run_file(core, core->lang, cmd);
                    free(cmd);
                    ret = 1;
                } else if (!strcmp(ext, "rb")) {
                    char *cmd = cmdstr("ruby");
                    rz_lang_use(core->lang, "pipe");
                    lang_run_file(core, core->lang, cmd);
                    free(cmd);
                    ret = 1;
                } else if (!strcmp(ext, "vala")) {
                    rz_lang_use(core->lang, "vala");
                    lang_run_file(core, core->lang, file);
                    ret = 1;
                } else if (!strcmp(ext, "sh")) {
                    char *shell = rz_sys_getenv("SHELL");
                    if (!shell) {
                        shell = strdup("sh");
                    }
                    if (shell) {
                        rz_lang_use(core->lang, "pipe");
                        char *cmd = rz_str_newf("%s '%s'", shell, file);
                        if (cmd) {
                            lang_run_file(core, core->lang, cmd);
                            free(cmd);
                        }
                        free(shell);
                    }
                    ret = 1;
                } else if (!strcmp(ext, "pl")) {
                    char *cmd = cmdstr("perl");
                    rz_lang_use(core->lang, "pipe");
                    lang_run_file(core, core->lang, cmd);
                    free(cmd);
                    ret = 1;
                } else if (!strcmp(ext, "py")) {
                    char *cmd = cmdstr("python");
                    rz_lang_use(core->lang, "pipe");
                    lang_run_file(core, core->lang, cmd);
                    free(cmd);
                    ret = 1;
                }
            } else {
                char *abspath = rz_file_path(file);
                char *lang = langFromHashbang(core, file);
                if (lang) {
                    rz_lang_use(core->lang, "pipe");
                    char *cmd = rz_str_newf("%s '%s'", lang, file);
                    lang_run_file(core, core->lang, cmd);
                    free(lang);
                    free(cmd);
                    ret = 1;
                }
                free(abspath);
            }
            if (!ret) {
                ret = rz_core_cmd_file(core, file);
            }
        }
    }
    free(rz_list_pop(core->scriptstack));
    return ret;
}

References rz_core_t::analysis, cmd, cmdstr, rz_core_t::config, eprintf, ext, free(), rz_core_t::lang, lang_run_file(), langFromHashbang(), name, NULL, out, p, duplicate_flag_t::ret, rz_config_get(), rz_config_set(), rz_core_cmd_file(), rz_core_cmd_lines(), rz_core_cmd_strf(), rz_core_editor(), rz_equal_H_handler_old(), rz_file_abspath(), rz_file_is_c(), rz_file_path(), rz_lang_get_by_extension(), rz_lang_use(), rz_list_pop(), rz_list_push(), RZ_LOG_WARN, rz_return_val_if_fail, rz_str_endswith(), rz_str_lchr(), rz_str_newf(), rz_sys_getenv(), rz_type_parse_file(), rz_core_t::scriptstack, strdup(), and rz_analysis_t::typedb.

Referenced by load_scripts_for(), run_commands(), rz_core_init(), rz_core_loadlibs(), rz_interpret_editor_2_handler(), rz_interpret_pipe_handler(), rz_interpret_script_handler(), and rz_main_rizin().

rz_last_output_handler()

RZ_IPI RzCmdStatus rz_last_output_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 929 of file cmd.c.

                                                                                     {
    rz_cons_last();
    return RZ_CMD_STATUS_OK;
}

References RZ_CMD_STATUS_OK, and rz_cons_last().

Referenced by rzshell_cmddescs_init().

rz_line_hist_sdb_down()

RZ_API int rz_line_hist_sdb_down

(

RzLine *

line

)

Definition at line 624 of file cmd.c.

                                               {
    if (!line->sdbshell_hist_iter || !line->sdbshell_hist_iter->p) {
        return false;
    }
    line->sdbshell_hist_iter = line->sdbshell_hist_iter->p;
    strncpy(line->buffer.data, line->sdbshell_hist_iter->data, RZ_LINE_BUFSIZE - 1);
    line->buffer.index = line->buffer.length = strlen(line->buffer.data);
    return true;
}

References setup::line, and RZ_LINE_BUFSIZE.

Referenced by rz_cmd_kuery().

rz_line_hist_sdb_up()

RZ_API int rz_line_hist_sdb_up

(

RzLine *

line

)

Definition at line 614 of file cmd.c.

                                             {
    if (!line->sdbshell_hist_iter || !line->sdbshell_hist_iter->n) {
        return false;
    }
    line->sdbshell_hist_iter = line->sdbshell_hist_iter->n;
    strncpy(line->buffer.data, line->sdbshell_hist_iter->data, RZ_LINE_BUFSIZE - 1);
    line->buffer.index = line->buffer.length = strlen(line->buffer.data);
    return true;
}

References setup::line, and RZ_LINE_BUFSIZE.

Referenced by rz_cmd_kuery().

rz_load_panels_layout()

RZ_API bool rz_load_panels_layout	(	RzCore *	core,
		const char *	_name
	)

Definition at line 5321 of file panels.c.

                                                                   {
    if (!core->panels) {
        return false;
    }
    char *config_path = __get_panels_config_file_from_dir(_name);
    if (!config_path) {
        char *tmp = rz_str_newf("No saved layout found for the name: %s", _name);
        (void)__show_status(core, tmp);
        free(tmp);
        return false;
    }
    char *panels_config = rz_file_slurp(config_path, NULL);
    free(config_path);
    if (!panels_config) {
        char *tmp = rz_str_newf("Layout is empty: %s", _name);
        (void)__show_status(core, tmp);
        free(tmp);
        return false;
    }
    RzPanels *panels = core->panels;
    __panel_all_clear(panels);
    panels->n_panels = 0;
    __set_curnode(core, 0);
 
    RzJson *json = rz_json_parse(panels_config);
    if (!json || json->type != RZ_JSON_ARRAY) {
        free(panels_config);
        return false;
    }
    RzJson *child, *baby;
    const char *title = NULL, *cmd = NULL;
    int x = 0, y = 0, w = 0, h = 0;
    // Configuration stored as an array of JSON objects
    for (child = json->children.first; child; child = child->next) {
        if (child->type != RZ_JSON_OBJECT) {
            break;
        }
        size_t params_read = 0;
        for (baby = child->children.first; baby; baby = baby->next) {
            if (params_read == 6) {
                break;
            }
            if (baby->type != RZ_JSON_INTEGER && baby->type != RZ_JSON_STRING) {
                continue;
            }
            // Get window title and executed command
            if (strcmp(baby->key, "title") == 0) {
                title = baby->str_value;
                params_read++;
            } else if (strcmp(baby->key, "cmd") == 0) {
                cmd = baby->str_value;
                params_read++;
                // Parse window geometry
            } else if (strcmp(baby->key, "x") == 0) {
                x = baby->num.u_value;
                params_read++;
            } else if (strcmp(baby->key, "y") == 0) {
                y = baby->num.u_value;
                params_read++;
            } else if (strcmp(baby->key, "w") == 0) {
                w = baby->num.u_value;
                params_read++;
            } else if (strcmp(baby->key, "h") == 0) {
                h = baby->num.u_value;
                params_read++;
            }
        }
        if (!title || !cmd) {
            eprintf("Malformed Visual Panels config: %s\n", _name);
            rz_json_free(json);
            free(panels_config);
            return false;
        }
        RzPanel *p = __get_panel(panels, panels->n_panels);
        __set_geometry(&p->view->pos, x, y, w, h);
        __init_panel_param(core, p, title, cmd);
        if (rz_str_endswith(cmd, "Help")) {
            p->model->title = rz_str_dup(p->model->title, "Help");
            p->model->cmd = rz_str_dup(p->model->cmd, "Help");
            RzStrBuf *rsb = rz_strbuf_new(NULL);
            rz_core_visual_append_help(rsb, "Visual Ascii Art Panels", help_msg_panels);
            if (!rsb) {
                rz_json_free(json);
                free(panels_config);
                return false;
            }
            char *helptxt = rz_strbuf_drain(rsb);
            __set_read_only(core, p, helptxt);
            free(helptxt);
        }
    }
    rz_json_free(json);
    free(panels_config);
    if (!panels->n_panels) {
        return false;
    }
    __set_refresh_all(core, true, false);
    return true;
}

References __get_panel(), __get_panels_config_file_from_dir(), __init_panel_param(), __panel_all_clear(), __set_curnode(), __set_geometry(), __set_read_only(), __set_refresh_all(), __show_status(), rz_json_t::children, cmd, config_path(), eprintf, free(), h, help_msg_panels, rz_json_t::key, rz_panels_t::n_panels, rz_json_t::next, NULL, rz_json_t::num, p, rz_core_t::panels, rz_core_visual_append_help(), rz_file_slurp(), RZ_JSON_ARRAY, rz_json_free(), RZ_JSON_INTEGER, RZ_JSON_OBJECT, rz_json_parse(), RZ_JSON_STRING, rz_str_dup(), rz_str_endswith(), rz_str_newf(), rz_strbuf_drain(), rz_strbuf_new(), rz_json_t::str_value, autogen_x86imm::tmp, rz_json_t::type, w, and x.

Referenced by __load_layout_saved_cb(), __panels_process(), rz_cmd_panels(), and rz_core_visual_panels_root().

rz_pointer_handler()

RZ_IPI RzCmdStatus rz_pointer_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 911 of file cmd.c.

                                                                                 {
    int ret;
    switch (argc) {
    case 2:
        ret = rz_core_cmdf(core, "?v [%s]", argv[1]);
        return rz_cmd_int2status(ret);
    case 3:
        if (rz_str_startswith(argv[2], "0x")) {
            ret = rz_core_cmdf(core, "wv %s @ %s", argv[2], argv[1]);
        } else {
            ret = rz_core_cmdf(core, "wx %s @ %s", argv[2], argv[1]);
        }
        return rz_cmd_int2status(ret);
    default:
        return RZ_CMD_STATUS_WRONG_ARGS;
    }
}

References argv, duplicate_flag_t::ret, RZ_CMD_STATUS_WRONG_ARGS, rz_core_cmdf(), and rz_str_startswith().

Referenced by rzshell_cmddescs_init().

rz_push_escaped_handler()

RZ_IPI RzCmdStatus rz_push_escaped_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 903 of file cmd.c.

                                                                                      {
    char *input = rz_str_array_join(argv + 1, argc - 1, " ");
    int len = rz_str_unescape(input);
    RzCmdStatus res = bool2status(rz_cons_readpush(input, len));
    free(input);
    return res;
}

References argv, bool2status(), free(), input(), len, rz_cons_readpush(), rz_str_array_join(), and rz_str_unescape().

Referenced by rzshell_cmddescs_init().

rz_save_panels_layout()

RZ_API void rz_save_panels_layout	(	RzCore *	core,
		const char *	_name
	)

Definition at line 5270 of file panels.c.

                                                                   {
    int i;
    if (!core->panels) {
        return;
    }
    const char *name = oname;
    if (RZ_STR_ISEMPTY(name)) {
        name = __show_status_input(core, "Name for the layout: ");
        if (RZ_STR_ISEMPTY(name)) {
            (void)__show_status(core, "Name can't be empty!");
            return;
        }
    }
    char *config_path = __create_panels_config_path(name);
    RzPanels *panels = core->panels;
    PJ *pj = pj_new();
    pj_a(pj);
    for (i = 0; i < panels->n_panels; i++) {
        RzPanel *panel = __get_panel(panels, i);
        pj_o(pj);
        pj_ks(pj, "title", panel->model->title);
        pj_ks(pj, "cmd", panel->model->cmd);
        pj_kn(pj, "x", panel->view->pos.x);
        pj_kn(pj, "y", panel->view->pos.y);
        pj_kn(pj, "w", panel->view->pos.w);
        pj_kn(pj, "h", panel->view->pos.h);
        pj_end(pj);
    }
    pj_end(pj);
    FILE *fd = rz_sys_fopen(config_path, "w");
    if (fd) {
        char *pjs = pj_drain(pj);
        fprintf(fd, "%s\n", pjs);
        free(pjs);
        fclose(fd);
        __update_menu(core, "File.Load Layout.Saved", __init_menu_saved_layout);
        (void)__show_status(core, "Panels layout saved!");
    }
    free(config_path);
}

References __create_panels_config_path(), __get_panel(), __init_menu_saved_layout(), __show_status(), __show_status_input(), __update_menu(), rz_panel_model_t::cmd, config_path(), fd, benchmark::FILE, free(), rz_panel_pos_t::h, i, rz_panel_t::model, rz_panels_t::n_panels, rz_core_t::panels, pj_a(), pj_drain(), pj_end(), pj_kn(), pj_ks(), pj_new(), pj_o(), rz_panel_view_t::pos, RZ_STR_ISEMPTY, rz_sys_fopen(), rz_panel_model_t::title, rz_panel_t::view, rz_panel_pos_t::w, rz_panel_pos_t::x, and rz_panel_pos_t::y.

Referenced by __save_layout_cb(), and rz_cmd_panels().

set_tmp_arch()

static bool set_tmp_arch ( RzCore *  core, char *  arch, char **  tmparch  )

static

Definition at line 1385 of file cmd.c.

                                                                   {
    rz_return_val_if_fail(tmparch, false);
    *tmparch = strdup(rz_config_get(core->config, "asm.arch"));
    rz_config_set(core->config, "asm.arch", arch);
    core->fixedarch = true;
    return true;
}

References arch, rz_core_t::config, rz_core_t::fixedarch, rz_config_get(), rz_config_set(), rz_return_val_if_fail, and strdup().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and rz_core_cmd_subst_i().

set_tmp_bits()

static bool set_tmp_bits ( RzCore *  core, int  bits, char **  tmpbits, int *  cmd_ignbithints  )

static

Definition at line 1393 of file cmd.c.

                                                                                       {
    rz_return_val_if_fail(tmpbits, false);
    *tmpbits = strdup(rz_config_get(core->config, "asm.bits"));
    rz_config_set_i(core->config, "asm.bits", bits);
    core->fixedbits = true;
    // XXX: why?
    *cmd_ignbithints = rz_config_get_i(core->config, "analysis.ignbithints");
    rz_config_set_i(core->config, "analysis.ignbithints", 1);
    return true;
}

References bits(), rz_core_t::config, rz_core_t::fixedbits, rz_config_get(), rz_config_get_i(), rz_config_set_i(), rz_return_val_if_fail, and strdup().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and rz_core_cmd_subst_i().

substitute_args()

static bool substitute_args ( struct tsr2cmd_state *  state, TSNode  args, TSNode *  new_command  )

static

Definition at line 3577 of file cmd.c.

                                                                                           {
    RzList *edits = rz_list_newf((RzListFree)free_tsr2cmd_edit);
 
    if (is_handled_args(args)) {
        handle_substitution_args(state, args, edits);
    }
 
    bool res = substitute_args_do(state, edits, new_command);
    rz_list_free(edits);
    return res;
}

References args, free_tsr2cmd_edit(), handle_substitution_args(), is_handled_args(), rz_list_free(), rz_list_newf(), and substitute_args_do().

Referenced by ts_node_handle_arg_prargs().

substitute_args_do()

static bool substitute_args_do ( struct tsr2cmd_state *  state, RzList *  edits, TSNode *  new_command  )

static

Definition at line 3561 of file cmd.c.

                                                                                                {
    TSTree *new_tree = apply_edits(state, edits);
    if (!new_tree) {
        return false;
    }
 
    TSNode root = ts_tree_root_node(new_tree);
    if (ts_node_has_error(root)) {
        ts_tree_delete(new_tree);
        return false;
    }
    *new_command = ts_node_named_child(root, 0);
    state->tree = new_tree;
    return true;
}

References apply_edits(), root, ts_node_has_error(), ts_node_named_child(), ts_tree_delete(), and ts_tree_root_node().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and substitute_args().

substitute_args_fini()

static void substitute_args_fini ( struct tsr2cmd_state *  state )

static

Definition at line 3538 of file cmd.c.

                                                              {
    TSTree *saved_tree = rz_pvector_pop(&state->saved_tree);
    if (state->tree != saved_tree) {
        ts_tree_delete(state->tree);
    }
    state->tree = saved_tree;
 
    char *saved_input = rz_pvector_pop(&state->saved_input);
    if (state->input != saved_input) {
        free(state->input);
    }
    state->input = saved_input;
}

References free(), rz_pvector_pop(), and ts_tree_delete().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and ts_node_handle_arg_prargs().

substitute_args_init()

static void substitute_args_init ( struct tsr2cmd_state *  state, TSNode  command  )

static

Definition at line 3552 of file cmd.c.

                                                                              {
    rz_pvector_push(&state->saved_input, state->input);
    rz_pvector_push(&state->saved_tree, state->tree);
 
    state->substitute_cmd = command;
    state->input = ts_node_sub_string(state->substitute_cmd, state->input);
    RZ_LOG_DEBUG("Shrinking input to '%s'\n", state->input);
}

References command, RZ_LOG_DEBUG, rz_pvector_push(), and ts_node_sub_string().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), and ts_node_handle_arg_prargs().

system_exec_stdin()

static char* system_exec_stdin ( bool  is_pipe, int  argc, char **  argv, const ut8 *  input, int  input_len, int *  length  )

static

Definition at line 3228 of file cmd.c.

                                                                                                                  {
    char *output = NULL;
    if (!rz_subprocess_init()) {
        RZ_LOG_ERROR("Cannot initialize subprocess.\n");
        return NULL;
    }
 
    RzSubprocessOpt opt = {
        .file = argv[0],
        .args = (const char **)&argv[1],
        .args_size = argc - 1,
        .envvars = NULL,
        .envvals = NULL,
        .env_size = 0,
        .stdin_pipe = RZ_SUBPROCESS_PIPE_CREATE,
        .stdout_pipe = is_pipe ? RZ_SUBPROCESS_PIPE_CREATE : RZ_SUBPROCESS_PIPE_NONE,
        .stderr_pipe = is_pipe ? RZ_SUBPROCESS_PIPE_STDOUT : RZ_SUBPROCESS_PIPE_NONE,
    };
 
    RzSubprocess *proc = rz_subprocess_start_opt(&opt);
    if (!proc) {
        RZ_LOG_ERROR("Cannot start subprocess.\n");
        rz_subprocess_fini();
        return NULL;
    }
 
    rz_subprocess_stdin_write(proc, input, input_len);
    rz_subprocess_wait(proc, UT64_MAX);
 
    output = (char *)rz_subprocess_out(proc, length);
    rz_subprocess_free(proc);
    rz_subprocess_fini();
 
    return output;
}

References argv, rz_subprocess_opt_t::file, input(), length, NULL, output, proc, RZ_LOG_ERROR, rz_subprocess_fini(), rz_subprocess_free(), rz_subprocess_init(), rz_subprocess_out(), RZ_SUBPROCESS_PIPE_CREATE, RZ_SUBPROCESS_PIPE_NONE, RZ_SUBPROCESS_PIPE_STDOUT, rz_subprocess_start_opt(), rz_subprocess_stdin_write(), rz_subprocess_wait(), stdin_pipe, stdout_pipe, and UT64_MAX.

Referenced by core_cmd_pipe().

tmpenvs_free()

static void tmpenvs_free ( void *  item )

static

Definition at line 1380 of file cmd.c.

                                     {
    rz_sys_setenv(item, NULL);
    free(item);
}

References free(), NULL, and rz_sys_setenv().

Referenced by rz_core_cmd_subst_i().

tree_sitter_rzcmd()

TSLanguage* tree_sitter_rzcmd

(

)

Definition at line 28912 of file parser.c.

                                                 {
  static const TSLanguage language = {
    .version = LANGUAGE_VERSION,
    .symbol_count = SYMBOL_COUNT,
    .alias_count = ALIAS_COUNT,
    .token_count = TOKEN_COUNT,
    .external_token_count = EXTERNAL_TOKEN_COUNT,
    .state_count = STATE_COUNT,
    .large_state_count = LARGE_STATE_COUNT,
    .production_id_count = PRODUCTION_ID_COUNT,
    .field_count = FIELD_COUNT,
    .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH,
    .parse_table = &ts_parse_table[0][0],
    .small_parse_table = ts_small_parse_table,
    .small_parse_table_map = ts_small_parse_table_map,
    .parse_actions = ts_parse_actions,
    .symbol_names = ts_symbol_names,
    .field_names = ts_field_names,
    .field_map_slices = ts_field_map_slices,
    .field_map_entries = ts_field_map_entries,
    .symbol_metadata = ts_symbol_metadata,
    .public_symbol_map = ts_symbol_map,
    .alias_map = ts_non_terminal_alias_map,
    .alias_sequences = &ts_alias_sequences[0][0],
    .lex_modes = ts_lex_modes,
    .lex_fn = ts_lex,
    .external_scanner = {
      &ts_external_scanner_states[0][0],
      ts_external_scanner_symbol_map,
      tree_sitter_rzcmd_external_scanner_create,
      tree_sitter_rzcmd_external_scanner_destroy,
      tree_sitter_rzcmd_external_scanner_scan,
      tree_sitter_rzcmd_external_scanner_serialize,
      tree_sitter_rzcmd_external_scanner_deserialize,
    },
  };
  return &language;
}

References ALIAS_COUNT, EXTERNAL_TOKEN_COUNT, FIELD_COUNT, LANGUAGE_VERSION, LARGE_STATE_COUNT, MAX_ALIAS_SEQUENCE_LENGTH, PRODUCTION_ID_COUNT, STATE_COUNT, SYMBOL_COUNT, TOKEN_COUNT, tree_sitter_rzcmd_external_scanner_create(), tree_sitter_rzcmd_external_scanner_deserialize(), tree_sitter_rzcmd_external_scanner_destroy(), tree_sitter_rzcmd_external_scanner_scan(), tree_sitter_rzcmd_external_scanner_serialize(), ts_alias_sequences, ts_external_scanner_states, ts_external_scanner_symbol_map, ts_field_map_entries, ts_field_map_slices, ts_field_names, ts_lex(), ts_lex_modes, ts_non_terminal_alias_map, ts_parse_actions, ts_parse_table, ts_small_parse_table, ts_small_parse_table_map, ts_symbol_map, ts_symbol_metadata, ts_symbol_names, and TSLanguage::version.

Referenced by rz_core_cmd_new().

ts_node_handle_arg()

static char* ts_node_handle_arg ( struct tsr2cmd_state *  state, TSNode  command, TSNode  arg, uint32_t  child_idx  )

static

Definition at line 3610 of file cmd.c.

                                                                                                             {
    RzCmdParsedArgs *a = ts_node_handle_arg_prargs(state, command, arg, child_idx, true);
    char *str = rz_cmd_parsed_args_argstr(a);
    rz_cmd_parsed_args_free(a);
    return str;
}

References a, command, rz_cmd_parsed_args_argstr(), rz_cmd_parsed_args_free(), cmd_descs_generate::str, and ts_node_handle_arg_prargs().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL().

ts_node_handle_arg_prargs()

static RzCmdParsedArgs* ts_node_handle_arg_prargs ( struct tsr2cmd_state *  state, TSNode  command, TSNode  arg, uint32_t  child_idx, bool  do_unwrap  )

static

Definition at line 3589 of file cmd.c.

                                                                                                                                               {
    RzCmdParsedArgs *res = NULL;
    TSNode new_command;
    substitute_args_init(state, command);
    bool ok = substitute_args(state, arg, &new_command);
    if (!ok) {
        RZ_LOG_ERROR("Error while substituting arguments\n");
        goto err;
    }
 
    arg = ts_node_named_child(new_command, child_idx);
    res = parse_args(state, arg, do_unwrap);
    if (res == NULL) {
        RZ_LOG_ERROR("Cannot parse arg\n");
        goto err;
    }
err:
    substitute_args_fini(state);
    return res;
}

References command, err, NULL, ok, parse_args(), RZ_LOG_ERROR, substitute_args(), substitute_args_fini(), substitute_args_init(), and ts_node_named_child().

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

ts_node_sub_parent_string()

static char* ts_node_sub_parent_string ( TSNode  parent, TSNode  node, const char *  cstr  )

static

Definition at line 3183 of file cmd.c.

                                                                                     {
    ut32 start, end;
    TS_START_END(node, start, end);
    ut32 parent_start = ts_node_start_byte(parent);
    start -= parent_start;
    end -= parent_start;
    return rz_str_newf("%.*s", end - start, cstr + start);
}

References test_evm::end, rz_str_newf(), start, ts_node_start_byte(), and TS_START_END.

Referenced by create_cmd_edit(), and do_handle_substitution_cmd().

ts_node_sub_string()

static char* ts_node_sub_string ( TSNode  node, const char *  cstr  )

static

Definition at line 3177 of file cmd.c.

                                                               {
    ut32 start, end;
    TS_START_END(node, start, end);
    return rz_str_newf("%.*s", end - start, cstr + start);
}

References test_evm::end, rz_str_newf(), start, and TS_START_END.

Referenced by DEFINE_HANDLE_TS_FCN(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), do_handle_ts_unescape_arg(), handle_ts_stmt(), and substitute_args_init().

Variable Documentation

help_msg_dollar

const char* help_msg_dollar[]

static

Initial value:

= {
    "Usage:", "$alias[=cmd] [args...]", "Alias commands and strings (See ?$? for help on $variables)",
    "$", "", "list all defined aliases",
    "$*", "", "list all the aliases as rizin commands in base64",
    "$**", "", "same as above, but using plain text",
    "$", "foo:=123", "alias for 'f foo=123'",
    "$", "foo-=4", "alias for 'f foo-=4'",
    "$", "foo+=4", "alias for 'f foo+=4'",
    "$", "foo", "alias for 's foo' (note that command aliases can override flag resolution)",
    "$", "dis=base64:AAA==", "alias this base64 encoded text to be printed when $dis is called",
    "$", "dis=$hello world", "alias this text to be printed when $dis is called",
    "$", "dis=-", "open cfg.editor to set the new value for dis alias",
    "$", "dis=af;pdf", "create command - analyze to show function",
    "$", "test=#!pipe node /tmp/test.js", "create command - rlangpipe script",
    "$", "dis=", "undefine alias",
    "$", "dis", "execute the previously defined alias",
    "$", "dis?", "show commands aliased by $dis",
    "$", "dis?n", "show commands aliased by $dis, without a new line",
    NULL
}

Definition at line 84 of file cmd.c.

Referenced by rz_cmd_alias().

help_msg_k

const char* help_msg_k[]

static

Definition at line 105 of file cmd.c.

Referenced by rz_cmd_kuery().

help_msg_v

const char* help_msg_v[]

static

Initial value:

= {
    "Usage:", "v[*i]", "",
    "v", "", "open visual panels",
    "v", " test", "load saved layout with name test",
    "v=", " test", "save current layout with name test",
    "vi", " test", "open the file test in 'cfg.editor'",
    NULL
}

Definition at line 154 of file cmd.c.

Referenced by rz_cmd_panels().

help_msg_vertical_bar

const char* help_msg_vertical_bar[]

static

Initial value:

= {
    "Usage:", "[cmd] | [program|H|T|.|]", "",
    "", "[cmd] |?", "show this help",
    "", "[cmd] |", "disable scr.html and scr.color",
    "", "[cmd] |H", "enable scr.html, respect scr.color",
    "", "[cmd] | [program]", "pipe output of command to program",
    "", "[cmd] |.", "alias for .[cmd]",
    NULL
}

Definition at line 144 of file cmd.c.

Referenced by rz_core_cmd_subst_i().

map_ts_stmt_handlers

struct ts_data_symbol_map map_ts_stmt_handlers[]

Initial value:

= {
    { NULL, NULL },
}

Definition at line 5138 of file cmd.c.

Referenced by rz_core_cmd_new().

map_ts_symbols

struct ts_data_symbol_map map_ts_symbols[]

Initial value:

= {
    { NULL, NULL },
}

Definition at line 5138 of file cmd.c.

Referenced by rz_core_cmd_new().