rz-bindgen/doxygen/rz__core_8h_source.html

 // SPDX-FileCopyrightText: 2009-2021 pancake <pancake@nopcode.org>

 // SPDX-License-Identifier: LGPL-3.0-only


 #ifndef RZ_CORE_H

 #define RZ_CORE_H


 #include <rz_main.h>

 #include <rz_types.h>

 #include <rz_magic.h>

 #include <rz_agraph.h>

 #include <rz_io.h>

 #include <rz_lib.h>

 #include <rz_diff.h>

 #include <rz_egg.h>

 #include <rz_lang.h>

 #include <rz_asm.h>

 #include <rz_parse.h>

 #include <rz_analysis.h>

 #include <rz_cmd.h>

 #include <rz_cons.h>

 #include <rz_search.h>

 #include <rz_sign.h>

 #include <rz_debug.h>

 #include <rz_flag.h>

 #include <rz_config.h>

 #include <rz_bin.h>

 #include <rz_hash.h>

 #include <rz_util.h>

 #include <ht_uu.h>

 #include <rz_util/rz_print.h>

 #include <rz_crypto.h>

 #include <rz_bind.h>

 #include <rz_util/rz_annotated_code.h>

 #include <rz_heap_glibc.h>

 #include <rz_windows_heap.h>


 #ifdef __cplusplus

 extern "C" {

 #endif

 RZ_LIB_VERSION_HEADER(rz_core);


 #define RZ_CORE_CMD_OK      0

 #define RZ_CORE_CMD_INVALID -1

 #define RZ_CORE_CMD_EXIT    -2


 #define RZ_CORE_BLOCKSIZE     0x100

 #define RZ_CORE_BLOCKSIZE_MAX 0x3200000 /* 32MB */


 #define RZ_CORE_ANALYSIS_GRAPHLINES         1

 #define RZ_CORE_ANALYSIS_GRAPHBODY          2

 #define RZ_CORE_ANALYSIS_GRAPHDIFF          4

 #define RZ_CORE_ANALYSIS_JSON               8

 #define RZ_CORE_ANALYSIS_KEYVALUE           16

 #define RZ_CORE_ANALYSIS_JSON_FORMAT_DISASM 32

 #define RZ_CORE_ANALYSIS_STAR               64


 #define RZ_FLAGS_FS_CLASSES                 "classes"

 #define RZ_FLAGS_FS_FUNCTIONS               "functions"

 #define RZ_FLAGS_FS_IMPORTS                 "imports"

 #define RZ_FLAGS_FS_RELOCS                  "relocs"

 #define RZ_FLAGS_FS_REGISTERS               "registers"

 #define RZ_FLAGS_FS_RESOURCES               "resources"

 #define RZ_FLAGS_FS_SECTIONS                "sections"

 #define RZ_FLAGS_FS_SEGMENTS                "segments"

 #define RZ_FLAGS_FS_SIGNS                   "sign"

 #define RZ_FLAGS_FS_STRINGS                 "strings"

 #define RZ_FLAGS_FS_SYMBOLS                 "symbols"

 #define RZ_FLAGS_FS_SYMBOLS_SECTIONS        "symbols.sections"

 #define RZ_FLAGS_FS_SYSCALLS                "syscalls"

 #define RZ_FLAGS_FS_MMIO_REGISTERS          "registers.mmio"

 #define RZ_FLAGS_FS_MMIO_REGISTERS_EXTENDED "registers.extended"

 #define RZ_FLAGS_FS_PLATFORM_PORTS          "platform.ports"

 #define RZ_FLAGS_FS_GLOBALS                 "globals"

 #define RZ_FLAGS_FS_DEBUG_MAPS              "maps"


 #define RZ_GRAPH_FORMAT_NO     0

 #define RZ_GRAPH_FORMAT_GMLFCN 1

 #define RZ_GRAPH_FORMAT_JSON   2

 #define RZ_GRAPH_FORMAT_GML    3

 #define RZ_GRAPH_FORMAT_DOT    4

 #define RZ_GRAPH_FORMAT_CMD    5


 #define RZ_CONS_COLOR_DEF(x, def) ((core->cons && core->cons->context->pal.x) ? core->cons->context->pal.x : def)

 #define RZ_CONS_COLOR(x)          RZ_CONS_COLOR_DEF(x, "")


 /* rtr */

 #define RTR_PROTOCOL_RAP  0

 #define RTR_PROTOCOL_TCP  1

 #define RTR_PROTOCOL_UDP  2

 #define RTR_PROTOCOL_HTTP 3

 #define RTR_PROTOCOL_UNIX 4


 #define RTR_MAX_HOSTS 255


 /* visual mode */

 typedef enum {

     RZ_CORE_VISUAL_MODE_PX = 0,

     RZ_CORE_VISUAL_MODE_PD = 1,

     RZ_CORE_VISUAL_MODE_DB = 2,

     RZ_CORE_VISUAL_MODE_OV = 3,

     RZ_CORE_VISUAL_MODE_CD = 4

 } RzCoreVisualMode;


 typedef enum {

     RZ_CORE_WRITE_OP_BYTESWAP2,

     RZ_CORE_WRITE_OP_BYTESWAP4,

     RZ_CORE_WRITE_OP_BYTESWAP8,

     RZ_CORE_WRITE_OP_ADD,

     RZ_CORE_WRITE_OP_SUB,

     RZ_CORE_WRITE_OP_DIV,

     RZ_CORE_WRITE_OP_MUL,

     RZ_CORE_WRITE_OP_AND,

     RZ_CORE_WRITE_OP_OR,

     RZ_CORE_WRITE_OP_XOR,

     RZ_CORE_WRITE_OP_SHIFT_LEFT,

     RZ_CORE_WRITE_OP_SHIFT_RIGHT,

 } RzCoreWriteOp;


 typedef bool (*RzCorePluginInit)(RzCore *core);

 typedef bool (*RzCorePluginFini)(RzCore *core);


 typedef struct rz_core_plugin_t {

     const char *name;

     const char *desc;

     const char *license;

     const char *author;

     const char *version;

     RzCorePluginInit init;

     RzCorePluginFini fini;

 } RzCorePlugin;


 typedef struct rz_core_rtr_host_t RzCoreRtrHost;


 typedef enum {

     AUTOCOMPLETE_DEFAULT,

     AUTOCOMPLETE_MS

 } RAutocompleteType;


 typedef struct rz_core_seek_undo_t {

     ut64 offset;

     int cursor;

     bool is_current;

     int idx;

 } RzCoreSeekItem;


 typedef struct rz_core_file_t {

     struct rz_core_t *core;

     int dbg;

     int fd;

     RzPVector /*<RzBinFile *>*/ binfiles;

     RzPVector /*<RzIODesc *>*/ extra_files;

     RzPVector /*<RzIOMap *>*/ maps;

 } RzCoreFile;


 typedef struct rz_core_io_map_info_t {

     RzCoreFile *cf;


     int perm_orig;

 } RzCoreIOMapInfo;


 typedef struct rz_core_times_t {

     ut64 loadlibs_init_time;

     ut64 loadlibs_time;

     ut64 file_open_time;

 } RzCoreTimes;


 #define RZ_CORE_ASMQJMPS_NUM         10

 #define RZ_CORE_ASMQJMPS_LETTERS     26

 #define RZ_CORE_ASMQJMPS_MAX_LETTERS (26 * 26 * 26 * 26 * 26)

 #define RZ_CORE_ASMQJMPS_LEN_LETTERS 5


 typedef enum rz_core_autocomplete_types_t {

     RZ_CORE_AUTOCMPLT_DFLT = 0,

     RZ_CORE_AUTOCMPLT_FLAG,

     RZ_CORE_AUTOCMPLT_FLSP,

     RZ_CORE_AUTOCMPLT_SEEK,

     RZ_CORE_AUTOCMPLT_FCN,

     RZ_CORE_AUTOCMPLT_EVAL,

     RZ_CORE_AUTOCMPLT_MINS,

     RZ_CORE_AUTOCMPLT_BRKP,

     RZ_CORE_AUTOCMPLT_MACR,

     RZ_CORE_AUTOCMPLT_FILE,

     RZ_CORE_AUTOCMPLT_THME,

     RZ_CORE_AUTOCMPLT_OPTN,

     RZ_CORE_AUTOCMPLT_MS,

     RZ_CORE_AUTOCMPLT_SDB,

     // --- left as last always

     RZ_CORE_AUTOCMPLT_END,

 } RzCoreAutocompleteType;


 typedef struct rz_core_autocomplete_t {

     const char *cmd;

     int length;

     int n_subcmds;

     bool locked;

     int type;

     struct rz_core_autocomplete_t **subcmds;

 } RzCoreAutocomplete;


 typedef struct rz_core_visual_tab_t {

     int printidx;

     ut64 offset;

     bool cur_enabled;

     int cur;

     int ocur;

     int cols;

     int disMode;

     int hexMode;

     int asm_offset;

     int asm_instr;

     int asm_indent;

     int asm_bytes;

     int asm_cmt_col;

     int printMode;

     int current3format;

     int current4format;

     int current5format;

     int dumpCols;

     char name[32]; // XXX leak because no  rz_core_visual_tab_free

     // TODO: cursor and such

 } RzCoreVisualTab;

 // #define RzCoreVisualTab Tab


 typedef struct rz_core_visual_t {

     RzList *tabs;

     int tab;

 } RzCoreVisual;

 // #define RzCoreVisual Visual


 typedef struct {

     int x;

     int y;

     int w;

     int h;

     char *cmd;

 } RzCoreGadget;


 typedef struct rz_core_task_t RzCoreTask;


 typedef void (*RzCoreTaskContextSwitch)(RzCoreTask *next, void *user);


 typedef void (*RzCoreTaskBreak)(RzCoreTask *task, void *user);


 typedef struct rz_core_tasks_t {

     RzCoreTaskContextSwitch ctx_switch;

     void *ctx_switch_user;

     RzCoreTaskBreak break_cb;

     void *break_cb_user;

     int task_id_next;

     RzList *tasks;

     RzList *tasks_queue;

     RzList *oneshot_queue;

     int oneshots_enqueued;

     struct rz_core_task_t *current_task;

     struct rz_core_task_t *main_task;

     RzThreadLock *lock;

     int tasks_running;

     bool oneshot_running;

 } RzCoreTaskScheduler;


 typedef struct rz_core_seek_history_t {

     RzVector undos;

     RzVector redos;

     bool saved_set;

     RzCoreSeekItem saved_item;

 } RzCoreSeekHistory;


 struct rz_core_t {

     RzBin *bin;

     RzList /*<RzCorePlugin *>*/ *plugins;

     RzConfig *config;

     ut64 offset; // current seek

     ut64 prompt_offset; // temporarily set to offset to have $$ in expressions always stay the same during temp seeks

     ut32 blocksize;

     ut32 blocksize_max;

     ut8 *block;

     RzBuffer *yank_buf;

     ut64 yank_addr;

     bool tmpseek;

     bool vmode;

     int interrupted; // XXX IS THIS DUPPED SOMEWHERE?

     /* files */

     RzCons *cons;

     RzIO *io;

     RzCoreFile *file;

     RzList /*<RzCoreFile *>*/ *files;

     RzNum *num;

     ut64 rc; // command's return code .. related to num->value;

     RzLib *lib;

     RzCmd *rcmd;

     RzCmdDescriptor root_cmd_descriptor;

     RzList /*<RzCmdDescriptor *>*/ *cmd_descriptors;

     RzAnalysis *analysis;

     RzAsm *rasm;

     /* ^^ */

     RzCoreTimes *times;

     RzParse *parser;

     RzPrint *print;

     RzLang *lang;

     RzDebug *dbg;

     RzFlag *flags;

     RzSearch *search;

     RzEgg *egg;

     RzAGraph *graph;

     RzPanelsRoot *panels_root;

     RzPanels *panels;

     char *cmdqueue;

     char *lastcmd;

     bool is_lastcmd;

     bool is_pipe;

     char *cmdlog;

     int cmdrepeat; // cmd.repeat

     const char *cmdtimes; // cmd.times

     RZ_DEPRECATE bool cmd_in_backticks; // whether currently executing a cmd out of backticks

     int rtr_n;

     RzCoreRtrHost *rtr_host; // array of RzCoreRtrHost

     ut64 *asmqjmps;

     int asmqjmps_count;

     int asmqjmps_size;

     bool is_asmqjmps_letter;

     bool keep_asmqjmps;

     RzCoreVisual visual;

     // visual // TODO: move them into RzCoreVisual

     bool visual_is_inputing; // whether the user is inputing

     char *visual_inputing; // for filter on the go in Vv mode

     int http_up;

     int gdbserver_up;

     RzCoreVisualMode printidx;

     char *stkcmd;

     bool in_search;

     RzList /*<RzCoreCmpWatcher *>*/ *watchers;

     RzList /*<char *>*/ *scriptstack;

     RzCoreTaskScheduler tasks;

     int max_cmd_depth;

     ut8 switch_file_view;

     Sdb *sdb;

     int incomment;

     int curtab; // current tab

     int seltab; // selected tab

     char *cmdremote;

     char *lastsearch;

     char *cmdfilter;

     char *curtheme;

     bool break_loop;

     bool binat;

     bool fixedbits; // will be true when using @b:

     bool fixedarch; // will be true when using @a:

     bool fixedblock;

     char *table_query;

     struct rz_core_t *c2;

     RzCoreAutocomplete *autocomplete;

     int autocomplete_type;

     int maxtab;

     RzEvent *ev;

     RzList /*<RzCoreGadget *>*/ *gadgets;

     bool scr_gadgets;

     bool log_events; // core.c:cb_event_handler : log actions from events if cfg.log.events is set

     RzList /*<char *>*/ *ropchain;

     RzCoreSeekHistory seek_history;

     RzHash *hash;


     bool marks_init;

     ut64 marks[UT8_MAX + 1];


     RzMainCallback rz_main_rizin;

     // int (*rz_main_rizin)(int argc, char **argv);

     int (*rz_main_rz_find)(int argc, const char **argv);

     int (*rz_main_rz_diff)(int argc, const char **argv);

     int (*rz_main_rz_bin)(int argc, const char **argv);

     int (*rz_main_rz_run)(int argc, const char **argv);

     int (*rz_main_rz_gg)(int argc, const char **argv);

     int (*rz_main_rz_asm)(int argc, const char **argv);

     int (*rz_main_rz_ax)(int argc, const char **argv);

 };


 // maybe move into RzAnalysis

 typedef struct rz_core_item_t {

     const char *type;

     ut64 addr;

     ut64 next;

     ut64 prev;

     int size;

     int perm;

     char *data;

     char *comment;

     char *sectname;

     char *fcnname;

 } RzCoreItem;


 typedef int (*RzCoreSearchCallback)(RzCore *core, ut64 from, ut8 *buf, int len);


 typedef struct rz_bin_sym_names_t {

     const char *pfx;

     char *name;

     char *symbolname;

     char *libname;

     char *nameflag;

     char *demname;

     char *demflag;

     char *classname;

     char *classflag;

     char *methname;

     char *methflag;

 } RzBinSymNames;


 typedef struct rz_analysis_disasm_text_t {

     ut64 offset;

     ut64 arrow;

     char *text;

 } RzAnalysisDisasmText;


 #ifdef RZ_API

 RZ_API int rz_core_bind(RzCore *core, RzCoreBind *bnd);


 RZ_API void rz_core_notify_begin(RZ_NONNULL RzCore *core, RZ_NONNULL const char *format, ...) RZ_PRINTF_CHECK(2, 3);

 RZ_API void rz_core_notify_done(RZ_NONNULL RzCore *core, RZ_NONNULL const char *format, ...) RZ_PRINTF_CHECK(2, 3);

 RZ_API void rz_core_notify_error(RZ_NONNULL RzCore *core, RZ_NONNULL const char *format, ...) RZ_PRINTF_CHECK(2, 3);


 RZ_API void rz_core_gadget_free(RzCoreGadget *g);

 RZ_API void rz_core_gadget_print(RzCore *core);


 RZ_API bool rz_core_plugin_init(RzCore *core);

 RZ_API bool rz_core_plugin_add(RzCore *core, RzCorePlugin *plugin);

 RZ_API bool rz_core_plugin_fini(RzCore *core);


 // #define rz_core_ncast(x) (RzCore*)(size_t)(x)

 RZ_API RZ_OWN RzList /*<char *>*/ *rz_core_theme_list(RZ_NONNULL RzCore *core);

 RZ_API char *rz_core_theme_get(RzCore *core);

 RZ_API bool rz_core_theme_load(RzCore *core, const char *name);

 RZ_API void rz_core_theme_nextpal(RzCore *core, RzConsPalSeekMode mode);

 RZ_API const char *rz_core_get_section_name(RzCore *core, ut64 addr);

 RZ_API RzCons *rz_core_get_cons(RzCore *core);

 RZ_API RzBin *rz_core_get_bin(RzCore *core);

 RZ_API RzConfig *rz_core_get_config(RzCore *core);

 RZ_API bool rz_core_init(RzCore *core);

 RZ_API void rz_core_bind_cons(RzCore *core); // to restore pointers in cons

 RZ_API RzCore *rz_core_new(void);

 RZ_API void rz_core_free(RzCore *core);

 RZ_API void rz_core_fini(RzCore *c);

 RZ_API void rz_core_wait(RzCore *core);

 RZ_API RzCore *rz_core_ncast(ut64 p);

 RZ_API RzCore *rz_core_cast(void *p);

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

 RZ_API int rz_core_config_init(RzCore *core);

 RZ_API void rz_core_config_print_all(RzConfig *cfg, const char *str, RzCmdStateOutput *state);

 RZ_API void rz_core_parse_rizinrc(RzCore *r);

 RZ_API RZ_OWN RzList /*<char *>*/ *rz_core_config_in_space(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *space);

 RZ_API int rz_core_prompt(RzCore *core, int sync);

 RZ_API int rz_core_prompt_exec(RzCore *core);

 RZ_API void rz_core_prompt_loop(RzCore *core);

 RZ_API ut64 rz_core_pava(RzCore *core, ut64 addr);

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

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

 RZ_API RZ_OWN char *rz_core_editor(const RzCore *core, RZ_NULLABLE const char *file, RZ_NULLABLE const char *str);

 RZ_API int rz_core_fgets(char *buf, int len, void *user);

 RZ_API RzFlagItem *rz_core_flag_get_by_spaces(RzFlag *f, ut64 off);

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

 RZ_API void rz_core_cmd_init(RzCore *core);

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

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

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

 RZ_API char *rz_core_cmd_strf(RzCore *core, const char *fmt, ...) RZ_PRINTF_CHECK(2, 3);

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

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

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

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

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

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

 RZ_API void rz_core_seek_item_free(RzCoreSeekItem *item);

 RZ_API bool rz_core_seek(RzCore *core, ut64 addr, bool rb);

 RZ_API bool rz_core_seek_and_save(RzCore *core, ut64 addr, bool rb);

 RZ_API bool rz_core_seek_opt(RzCore *core, ut64 addr, bool read_block, bool save);

 RZ_API bool rz_core_seek_mark(RzCore *core);

 RZ_API bool rz_core_seek_save(RzCore *core);

 RZ_API bool rz_core_seek_undo(RzCore *core);

 RZ_API bool rz_core_seek_redo(RzCore *core);

 RZ_API void rz_core_seek_reset(RzCore *core);

 RZ_API void rz_core_seek_free(RzCore *core);

 RZ_API RzList /*<RzCoreSeekItem *>*/ *rz_core_seek_list(RzCore *core);

 RZ_API RzCoreSeekItem *rz_core_seek_peek(RzCore *core, int idx);

 RZ_API int rz_core_seek_base(RzCore *core, const char *hex, bool save);

 RZ_API bool rz_core_seek_prev(RzCore *core, const char *type, bool save);

 RZ_API bool rz_core_seek_next(RzCore *core, const char *type, bool save);

 RZ_API bool rz_core_seek_align(RzCore *core, ut64 align, bool save);

 RZ_API bool rz_core_seek_delta(RzCore *core, st64 delta, bool save);

 RZ_API bool rz_core_seek_analysis_bb(RzCore *core, ut64 addr, bool save);

 RZ_API bool rz_core_visual_bit_editor(RzCore *core);

 RZ_API void rz_core_arch_bits_at(RzCore *core, ut64 addr, RZ_OUT RZ_NULLABLE int *bits, RZ_OUT RZ_BORROW RZ_NULLABLE const char **arch);

 RZ_API void rz_core_seek_arch_bits(RzCore *core, ut64 addr);

 RZ_API int rz_core_block_read(RzCore *core);

 RZ_API bool rz_core_block_size(RzCore *core, ut32 bsize);

 RZ_API int rz_core_is_valid_offset(RzCore *core, ut64 offset);

 RZ_API int rz_core_write_hexpair(RzCore *core, ut64 addr, const char *pairs);

 RZ_API int rz_core_write_assembly(RzCore *core, ut64 addr, RZ_NONNULL const char *instructions);

 RZ_API int rz_core_write_assembly_fill(RzCore *core, ut64 addr, RZ_NONNULL const char *instructions);

 RZ_API bool rz_core_write_block(RzCore *core, ut64 addr, ut8 *data, size_t len);

 RZ_API bool rz_core_write_seq_at(RzCore *core, ut64 addr, ut64 from, ut64 to, ut64 step, int value_size);

 RZ_API bool rz_core_shift_block(RzCore *core, ut64 addr, ut64 b_size, st64 dist);

 RZ_API void rz_core_autocomplete(RZ_NULLABLE RzCore *core, RzLineCompletion *completion, RzLineBuffer *buf, RzLinePromptType prompt_type);

 RZ_API RzLineNSCompletionResult *rz_core_autocomplete_rzshell(RzCore *core, RzLineBuffer *buf, RzLinePromptType prompt_type);

 RZ_API void rz_core_print_scrollbar(RzCore *core);

 RZ_API void rz_core_print_scrollbar_bottom(RzCore *core);

 RZ_API void rz_core_help_vars_print(RzCore *core);

 RZ_API void rz_core_visual_prompt_input(RzCore *core);

 RZ_API void rz_core_visual_toggle_hints(RzCore *core);

 RZ_API void rz_core_visual_toggle_decompiler_disasm(RzCore *core, bool for_graph, bool reset);

 RZ_API void rz_core_visual_applyDisMode(RzCore *core, int disMode);

 RZ_API void rz_core_visual_applyHexMode(RzCore *core, int hexMode);

 RZ_API int rz_core_visual_xrefs(RzCore *core, bool xref_to, bool fcnInsteadOfAddr);

 RZ_API void rz_core_visual_append_help(RzStrBuf *p, const char *title, const char **help);

 RZ_API bool rz_core_prevop_addr(RzCore *core, ut64 start_addr, int numinstrs, ut64 *prev_addr);

 RZ_API ut64 rz_core_prevop_addr_force(RzCore *core, ut64 start_addr, int numinstrs);

 RZ_API bool rz_core_visual_hudstuff(RzCore *core);

 RZ_API int rz_core_visual_classes(RzCore *core);

 RZ_API int rz_core_visual_analysis_classes(RzCore *core);

 RZ_API int rz_core_visual(RzCore *core, const char *input);

 RZ_API int rz_core_visual_graph(RzCore *core, RzAGraph *g, RzAnalysisFunction *_fcn, int is_interactive);

 RZ_API bool rz_core_visual_panels_root(RzCore *core, RzPanelsRoot *panels_root);

 RZ_API void rz_core_visual_browse(RzCore *core, const char *arg);

 RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg);

 RZ_API void rz_core_visual_seek_animation(RzCore *core, ut64 addr);

 RZ_API void rz_core_visual_seek_animation_redo(RzCore *core);

 RZ_API void rz_core_visual_seek_animation_undo(RzCore *core);

 RZ_API void rz_core_visual_asm(RzCore *core, ut64 addr);

 RZ_API void rz_core_visual_colors(RzCore *core);

 RZ_API void rz_core_visual_showcursor(RzCore *core, int x);

 RZ_API void rz_core_visual_offset(RzCore *core);

 RZ_API bool rz_core_visual_hud(RzCore *core);

 RZ_API void rz_core_visual_jump(RzCore *core, ut8 ch);

 RZ_API void rz_core_visual_disasm_up(RzCore *core, int *cols);

 RZ_API void rz_core_visual_disasm_down(RzCore *core, RzAsmOp *op, int *cols);

 RZ_API RzBinReloc *rz_core_getreloc(RzCore *core, ut64 addr, int size);

 RZ_API RzBinReloc *rz_core_get_reloc_to(RzCore *core, ut64 addr);

 RZ_API ut64 rz_core_get_asmqjmps(RzCore *core, const char *str);

 RZ_API void rz_core_set_asmqjmps(RzCore *core, char *str, size_t len, int i);

 RZ_API char *rz_core_add_asmqjmp(RzCore *core, ut64 addr);


 RZ_API void rz_core_analysis_type_init(RzCore *core);

 RZ_API char *rz_core_analysis_hasrefs_to_depth(RzCore *core, ut64 value, PJ *pj, int depth);

 RZ_API void rz_core_link_stroff(RzCore *core, RzAnalysisFunction *fcn);

 RZ_API bool cmd_analysis_objc(RzCore *core, bool auto_analysis);

 RZ_API void rz_core_analysis_cc_init(RzCore *core);

 RZ_API void rz_core_analysis_paths(RzCore *core, ut64 from, ut64 to, bool followCalls, int followDepth, bool is_json);

 RZ_API void rz_core_types_link(RzCore *core, const char *typestr, ut64 addr);

 RZ_API RZ_OWN char *rz_core_types_as_c(RZ_NONNULL RzCore *core, RZ_NONNULL const char *name, bool multiline);

 RZ_API RZ_OWN char *rz_core_types_as_c_all(RZ_NONNULL RzCore *core, bool multiline);


 RZ_API bool rz_core_analysis_esil_trace_start(RzCore *core);

 RZ_API bool rz_core_analysis_esil_trace_stop(RzCore *core);

 RZ_API void rz_analysis_bytes_free(RZ_NULLABLE void *ptr);

 RZ_API RZ_OWN RzPVector /*<RzAnalysisBytes *>*/ *rz_core_analysis_bytes(RZ_NONNULL RzCore *core, RZ_NONNULL const ut8 *buf, int len, int nops);


 RZ_API RzListInfo *rz_listinfo_new(const char *name, RzInterval pitv, RzInterval vitv, int perm, const char *extra);

 RZ_API void rz_listinfo_free(RzListInfo *info);

 /* visual marks */

 RZ_API void rz_core_visual_mark_seek(RzCore *core, ut8 ch);

 RZ_API void rz_core_visual_mark(RzCore *core, ut8 ch);

 RZ_API void rz_core_visual_mark_set(RzCore *core, ut8 ch, ut64 addr);

 RZ_API void rz_core_visual_mark_del(RzCore *core, ut8 ch);

 RZ_API bool rz_core_visual_mark_dump(RzCore *core);

 RZ_API void rz_core_visual_mark_reset(RzCore *core);


 RZ_API int rz_core_search_cb(RzCore *core, ut64 from, ut64 to, RzCoreSearchCallback cb);

 RZ_API bool rz_core_serve(RzCore *core, RzIODesc *fd);

 RZ_API bool rz_core_file_reopen(RzCore *core, const char *args, int perm, int binload);

 RZ_API void rz_core_file_reopen_debug(RzCore *core, const char *args);

 RZ_API void rz_core_file_reopen_remote_debug(RzCore *core, const char *uri, ut64 addr);

 RZ_API bool rz_core_file_resize(RzCore *core, ut64 newsize);

 RZ_API bool rz_core_file_resize_delta(RzCore *core, st64 delta);

 RZ_API RzCoreFile *rz_core_file_find_by_fd(RzCore *core, ut64 fd);

 RZ_API RzCoreFile *rz_core_file_find_by_name(RzCore *core, const char *name);

 RZ_API RzCoreFile *rz_core_file_cur(RzCore *r);

 RZ_API int rz_core_file_set_by_fd(RzCore *core, ut64 fd);

 RZ_API int rz_core_file_set_by_name(RzCore *core, const char *name);

 RZ_API int rz_core_file_set_by_file(RzCore *core, RzCoreFile *cf);

 RZ_API int rz_core_setup_debugger(RzCore *r, const char *debugbackend, bool attach);


 RZ_API bool rz_core_file_open_load(RZ_NONNULL RzCore *core, RZ_NONNULL const char *filepath, ut64 addr, int perms, bool write_mode);

 RZ_API RZ_BORROW RzCoreFile *rz_core_file_open(RZ_NONNULL RzCore *core, RZ_NONNULL const char *file, int flags, ut64 loadaddr);

 RZ_API RZ_BORROW RzCoreFile *rz_core_file_open_many(RZ_NONNULL RzCore *r, RZ_NULLABLE const char *file, int perm, ut64 loadaddr);

 RZ_API RzCoreFile *rz_core_file_get_by_fd(RzCore *core, int fd);

 RZ_API void rz_core_file_close(RzCoreFile *fh);

 RZ_API bool rz_core_file_close_fd(RzCore *core, int fd);

 RZ_API bool rz_core_file_close_all_but(RzCore *core);

 RZ_API bool rz_core_raw_file_print(RzCore *core);

 RZ_API bool rz_core_file_print(RzCore *core, RzOutputMode mode);

 RZ_API int rz_core_file_binlist(RzCore *core);

 RZ_API bool rz_core_file_bin_raise(RzCore *core, ut32 num);

 RZ_API void rz_core_io_file_open(RZ_NONNULL RzCore *core, int fd);

 RZ_API void rz_core_io_file_reopen(RZ_NONNULL RzCore *core, int fd, int perms);

 RZ_API bool rz_core_extend_at(RzCore *core, ut64 addr, ut64 size);

 RZ_API bool rz_core_write_at(RzCore *core, ut64 addr, const ut8 *buf, int size);

 RZ_API bool rz_core_write_value_at(RzCore *core, ut64 addr, ut64 value, int sz);

 RZ_API bool rz_core_write_value_inc_at(RzCore *core, ut64 addr, st64 value, int sz);

 RZ_API bool rz_core_write_string_at(RzCore *core, ut64 addr, RZ_NONNULL const char *s);

 RZ_API bool rz_core_write_string_zero_at(RzCore *core, ut64 addr, const char *s);

 RZ_API bool rz_core_write_string_wide_at(RzCore *core, ut64 addr, const char *s);

 RZ_API bool rz_core_write_length_string_at(RzCore *core, ut64 addr, const char *s);

 RZ_API bool rz_core_write_base64d_at(RzCore *core, ut64 addr, RZ_NONNULL const char *s);

 RZ_API bool rz_core_write_base64_at(RzCore *core, ut64 addr, RZ_NONNULL const char *s);

 RZ_API bool rz_core_write_random_at(RzCore *core, ut64 addr, size_t len);

 RZ_API bool rz_core_write_block_op_at(RzCore *core, ut64 addr, RzCoreWriteOp op, ut8 *hex, int hexlen);

 RZ_API bool rz_core_write_duplicate_at(RzCore *core, ut64 addr, ut64 from, int len);

 RZ_API RZ_OWN ut8 *rz_core_transform_op(RzCore *core, ut64 addr, RzCoreWriteOp op, ut8 *hex, int hexlen, int *buflen);

 RZ_API ut32 rz_core_file_cur_fd(RzCore *core);

 RZ_API RzCmdStatus rz_core_io_cache_print(RzCore *core, RzCmdStateOutput *state);

 RZ_API RzCmdStatus rz_core_io_pcache_print(RzCore *core, RzIODesc *desc, RzCmdStateOutput *state);


 /* creg.c */

 RZ_API RzReg *rz_core_reg_default(RzCore *core);

 RZ_API ut64 rz_core_reg_getv_by_role_or_name(RzCore *core, const char *name);

 RZ_API bool rz_core_reg_set_by_role_or_name(RzCore *core, const char *name, ut64 num);

 RZ_API void rz_core_reg_update_flags(RzCore *core);


 /* cdebug.c */

 RZ_API bool rz_core_is_debug(RzCore *core);

 RZ_API bool rz_core_debug_step_one(RzCore *core, int times);

 RZ_API bool rz_core_debug_continue_until(RzCore *core, ut64 addr, ut64 to);

 RZ_API void rz_core_debug_bp_add_noreturn_func(RzCore *core);

 RZ_API void rz_core_debug_breakpoint_toggle(RZ_NONNULL RzCore *core, ut64 addr);


 RZ_API void rz_core_debug_ri(RzCore *core);

 RZ_API void rz_core_debug_set_register_flags(RzCore *core);

 RZ_API void rz_core_debug_clear_register_flags(RzCore *core);


 RZ_API bool rz_core_debug_process_close(RzCore *core);

 RZ_API bool rz_core_debug_step_until_frame(RzCore *core);

 RZ_API bool rz_core_debug_step_back(RzCore *core, int steps);

 RZ_API bool rz_core_debug_step_over(RzCore *core, int steps);

 RZ_API bool rz_core_debug_step_skip(RzCore *core, int times);

 RZ_API void rz_core_dbg_follow_seek_register(RzCore *core);


 RZ_API RZ_OWN RzList /*<RzBacktrace *>*/ *rz_core_debug_backtraces(RzCore *core);

 RZ_API void rz_backtrace_free(RZ_NULLABLE RzBacktrace *bt);


 RZ_API RzCmdStatus rz_core_debug_plugins_print(RzCore *core, RzCmdStateOutput *state);

 RZ_API void rz_core_debug_map_update_flags(RzCore *core);

 RZ_API void rz_core_debug_map_print(RzCore *core, ut64 addr, RzCmdStateOutput *state);


 /* chash.c */

 RZ_API RzCmdStatus rz_core_hash_plugins_print(RzHash *hash, RzCmdStateOutput *state);


 /* cio.c */

 RZ_API RzCmdStatus rz_core_io_plugins_print(RzIO *io, RzCmdStateOutput *state);


 /* cio.c */

 RZ_API RzCmdStatus rz_core_parser_plugins_print(RzParse *parser, RzCmdStateOutput *state);


 /* fortune */

 RZ_API void rz_core_fortune_list_types(void);

 RZ_API void rz_core_fortune_list(RzCore *core);

 RZ_API RZ_OWN char *rz_core_fortune_get_random(RzCore *core);

 RZ_API void rz_core_fortune_print_random(RzCore *core);


 #define RZ_CORE_FOREIGN_ADDR -1

 RZ_API RZ_OWN char *rz_core_yank_as_string(RzCore *core, ut64 pos);

 RZ_API bool rz_core_yank(RzCore *core, ut64 addr, ut64 len);

 RZ_API bool rz_core_yank_string(RzCore *core, ut64 addr, ut64 maxlen);

 RZ_API bool rz_core_yank_hexpair(RzCore *core, const char *str);

 RZ_API bool rz_core_yank_paste(RzCore *core, ut64 addr, ut64 len);

 RZ_API bool rz_core_yank_set(RzCore *core, ut64 addr, RZ_NONNULL const ut8 *buf, ut64 len);

 RZ_API bool rz_core_yank_set_str(RzCore *core, ut64 addr, RZ_NONNULL const char *str);

 RZ_API bool rz_core_yank_to(RzCore *core, ut64 len, ut64 addr);

 RZ_API bool rz_core_yank_dump(RzCore *core, ut64 pos, RzCmdStateOutput *state);

 RZ_API bool rz_core_yank_print_hexdump(RzCore *core, ut64 pos);

 RZ_API bool rz_core_yank_print(RzCore *core, ut64 pos);

 RZ_API bool rz_core_yank_print_string(RzCore *core, ut64 pos);

 RZ_API bool rz_core_yank_hud_file(RzCore *core, const char *input);

 RZ_API bool rz_core_yank_hud_path(RzCore *core, const char *input, int dir);

 RZ_API bool rz_core_yank_file(RzCore *core, ut64 len, ut64 addr, const char *filename);

 RZ_API bool rz_core_yank_file_all(RzCore *core, const char *filename);


 #define RZ_CORE_LOADLIBS_ENV    1

 #define RZ_CORE_LOADLIBS_HOME   2

 #define RZ_CORE_LOADLIBS_SYSTEM 4

 #define RZ_CORE_LOADLIBS_CONFIG 8

 #define RZ_CORE_LOADLIBS_ALL    UT32_MAX


 RZ_API void rz_core_loadlibs_init(RzCore *core);

 RZ_API int rz_core_loadlibs(RzCore *core, int where);

 RZ_API RzCmd *rz_core_cmd_new(bool has_cons);

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

 RZ_API int rz_core_cmdf(RzCore *core, const char *fmt, ...) RZ_PRINTF_CHECK(2, 3);

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

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

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

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

 RZ_API char *rz_core_op_str(RzCore *core, ut64 addr);

 RZ_API RzAnalysisOp *rz_core_op_analysis(RzCore *core, ut64 addr, RzAnalysisOpMask mask);

 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);


 /* carg.c */

 RZ_DEPRECATE RZ_API ut64 rz_core_arg_get(RzCore *core, const char *cc, int num);

 RZ_API RZ_OWN RzList /*<RzAnalysisFuncArg *>*/ *rz_core_get_func_args(RzCore *core, const char *func_name);

 RZ_API void rz_core_print_func_args(RzCore *core);

 RZ_API char *resolve_fcn_name(RzAnalysis *analysis, const char *func_name);


 /* clang.c */

 RZ_API RzCmdStatus rz_core_lang_plugins_print(RzLang *lang, RzCmdStateOutput *state);


 /* ccore.c */

 RZ_API RzCmdStatus rz_core_core_plugins_print(RzCore *core, RzCmdStateOutput *state);


 /* cil.c */

 // TODO : They should have been there, but require `static` vars inside canalysis.c

 //      : Keep esil in canalysis.c, and split the rzil in cil.c

 RZ_API void rz_core_analysis_esil(RzCore *core, ut64 addr, ut64 size, RZ_NULLABLE RzAnalysisFunction *fcn);

 RZ_API bool rz_core_esil_cmd(RzAnalysisEsil *esil, const char *cmd, ut64 a1, ut64 a2);

 RZ_API int rz_core_esil_step(RzCore *core, ut64 until_addr, const char *until_expr, ut64 *prev_addr, bool stepOver);

 RZ_API int rz_core_esil_step_back(RzCore *core);

 RZ_API bool rz_core_esil_dumpstack(RzAnalysisEsil *esil);

 RZ_API bool rz_core_esil_continue_back(RZ_NONNULL RzCore *core);

 RZ_API void rz_core_analysis_esil_step_over(RZ_NONNULL RzCore *core);

 RZ_API void rz_core_analysis_esil_reinit(RZ_NONNULL RzCore *core);

 RZ_API void rz_core_analysis_esil_deinit(RZ_NONNULL RzCore *core);

 RZ_API void rz_core_analysis_esil_init_mem(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *name, ut64 addr, ut32 size);

 RZ_API void rz_core_analysis_esil_init_mem_del(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *name, ut64 addr, ut32 size);

 RZ_API void rz_core_analysis_esil_init_regs(RZ_NONNULL RzCore *core);


 /* canalysis.c */

 typedef enum rz_core_analysis_name_type {

     RZ_CORE_ANALYSIS_NAME_TYPE_VAR = 0,

     RZ_CORE_ANALYSIS_NAME_TYPE_FUNCTION,

     RZ_CORE_ANALYSIS_NAME_TYPE_FLAG,

     RZ_CORE_ANALYSIS_NAME_TYPE_ADDRESS,

 } RzCoreAnalysisNameType;


 typedef struct rz_core_analysis_name_t {

     char *name;

     char *realname;

     RzCoreAnalysisNameType type;

     ut64 offset;

 } RzCoreAnalysisName;


 RZ_API RzAnalysisOp *rz_core_analysis_op(RzCore *core, ut64 addr, int mask);

 RZ_API void rz_core_analysis_fcn_merge(RzCore *core, ut64 addr, ut64 addr2);

 RZ_API const char *rz_core_analysis_optype_colorfor(RzCore *core, ut64 addr, bool verbose);

 RZ_API ut64 rz_core_analysis_address(RzCore *core, ut64 addr);

 RZ_API void rz_core_analysis_undefine(RzCore *core, ut64 off);

 RZ_API void rz_core_analysis_hint_print(RzAnalysis *a, ut64 addr, RzCmdStateOutput *state);

 RZ_API void rz_core_analysis_hint_list_print(RzAnalysis *a, RzCmdStateOutput *state);

 RZ_API int rz_core_analysis_search(RzCore *core, ut64 from, ut64 to, ut64 ref, int mode);

 RZ_API int rz_core_analysis_search_xrefs(RZ_NONNULL RzCore *core, ut64 from, ut64 to);

 RZ_API int rz_core_analysis_data(RzCore *core, ut64 addr, int count, int depth, int wordsize);

 RZ_API void rz_core_analysis_datarefs(RzCore *core, ut64 addr);

 RZ_API void rz_core_analysis_coderefs(RzCore *core, ut64 addr);

 RZ_API RzGraph /*<RzGraphNodeInfo *>*/ *rz_core_analysis_codexrefs(RzCore *core, ut64 addr);

 RZ_API RzGraph /*<RzGraphNodeInfo *>*/ *rz_core_analysis_importxrefs(RzCore *core);

 RZ_API void rz_core_analysis_callgraph(RzCore *core, ut64 addr, int fmt);

 RZ_API void rz_core_analysis_resolve_jumps(RZ_NONNULL RzCore *core);

 RZ_API bool rz_core_analysis_refs(RZ_NONNULL RzCore *core, size_t nbytes);

 RZ_API void rz_core_agraph_print(RzCore *core, int use_utf, const char *input);

 RZ_API void rz_core_analysis_flag_every_function(RzCore *core);

 RZ_API bool rz_core_analysis_function_rename(RzCore *core, ut64 addr, const char *_name);

 RZ_API bool rz_core_analysis_function_add(RzCore *core, const char *name, ut64 addr, bool analyze_recursively);

 RZ_API int rz_core_analysis_fcn(RzCore *core, ut64 at, ut64 from, int reftype, int depth);

 RZ_API RZ_OWN char *rz_core_analysis_function_autoname(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisFunction *fcn);

 RZ_API void rz_core_analysis_function_strings_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisFunction *fcn, RZ_NULLABLE PJ *pj);

 RZ_API void rz_core_analysis_autoname_all_fcns(RzCore *core);

 RZ_API bool rz_core_analysis_recover_golang_functions(RzCore *core);

 RZ_API void rz_core_analysis_resolve_golang_strings(RzCore *core);

 RZ_API char *rz_core_analysis_fcn_name(RzCore *core, RzAnalysisFunction *fcn);

 RZ_API int rz_core_analysis_fcn_clean(RzCore *core, ut64 addr);

 RZ_API int rz_core_print_bb_custom(RzCore *core, RzAnalysisFunction *fcn);

 RZ_API int rz_core_print_bb_gml(RzCore *core, RzAnalysisFunction *fcn);

 RZ_API bool rz_core_analysis_graph(RzCore *core, ut64 addr, int opts);

 RZ_API RzList /*<RzAnalysisBlock *>*/ *rz_core_analysis_graph_to(RzCore *core, ut64 addr, int n);

 RZ_API int rz_core_analysis_all(RzCore *core);

 RZ_API bool rz_core_analysis_everything(RzCore *core, bool experimental, char *dh_orig);

 RZ_API RZ_OWN RzList /*<RzSigDBEntry *>*/ *rz_core_analysis_sigdb_list(RZ_NONNULL RzCore *core, bool with_details);

 RZ_API bool rz_core_analysis_sigdb_apply(RZ_NONNULL RzCore *core, RZ_NULLABLE int *n_applied, RZ_NULLABLE const char *filter);

 RZ_API void rz_core_analysis_sigdb_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzTable *table);

 RZ_API RzList /*<RzAnalysisCycleHook *>*/ *rz_core_analysis_cycles(RzCore *core, int ccl);

 RZ_API RzList /*<RzAnalysisXRef *>*/ *rz_core_analysis_fcn_get_calls(RzCore *core, RzAnalysisFunction *fcn); // get all calls from a function

 RZ_API void rz_core_analysis_calls(RZ_NONNULL RzCore *core, bool imports_only);

 RZ_API int rz_core_get_stacksz(RzCore *core, ut64 from, ut64 to);

 RZ_API bool rz_core_analysis_hint_set_offset(RZ_NONNULL RzCore *core, RZ_NONNULL const char *struct_member);

 RZ_API bool rz_core_analysis_continue_until_syscall(RZ_NONNULL RzCore *core);

 RZ_API bool rz_core_analysis_continue_until_call(RZ_NONNULL RzCore *core);


 RZ_API st64 rz_core_analysis_coverage_count(RZ_NONNULL RzCore *core);

 RZ_API st64 rz_core_analysis_code_count(RZ_NONNULL RzCore *core);

 RZ_API st64 rz_core_analysis_calls_count(RZ_NONNULL RzCore *core);


 RZ_API RZ_BORROW const char *rz_core_analysis_name_type_to_str(RzCoreAnalysisNameType typ);

 RZ_API void rz_core_analysis_name_free(RZ_NULLABLE RzCoreAnalysisName *p);

 RZ_API RZ_OWN RzCoreAnalysisName *rz_core_analysis_name(RZ_NONNULL RzCore *core, ut64 addr);

 RZ_API bool rz_core_analysis_rename(RZ_NONNULL RzCore *core, RZ_NONNULL const char *name, ut64 addr);


 /*tp.c*/

 RZ_API void rz_core_analysis_type_match(RzCore *core, RzAnalysisFunction *fcn, HtUU *addr_loop_table);


 /* asm.c */

 #define RZ_MIDFLAGS_HIDE     0

 #define RZ_MIDFLAGS_SHOW     1

 #define RZ_MIDFLAGS_REALIGN  2

 #define RZ_MIDFLAGS_SYMALIGN 3


 typedef struct rz_core_asm_hit {

     char *code;

     int len;

     ut64 addr;

     ut8 valid;

 } RzCoreAsmHit;


 typedef struct rz_core_disasm_options {

     int invbreak;

     int cbytes;

     RzAnalysisFunction *function;

     RzPVector *vec;

 } RzCoreDisasmOptions;


 #define RZ_CORE_MAX_DISASM (1024 * 1024 * 8)


 RZ_API RzBuffer *rz_core_syscall(RzCore *core, const char *name, const char *args);

 RZ_API RzBuffer *rz_core_syscallf(RzCore *core, const char *name, const char *fmt, ...) RZ_PRINTF_CHECK(3, 4);

 RZ_API RzCoreAsmHit *rz_core_asm_hit_new(void);

 RZ_API RzList /*<RzCoreAsmHit *>*/ *rz_core_asm_hit_list_new(void);

 RZ_API void rz_core_asm_hit_free(void *_hit);

 RZ_API void rz_core_set_asm_configs(RzCore *core, char *arch, ut32 bits, int segoff);

 RZ_API char *rz_core_asm_search(RzCore *core, const char *input);

 RZ_API RzCmdStatus rz_core_asm_plugins_print(RzCore *core, const char *arch, RzCmdStateOutput *state);

 RZ_API RzList /*<RzCoreAsmHit *>*/ *rz_core_asm_strsearch(RzCore *core, const char *input, ut64 from, ut64 to, int maxhits, int regexp, int everyByte, int mode);

 RZ_API RzList /*<RzCoreAsmHit *>*/ *rz_core_asm_bwdisassemble(RzCore *core, ut64 addr, int n, int len);

 RZ_API RzList /*<RzCoreAsmHit *>*/ *rz_core_asm_back_disassemble_instr(RzCore *core, ut64 addr, int len, ut32 hit_count, ut32 extra_padding);

 RZ_API RzList /*<RzCoreAsmHit *>*/ *rz_core_asm_back_disassemble_byte(RzCore *core, ut64 addr, int len, ut32 hit_count, ut32 extra_padding);

 RZ_API ut32 rz_core_asm_bwdis_len(RzCore *core, int *len, ut64 *start_addr, ut32 l);

 RZ_API int rz_core_print_disasm(RZ_NONNULL RzCore *core, ut64 addr, RZ_NONNULL ut8 *buf, int len, int nlines, RZ_NULLABLE RzCmdStateOutput *state, RZ_NULLABLE RzCoreDisasmOptions *options);

 RZ_API int rz_core_print_disasm_json(RzCore *core, ut64 addr, ut8 *buf, int len, int lines, PJ *pj);

 RZ_API int rz_core_print_disasm_instructions_with_buf(RzCore *core, ut64 address, ut8 *buf, int nb_bytes, int nb_opcodes);

 RZ_API int rz_core_print_disasm_instructions(RzCore *core, int nb_bytes, int nb_opcodes);

 RZ_API int rz_core_print_disasm_all(RzCore *core, ut64 addr, int l, int len, int mode);

 RZ_API int rz_core_disasm_pdi_with_buf(RzCore *core, ut64 address, ut8 *buf, ut32 nb_opcodes, ut32 nb_bytes, int fmt);

 RZ_API int rz_core_disasm_pdi(RzCore *core, int nb_opcodes, int nb_bytes, int fmt);

 RZ_API int rz_core_disasm_pde(RzCore *core, int nb_opcodes, RzCmdStateOutput *state);

 RZ_API RZ_OWN char *rz_core_disasm_instruction(RzCore *core, ut64 addr, ut64 reladdr, RZ_NULLABLE RzAnalysisFunction *fcn, bool color);

 RZ_API bool rz_core_print_function_disasm_json(RzCore *core, RzAnalysisFunction *fcn, PJ *pj);

 RZ_API int rz_core_flag_in_middle(RzCore *core, ut64 at, int oplen, int *midflags);

 RZ_API int rz_core_bb_starts_in_middle(RzCore *core, ut64 at, int oplen);

 RZ_API void rz_analysis_disasm_text_free(RzAnalysisDisasmText *t);


 /* cbin.c */

 RZ_API bool rz_core_bin_raise(RzCore *core, ut32 bfid);

 RZ_API bool rz_core_bin_set_cur(RZ_NONNULL RzCore *core, RZ_NULLABLE RzBinFile *binfile);

 RZ_API RZ_BORROW const char *rz_core_bin_get_compile_time(RZ_NONNULL RzBinFile *bf);

 RZ_API void rz_core_bin_options_init(RzCore *core, RZ_OUT RzBinOptions *opts, int fd, ut64 baseaddr, ut64 loadaddr);

 RZ_API bool rz_core_bin_apply_strings(RzCore *r, RzBinFile *binfile);

 RZ_API bool rz_core_bin_apply_config(RzCore *r, RzBinFile *binfile);

 RZ_API bool rz_core_bin_apply_maps(RzCore *core, RzBinFile *binfile, bool va);

 RZ_API bool rz_core_bin_apply_main(RzCore *r, RzBinFile *binfile, bool va);

 RZ_API bool rz_core_bin_apply_dwarf(RzCore *core, RzBinFile *binfile);

 RZ_API bool rz_core_bin_apply_entry(RzCore *core, RzBinFile *binfile, bool va);

 RZ_API bool rz_core_bin_apply_sections(RzCore *core, RzBinFile *binfile, bool va);

 RZ_API bool rz_core_bin_apply_relocs(RzCore *core, RzBinFile *binfile, bool va);

 RZ_API bool rz_core_bin_apply_imports(RzCore *core, RzBinFile *binfile, bool va);

 RZ_API bool rz_core_bin_apply_symbols(RzCore *core, RzBinFile *binfile, bool va);

 RZ_API bool rz_core_bin_apply_classes(RzCore *core, RzBinFile *binfile);

 RZ_API bool rz_core_bin_apply_resources(RzCore *core, RzBinFile *binfile);

 RZ_API bool rz_core_bin_apply_info(RzCore *r, RzBinFile *binfile, ut32 mask);

 RZ_API bool rz_core_bin_apply_all_info(RzCore *r, RzBinFile *binfile);

 RZ_API int rz_core_bin_set_by_fd(RzCore *core, ut64 bin_fd);

 RZ_API int rz_core_bin_set_by_name(RzCore *core, const char *name);

 RZ_API bool rz_core_bin_load(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *file_uri, ut64 base_addr);

 RZ_API int rz_core_bin_rebase(RzCore *core, ut64 baddr);

 RZ_API void rz_core_bin_export_info(RzCore *core, int mode);

 RZ_API bool rz_core_binfiles_print(RzCore *core, RzCmdStateOutput *state);

 RZ_API bool rz_core_binfiles_delete(RzCore *core, RzBinFile *bf);

 RZ_API RZ_OWN HtPP *rz_core_bin_create_digests(RzCore *core, ut64 paddr, ut64 size, RzList /*<char *>*/ *digests);


 RZ_API void rz_core_bin_print_source_line_sample(RzCore *core, const RzBinSourceLineSample *s, RzCmdStateOutput *state);

 RZ_API void rz_core_bin_print_source_line_info(RzCore *core, const RzBinSourceLineInfo *li, RzCmdStateOutput *state);


 RZ_API bool rz_core_sym_is_export(RZ_NONNULL RzBinSymbol *s);

 RZ_API void rz_core_sym_name_init(RZ_NONNULL RzCore *r, RZ_OUT RzBinSymNames *sn, RZ_NONNULL RzBinSymbol *sym, RZ_NULLABLE const char *lang);

 RZ_API void rz_core_sym_name_fini(RZ_NULLABLE RzBinSymNames *sn);


 // bin_dwarf

 RZ_API void rz_core_bin_dwarf_print_abbrev_section(const RzBinDwarfDebugAbbrev *da);

 RZ_API void rz_core_bin_dwarf_print_attr_value(const RzBinDwarfAttrValue *val);

 RZ_API void rz_core_bin_dwarf_print_debug_info(const RzBinDwarfDebugInfo *inf);

 RZ_API void rz_core_bin_dwarf_print_loc(HtUP /*<offset, RzBinDwarfLocList *>*/ *loc_table, int addr_size);

 RZ_API void rz_core_bin_dwarf_print_aranges(RzList /*<RzBinDwarfARangeSet *>*/ *aranges);

 RZ_API void rz_core_bin_dwarf_print_line_units(RzList /*<RzBinDwarfLineUnit *>*/ *lines);


 /* gdiff.c */

 RZ_API bool rz_core_gdiff_2_files(RzCore *core1, RzCore *core2);

 RZ_API bool rz_core_gdiff_function_1_file(RzCore *c, ut64 addr, ut64 addr2);

 RZ_API bool rz_core_gdiff_function_2_files(RzCore *core1, RzCore *core2, ut64 addr, ut64 addr2);


 RZ_API void rz_core_sysenv_begin(RzCore *core);

 RZ_API void rz_core_sysenv_end(RzCore *core);


 RZ_API void rz_core_recover_vars(RzCore *core, RzAnalysisFunction *fcn, bool argonly);


 /* cmd_linux_heap_glibc.c */

 RZ_API RzList /*<RzHeapChunkListItem *>*/ *rz_heap_chunks_list(RzCore *core, ut64 m_arena);

 RZ_API RzList /*<MallocState *>*/ *rz_heap_arenas_list(RzCore *core);

 RZ_API RzHeapChunkSimple *rz_heap_chunk(RzCore *core, ut64 addr);

 RZ_API RzHeapBin *rz_heap_bin_content(RzCore *core, MallocState *arena, int bin_num, ut64 m_arena);

 RZ_API RzHeapBin *rz_heap_fastbin_content(RzCore *core, MallocState *arena, int bin_num);

 RZ_API MallocState *rz_heap_get_arena(RzCore *core, ut64 m_state);

 RZ_API RzList /*<RzHeapBin *>*/ *rz_heap_tcache_content(RzCore *core, ut64 arena_base);

 RZ_API bool rz_heap_write_chunk(RzCore *core, RzHeapChunkSimple *chunk_simple);


 /* cmd_windows_heap.c */

 RZ_API RZ_OWN RzList /*<RzWindowsHeapBlock *>*/ *rz_heap_windows_blocks_list(RzCore *core);

 RZ_API RZ_OWN RzList /*<RzWindowsHeapInfo *>*/ *rz_heap_windows_heap_list(RzCore *core);


 // XXX dupe from rz_bin.h

 /* bin.c */

 #define RZ_CORE_BIN_ACC_STRINGS          0x001

 #define RZ_CORE_BIN_ACC_INFO             0x002

 #define RZ_CORE_BIN_ACC_MAIN             0x004

 #define RZ_CORE_BIN_ACC_ENTRIES          0x008

 #define RZ_CORE_BIN_ACC_RELOCS           0x010

 #define RZ_CORE_BIN_ACC_IMPORTS          0x020

 #define RZ_CORE_BIN_ACC_SYMBOLS          0x040

 #define RZ_CORE_BIN_ACC_SECTIONS         0x080

 #define RZ_CORE_BIN_ACC_FIELDS           0x100

 #define RZ_CORE_BIN_ACC_LIBS             0x200

 #define RZ_CORE_BIN_ACC_CLASSES          0x400

 #define RZ_CORE_BIN_ACC_DWARF            0x800

 #define RZ_CORE_BIN_ACC_SIZE             0x1000

 #define RZ_CORE_BIN_ACC_PDB              0x2000

 #define RZ_CORE_BIN_ACC_MEM              0x4000

 #define RZ_CORE_BIN_ACC_EXPORTS          0x8000

 #define RZ_CORE_BIN_ACC_VERSIONINFO      0x10000

 #define RZ_CORE_BIN_ACC_SIGNATURE        0x20000

 #define RZ_CORE_BIN_ACC_RAW_STRINGS      0x40000

 #define RZ_CORE_BIN_ACC_HEADER           0x80000

 #define RZ_CORE_BIN_ACC_RESOURCES        0x100000

 #define RZ_CORE_BIN_ACC_INITFINI         0x200000

 #define RZ_CORE_BIN_ACC_SEGMENTS         0x400000

 #define RZ_CORE_BIN_ACC_BASEFIND         0x800000

 #define RZ_CORE_BIN_ACC_TRYCATCH         0x20000000

 #define RZ_CORE_BIN_ACC_SECTIONS_MAPPING 0x40000000

 #define RZ_CORE_BIN_ACC_MAPS             0x80000000

 #define RZ_CORE_BIN_ACC_ALL              0x80504FFF


 #define RZ_CORE_PRJ_FLAGS           0x0001

 #define RZ_CORE_PRJ_EVAL            0x0002

 #define RZ_CORE_PRJ_IO_MAPS         0x0004

 #define RZ_CORE_PRJ_SECTIONS        0x0008

 #define RZ_CORE_PRJ_META            0x0010

 #define RZ_CORE_PRJ_XREFS           0x0020

 #define RZ_CORE_PRJ_FCNS            0x0040

 #define RZ_CORE_PRJ_ANALYSIS_HINTS  0x0080

 #define RZ_CORE_PRJ_ANALYSIS_TYPES  0x0100

 #define RZ_CORE_PRJ_ANALYSIS_MACROS 0x0200

 #define RZ_CORE_PRJ_ANALYSIS_SEEK   0x0400

 #define RZ_CORE_PRJ_DBG_BREAK       0x0800

 #define RZ_CORE_PRJ_ALL             0xFFFF


 typedef struct rz_core_bin_filter_t {

     ut64 offset;

     const char *name;

 } RzCoreBinFilter;


 RZ_API int rz_core_bin_set_arch_bits(RzCore *r, const char *name, const char *arch, ut16 bits);

 RZ_API int rz_core_bin_update_arch_bits(RzCore *r);

 RZ_API RZ_OWN char *rz_core_bin_class_build_flag_name(RZ_NONNULL RzBinClass *cls);

 RZ_API RZ_OWN char *rz_core_bin_super_build_flag_name(RZ_NONNULL RzBinClass *cls);

 RZ_API RZ_OWN char *rz_core_bin_method_build_flag_name(RZ_NONNULL RzBinClass *cls, RZ_NONNULL RzBinSymbol *meth);

 RZ_API RZ_OWN char *rz_core_bin_field_build_flag_name(RZ_NONNULL RzBinClass *cls, RZ_NONNULL RzBinField *field);

 RZ_API char *rz_core_bin_method_flags_str(ut64 flags, int mode);

 RZ_API RZ_OWN char *rz_core_bin_pdb_get_filename(RZ_NONNULL RzCore *core);

 RZ_API bool rz_core_bin_pdb_load(RZ_NONNULL RzCore *core, RZ_NONNULL const char *filename);

 RZ_API RzPdb *rz_core_pdb_load_info(RZ_NONNULL RzCore *core, RZ_NONNULL const char *file);

 RZ_API void rz_core_pdb_info_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzTypeDB *db, RZ_NONNULL RzPdb *pdb, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API char *rz_core_bin_pdb_gvars_as_string(RZ_NONNULL const RzPdb *pdb, const ut64 img_base, PJ *pj, const RzOutputMode mode);

 RZ_API RzCmdStatus rz_core_bin_plugins_print(RzBin *bin, RzCmdStateOutput *state);


 RZ_API bool rz_core_bin_archs_print(RZ_NONNULL RzBin *bin, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_entries_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_initfini_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_exports_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter);

 RZ_API bool rz_core_bin_cur_export_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_symbols_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter);

 RZ_API bool rz_core_bin_cur_symbol_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_imports_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter);

 RZ_API bool rz_core_bin_libs_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_main_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_relocs_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_sections_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter, RzList /*<char *>*/ *hashes);

 RZ_API bool rz_core_bin_cur_section_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzList /*<char *>*/ *hashes);

 RZ_API bool rz_core_bin_cur_segment_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzList /*<char *>*/ *hashes);

 RZ_API bool rz_core_bin_segments_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter, RzList /*<char *>*/ *hashes);

 RZ_API bool rz_core_bin_strings_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API RZ_OWN RzList /*<RzBinString *>*/ *rz_core_bin_whole_strings(RZ_NONNULL RzCore *core, RZ_NULLABLE RzBinFile *bf);

 RZ_API bool rz_core_bin_whole_strings_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_file_info_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_info_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_classes_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_class_as_source_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, const char *class_name);

 RZ_API bool rz_core_bin_class_fields_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, const char *class_name);

 RZ_API bool rz_core_bin_class_methods_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, const char *class_name);

 RZ_API bool rz_core_bin_signatures_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_fields_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_headers_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf);

 RZ_API bool rz_core_bin_dwarf_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_memory_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_resources_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RZ_NULLABLE RzList /*<char *>*/ *hashes);

 RZ_API bool rz_core_bin_versions_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_trycatch_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_size_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_sections_mapping_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state);

 RZ_API bool rz_core_bin_print(RzCore *core, RZ_NONNULL RzBinFile *bf, ut32 mask, RzCoreBinFilter *filter, RzCmdStateOutput *state, RzList /*<char *>*/ *hashes);

 RZ_API bool rz_core_bin_basefind_print(RzCore *core, ut32 pointer_size, RzCmdStateOutput *state);


 // cmeta.c

 RZ_API bool rz_core_meta_string_add(RzCore *core, ut64 addr, ut64 size, RzStrEnc encoding, RZ_NULLABLE const char *name);

 RZ_API bool rz_core_meta_pascal_string_add(RzCore *core, ut64 addr, RzStrEnc encoding, RZ_NULLABLE const char *name);


 // cprint.c

 typedef enum {

     RZ_CORE_PRINT_FORMAT_TYPE_OCTAL = 0,

     RZ_CORE_PRINT_FORMAT_TYPE_INTEGER,

     RZ_CORE_PRINT_FORMAT_TYPE_HEXADECIMAL,

     RZ_CORE_PRINT_FORMAT_TYPE_INVALID,

 } RzCorePrintFormatType;


 RZ_API RZ_OWN char *rz_core_print_string_c_cpp(RzCore *core);

 RZ_API RZ_OWN char *rz_core_hex_of_assembly(RzCore *core, const char *assembly);

 RZ_API RZ_OWN char *rz_core_esil_of_assembly(RzCore *core, const char *assembly);

 RZ_API RZ_OWN char *rz_core_assembly_of_hex(RzCore *core, ut8 *hex, int len);

 RZ_API RZ_OWN char *rz_core_esil_of_hex(RzCore *core, ut8 *hex, int len);


 RZ_API RZ_OWN char *rz_core_print_hexdump_diff_str(RZ_NONNULL RzCore *core, ut64 aa, ut64 ba, ut64 len);

 RZ_API RZ_OWN char *rz_core_print_dump_str(RZ_NONNULL RzCore *core, RzOutputMode mode, ut64 addr, ut8 n, int len, RzCorePrintFormatType format);

 RZ_API RZ_OWN char *rz_core_print_hexdump_or_hexdiff_str(RZ_NONNULL RzCore *core, RzOutputMode mode, ut64 addr, int len, bool use_comment);

 RZ_API RZ_OWN char *rz_core_print_hexdump_byline_str(RZ_NONNULL RzCore *core, bool hex_offset, ut64 addr, int len, ut8 size);


 /* rtr */

 RZ_API bool rz_core_rtr_init(RZ_NONNULL RzCore *core);

 RZ_API int rz_core_rtr_cmds(RzCore *core, const char *port);

 RZ_API char *rz_core_rtr_cmds_query(RzCore *core, const char *host, const char *port, const char *cmd);

 RZ_API void rz_core_rtr_pushout(RzCore *core, const char *input);

 RZ_API void rz_core_rtr_list(RzCore *core);

 RZ_API void rz_core_rtr_add(RzCore *core, const char *input);

 RZ_API void rz_core_rtr_remove(RzCore *core, const char *input);

 RZ_API void rz_core_rtr_session(RzCore *core, const char *input);

 RZ_API void rz_core_rtr_cmd(RzCore *core, const char *input);

 RZ_API int rz_core_rtr_http(RzCore *core, int launch, int browse, const char *path);

 RZ_API int rz_core_rtr_http_stop(RzCore *u);

 RZ_API int rz_core_rtr_gdb(RzCore *core, int launch, const char *path);


 RZ_API int rz_core_visual_prevopsz(RzCore *core, ut64 addr);

 RZ_API void rz_core_visual_config(RzCore *core);

 RZ_API void rz_core_visual_analysis(RzCore *core, const char *input);

 RZ_API void rz_core_visual_debugtraces(RzCore *core, const char *input);

 RZ_API void rz_core_visual_define(RzCore *core, const char *arg, int distance);

 RZ_API int rz_core_visual_trackflags(RzCore *core);

 RZ_API int rz_core_visual_view_graph(RzCore *core);

 RZ_API int rz_core_visual_view_rop(RzCore *core);

 RZ_API int rz_core_visual_comments(RzCore *core);

 RZ_API int rz_core_visual_prompt(RzCore *core);

 RZ_API bool rz_core_visual_esil(RzCore *core);

 RZ_API int rz_core_search_preludes(RzCore *core, bool log);

 RZ_API int rz_core_search_prelude(RzCore *core, ut64 from, ut64 to, const ut8 *buf, int blen, const ut8 *mask, int mlen);

 RZ_API RZ_OWN RzList /*<RzIOMap *>*/ *rz_core_get_boundaries_prot(RzCore *core, int protection, const char *mode, const char *prefix);


 RZ_API void rz_core_hack_help(const RzCore *core);

 RZ_API bool rz_core_hack(RzCore *core, const char *op);

 RZ_API bool rz_core_dump(RzCore *core, const char *file, ut64 addr, ut64 size, int append);

 RZ_API void rz_core_diff_show(RzCore *core, RzCore *core2, bool json);

 RZ_API bool rz_core_diff_show_function(RzCore *core, RzCore *core2, ut64 addr, bool json);

 RZ_API void rz_core_clippy(RzCore *core, const char *msg);


 // TODO MOVE SOMEWHERE ELSE

 typedef char *(*PrintItemCallback)(void *user, void *p, bool selected);

 RZ_API char *rz_str_widget_list(void *user, RzList /*<void *>*/ *list, int rows, int cur, PrintItemCallback cb);

 /* help */

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

 RZ_API const char **rz_core_help_vars_get(RzCore *core);


 /* analysis stats */


 typedef struct {

     ut32 youarehere;

     ut32 flags;

     ut32 comments;

     ut32 functions;

     ut32 blocks;

     ut32 in_functions;

     ut32 symbols;

     ut32 strings;

     ut32 perm;

 } RzCoreAnalysisStatsItem;


 typedef struct {

     ut64 from;

     ut64 to;

     ut64 step;

     RzVector blocks;

 } RzCoreAnalysisStats;


 RZ_API char *rz_core_analysis_hasrefs(RzCore *core, ut64 value, int mode);

 RZ_API char *rz_core_analysis_get_comments(RzCore *core, ut64 addr);

 RZ_API RZ_OWN RzCoreAnalysisStats *rz_core_analysis_get_stats(RZ_NONNULL RzCore *a, ut64 from, ut64 to, ut64 step);

 RZ_API void rz_core_analysis_stats_free(RzCoreAnalysisStats *s);

 RZ_API ut64 rz_core_analysis_stats_get_block_from(RZ_NONNULL const RzCoreAnalysisStats *s, size_t i);

 RZ_API ut64 rz_core_analysis_stats_get_block_to(RZ_NONNULL const RzCoreAnalysisStats *s, size_t i);


 RZ_API int rz_line_hist_offset_up(RzLine *line);

 RZ_API int rz_line_hist_offset_down(RzLine *line);


 RZ_API RZ_OWN char *rz_core_syscall_as_string(RzCore *core, st64 num, ut64 addr);


 /* tasks */


 typedef enum {

     RZ_CORE_TASK_STATE_BEFORE_START,

     RZ_CORE_TASK_STATE_RUNNING,

     RZ_CORE_TASK_STATE_SLEEPING,

     RZ_CORE_TASK_STATE_DONE

 } RzTaskState;


 typedef void (*RzCoreTaskRunner)(RzCoreTaskScheduler *sched, void *user);


 typedef void (*RzCoreTaskRunnerFree)(void *user);


 struct rz_core_task_t {

     RzCoreTaskScheduler *sched;

     int id;

     RzTaskState state;

     bool transient; // delete when finished

     int refcount;

     RzThreadSemaphore *running_sem;

     bool dispatched;

     RzThreadCond *dispatch_cond;

     RzThreadLock *dispatch_lock;

     RzThread *thread;

     bool breaked;


     RzCoreTaskRunner runner; // will be NULL for main task

     RzCoreTaskRunnerFree runner_free;

     void *runner_user;

 };


 typedef void (*RzCoreTaskOneShot)(void *);


 RZ_API RzTable *rz_core_table(RzCore *core);


 RZ_API void rz_core_task_scheduler_init(RzCoreTaskScheduler *sched,

     RzCoreTaskContextSwitch ctx_switch, void *ctx_switch_user,

     RzCoreTaskBreak break_cb, void *break_cb_user);

 RZ_API void rz_core_task_scheduler_fini(RzCoreTaskScheduler *tasks);

 RZ_API RzCoreTask *rz_core_task_get_incref(RzCoreTaskScheduler *scheduler, int id);

 RZ_API int rz_core_task_running_tasks_count(RzCoreTaskScheduler *scheduler);

 RZ_API RzCoreTask *rz_core_task_new(RzCoreTaskScheduler *sched, RzCoreTaskRunner runner, RzCoreTaskRunnerFree runner_free, void *runner_user);

 RZ_API void rz_core_task_incref(RzCoreTask *task);

 RZ_API void rz_core_task_decref(RzCoreTask *task);

 RZ_API void rz_core_task_enqueue(RzCoreTaskScheduler *scheduler, RzCoreTask *task);

 RZ_API void rz_core_task_enqueue_oneshot(RzCoreTaskScheduler *scheduler, RzCoreTaskOneShot func, void *user);

 RZ_API int rz_core_task_run_sync(RzCoreTaskScheduler *scheduler, RzCoreTask *task);

 RZ_API void rz_core_task_sync_begin(RzCoreTaskScheduler *scheduler);

 RZ_API void rz_core_task_sync_end(RzCoreTaskScheduler *scheduler);

 RZ_API void rz_core_task_yield(RzCoreTaskScheduler *scheduler);

 RZ_API void rz_core_task_sleep_begin(RzCoreTask *task);

 RZ_API void rz_core_task_sleep_end(RzCoreTask *task);

 RZ_API void rz_core_task_break(RzCoreTaskScheduler *scheduler, int id);

 RZ_API void rz_core_task_break_all(RzCoreTaskScheduler *scheduler);

 RZ_API int rz_core_task_del(RzCoreTaskScheduler *scheduler, int id);

 RZ_API RzCoreTask *rz_core_task_self(RzCoreTaskScheduler *scheduler);

 RZ_API void rz_core_task_join(RzCoreTaskScheduler *scheduler, RzCoreTask *current, int id);

 typedef void (*inRangeCb)(RzCore *core, ut64 from, ut64 to, int vsize, void *cb_user);

 RZ_API int rz_core_search_value_in_range(RzCore *core, RzInterval search_itv,

     ut64 vmin, ut64 vmax, int vsize, inRangeCb cb, void *cb_user);


 // core-specific tasks

 typedef void (*RzCoreCmdTaskFinished)(const char *res, void *user);

 RZ_API RzCoreTask *rz_core_cmd_task_new(RzCore *core, const char *cmd, RzCoreCmdTaskFinished finished_cb, void *finished_cb_user);

 RZ_API const char *rz_core_cmd_task_get_result(RzCoreTask *task);

 typedef void *(*RzCoreTaskFunction)(RzCore *core, void *user);

 RZ_API RzCoreTask *rz_core_function_task_new(RzCore *core, RzCoreTaskFunction fcn, void *fcn_user);

 RZ_API void *rz_core_function_task_get_result(RzCoreTask *task);

 RZ_API const char *rz_core_task_status(RzCoreTask *task);

 RZ_API void rz_core_task_print(RzCore *core, RzCoreTask *task, int mode, PJ *j);

 RZ_API void rz_core_task_list(RzCore *core, int mode);

 RZ_API bool rz_core_task_is_cmd(RzCore *core, int id);

 RZ_API void rz_core_task_del_all_done(RzCore *core);


 RZ_API RzCoreAutocomplete *rz_core_autocomplete_add(RzCoreAutocomplete *parent, const char *cmd, int type, bool lock);

 RZ_API void rz_core_autocomplete_free(RzCoreAutocomplete *obj);

 RZ_API void rz_core_autocomplete_reload(RzCore *core);

 RZ_API RzCoreAutocomplete *rz_core_autocomplete_find(RzCoreAutocomplete *parent, const char *cmd, bool exact);

 RZ_API bool rz_core_autocomplete_remove(RzCoreAutocomplete *parent, const char *cmd);

 RZ_API void rz_core_analysis_propagate_noreturn(RzCore *core, ut64 addr);


 RZ_API bool rz_core_flirt_dump_file(RZ_NONNULL const char *flirt_file);

 RZ_API bool rz_core_flirt_create_file(RZ_NONNULL RzCore *core, RZ_NONNULL const char *output_file, RZ_NULLABLE ut32 *written_nodes);

 RZ_API bool rz_core_flirt_convert_file(RZ_NONNULL RzCore *core, RZ_NONNULL const char *input_file, RZ_NONNULL const char *ouput_file);

 RZ_API const char *rz_core_flirt_arch_from_id(ut8 arch);

 RZ_API ut8 rz_core_flirt_arch_from_name(RZ_NONNULL const char *arch);

 RZ_API ut32 rz_core_flirt_file_from_option_list(RZ_NONNULL const char *file_list);

 RZ_API ut16 rz_core_flirt_os_from_option_list(RZ_NONNULL const char *os_list);

 RZ_API ut16 rz_core_flirt_app_from_option_list(RZ_NONNULL const char *app_list);


 /* PLUGINS */

 extern RzCorePlugin rz_core_plugin_java;

 extern RzCorePlugin rz_core_plugin_dex;


 /* DECOMPILER PRINTING FUNCTIONS */

 RZ_API void rz_core_annotated_code_print_json(RzAnnotatedCode *code);

 RZ_API void rz_core_annotated_code_print(RzAnnotatedCode *code, RzVector /*<ut64>*/ *line_offsets);

 RZ_API void rz_core_annotated_code_print_comment_cmds(RzAnnotatedCode *code);


 /* serialize */


 RZ_API void rz_serialize_core_save(RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, RZ_NULLABLE const char *prj_file);


 RZ_API bool rz_serialize_core_load(RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, bool load_bin_io,

     RZ_NULLABLE const char *prj_file, RZ_NULLABLE RzSerializeResultInfo *res);


 RZ_API bool rz_core_project_load_for_cli(RzCore *core, const char *file, bool load_bin_io);


 RZ_API bool rz_platform_index_add_flags_comments(RzCore *core);


 /* regs */

 typedef bool (*RzCmdRegSync)(RzCore *core, RzRegisterType type, bool write);

 RZ_API bool rz_core_reg_assign_sync(RZ_NONNULL RzCore *core, RZ_NONNULL RzReg *reg, RzCmdRegSync sync_cb, RZ_NONNULL const char *name, ut64 val);

 RZ_API RZ_OWN RzList /*<RzRegItem *>*/ *rz_core_reg_filter_items_sync(RZ_NONNULL RzCore *core, RZ_NONNULL RzReg *reg, RzCmdRegSync sync_cb, RZ_NULLABLE const char *filter);


 #endif


 #ifdef __cplusplus

 }

 #endif


 #endif

len
size_t len
Definition: 6502dis.c:15

rz_core_visual_graph
RZ_API int rz_core_visual_graph(RzCore *core, RzAGraph *g, RzAnalysisFunction *_fcn, int is_interactive)
Definition: agraph.c:4114

disMode
static int disMode
Definition: agraph.c:14

mask
#define mask()
Definition: analysis_h8300.c:39

cmd_analysis_objc
RZ_API bool cmd_analysis_objc(RzCore *core, bool auto_analysis)
Definition: analysis_objc.c:301

rz_core_analysis_type_match
RZ_API void rz_core_analysis_type_match(RzCore *core, RzAnalysisFunction *fcn, HtUU *loop_table)
Definition: analysis_tp.c:816

i
lzma_index ** i
Definition: index.h:629

cls
static RzILOpEffect * cls(cs_insn *insn)
Definition: arm_il64.c:915

val
ut16 val
Definition: armass64_const.h:6

instructions
static const AvrInstruction instructions[]
Definition: assembler.c:880

baddr
static ut64 baddr(RzBinFile *bf)
Definition: bin_any.c:58

info
RzBinInfo * info(RzBinFile *bf)
Definition: bin_ne.c:86

symbols
RzList * symbols(RzBinFile *bf)
Definition: bin_ne.c:102

lines
static RzBinSourceLineInfo * lines(RzBinFile *bf)
Definition: bin_symbols.c:427

desc
const char * desc
Definition: bin_vsf.c:19

bits
int bits(struct state *s, int need)
Definition: blast.c:72

fh
FILE * fh
Definition: cabinfo.c:52

rz_core_analysis_function_strings_print
RZ_API void rz_core_analysis_function_strings_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisFunction *fcn, RZ_NULLABLE PJ *pj)
Print all string flags referenced by the function.
Definition: canalysis.c:612

rz_core_analysis_codexrefs
RZ_API RzGraph * rz_core_analysis_codexrefs(RzCore *core, ut64 addr)
Definition: canalysis.c:2412

rz_core_analysis_fcn_merge
RZ_API void rz_core_analysis_fcn_merge(RzCore *core, ut64 addr, ut64 addr2)
Definition: canalysis.c:4042

rz_core_analysis_fcn_get_calls
RZ_API RzList * rz_core_analysis_fcn_get_calls(RzCore *core, RzAnalysisFunction *fcn)
Definition: canalysis.c:2663

rz_core_analysis_fcn_name
RZ_API char * rz_core_analysis_fcn_name(RzCore *core, RzAnalysisFunction *fcn)
Definition: canalysis.c:2647

rz_core_analysis_bytes
RZ_API RZ_OWN RzPVector * rz_core_analysis_bytes(RZ_NONNULL RzCore *core, RZ_NONNULL const ut8 *buf, int len, int nops)
Definition: canalysis.c:6817

rz_core_analysis_hint_print
RZ_API void rz_core_analysis_hint_print(RzAnalysis *a, ut64 addr, RzCmdStateOutput *state)
Definition: canalysis.c:1433

rz_core_recover_vars
RZ_API void rz_core_recover_vars(RzCore *core, RzAnalysisFunction *fcn, bool argonly)
Definition: canalysis.c:2779

rz_core_analysis_esil_trace_stop
RZ_API bool rz_core_analysis_esil_trace_stop(RzCore *core)
Stop ESIL trace session.
Definition: canalysis.c:6770

rz_core_analysis_fcn_clean
RZ_API int rz_core_analysis_fcn_clean(RzCore *core, ut64 addr)
Definition: canalysis.c:2099

rz_core_print_bb_custom
RZ_API int rz_core_print_bb_custom(RzCore *core, RzAnalysisFunction *fcn)
Definition: canalysis.c:2118

rz_core_analysis_sigdb_print
RZ_API void rz_core_analysis_sigdb_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzTable *table)
Adds all the signatures to a RzTable structure.
Definition: canalysis.c:6026

rz_core_analysis_graph_to
RZ_API RzList * rz_core_analysis_graph_to(RzCore *core, ut64 addr, int n)
Definition: canalysis.c:2895

rz_core_analysis_all
RZ_API int rz_core_analysis_all(RzCore *core)
Definition: canalysis.c:3552

rz_core_analysis_stats_free
RZ_API void rz_core_analysis_stats_free(RzCoreAnalysisStats *s)
Definition: canalysis.c:3818

rz_core_analysis_continue_until_call
RZ_API bool rz_core_analysis_continue_until_call(RZ_NONNULL RzCore *core)
Continue until call.
Definition: canalysis.c:7041

rz_core_analysis_address
RZ_API ut64 rz_core_analysis_address(RzCore *core, ut64 addr)
Definition: canalysis.c:168

rz_core_analysis_type_init
RZ_API void rz_core_analysis_type_init(RzCore *core)
Definition: canalysis.c:6610

rz_core_analysis_undefine
RZ_API void rz_core_analysis_undefine(RzCore *core, ut64 off)
Definition: canalysis.c:4028

rz_core_analysis_function_add
RZ_API bool rz_core_analysis_function_add(RzCore *core, const char *name, ut64 addr, bool analyze_recursively)
Definition: canalysis.c:5298

rz_core_analysis_search
RZ_API int rz_core_analysis_search(RzCore *core, ut64 from, ut64 to, ut64 ref, int mode)
Definition: canalysis.c:3071

rz_core_analysis_cc_init
RZ_API void rz_core_analysis_cc_init(RzCore *core)
Definition: canalysis.c:6628

rz_core_analysis_coderefs
RZ_API void rz_core_analysis_coderefs(RzCore *core, ut64 addr)
Definition: canalysis.c:2342

rz_core_analysis_get_stats
RZ_API RZ_OWN RzCoreAnalysisStats * rz_core_analysis_get_stats(RZ_NONNULL RzCore *core, ut64 from, ut64 to, ut64 step)
Definition: canalysis.c:3722

rz_core_analysis_callgraph
RZ_API void rz_core_analysis_callgraph(RzCore *core, ut64 addr, int fmt)
Definition: canalysis.c:2425

rz_core_analysis_flag_every_function
RZ_API void rz_core_analysis_flag_every_function(RzCore *core)
Definition: canalysis.c:5202

rz_core_analysis_datarefs
RZ_API void rz_core_analysis_datarefs(RzCore *core, ut64 addr)
Definition: canalysis.c:2314

rz_core_analysis_hint_list_print
RZ_API void rz_core_analysis_hint_list_print(RzAnalysis *a, RzCmdStateOutput *state)
Definition: canalysis.c:1422

rz_core_analysis_op
RZ_API RzAnalysisOp * rz_core_analysis_op(RzCore *core, ut64 addr, int mask)
Definition: canalysis.c:1033

rz_core_analysis_autoname_all_fcns
RZ_API void rz_core_analysis_autoname_all_fcns(RzCore *core)
Definition: canalysis.c:504

rz_platform_index_add_flags_comments
RZ_API bool rz_platform_index_add_flags_comments(RzCore *core)
Adds the information from the Platform Profiles as flags and comments.
Definition: canalysis.c:5263

rz_core_analysis_continue_until_syscall
RZ_API bool rz_core_analysis_continue_until_syscall(RZ_NONNULL RzCore *core)
Continue until syscall.
Definition: canalysis.c:7005

rz_core_analysis_code_count
RZ_API st64 rz_core_analysis_code_count(RZ_NONNULL RzCore *core)
Compute analysis code count.
Definition: canalysis.c:7098

rz_core_analysis_everything
RZ_API bool rz_core_analysis_everything(RzCore *core, bool experimental, char *dh_orig)
Definition: canalysis.c:5784

rz_core_analysis_cycles
RZ_API RzList * rz_core_analysis_cycles(RzCore *core, int ccl)
Definition: canalysis.c:3847

rz_core_analysis_stats_get_block_from
RZ_API ut64 rz_core_analysis_stats_get_block_from(RZ_NONNULL const RzCoreAnalysisStats *s, size_t i)
Definition: canalysis.c:3829

rz_core_get_stacksz
RZ_API int rz_core_get_stacksz(RzCore *core, ut64 from, ut64 to)
Definition: canalysis.c:6582

rz_core_analysis_name_type_to_str
RZ_API RZ_BORROW const char * rz_core_analysis_name_type_to_str(RzCoreAnalysisNameType typ)
Convert typ to string (const char*)
Definition: canalysis.c:7140

rz_core_analysis_search_xrefs
RZ_API int rz_core_analysis_search_xrefs(RZ_NONNULL RzCore *core, ut64 from, ut64 to)
Searches for xrefs in the range of the paramters 'from' and 'to'.
Definition: canalysis.c:3380

rz_core_analysis_esil_trace_start
RZ_API bool rz_core_analysis_esil_trace_start(RzCore *core)
Start ESIL trace session.
Definition: canalysis.c:6746

rz_core_analysis_esil
RZ_API void rz_core_analysis_esil(RzCore *core, ut64 addr, ut64 size, RZ_NULLABLE RzAnalysisFunction *fcn)
Definition: canalysis.c:4499

rz_core_analysis_sigdb_list
RZ_API RZ_OWN RzList * rz_core_analysis_sigdb_list(RZ_NONNULL RzCore *core, bool with_details)
Returns all the signatures found in the default path.
Definition: canalysis.c:5994

rz_core_analysis_propagate_noreturn
RZ_API void rz_core_analysis_propagate_noreturn(RzCore *core, ut64 addr)
Definition: canalysis.c:5630

rz_core_analysis_paths
RZ_API void rz_core_analysis_paths(RzCore *core, ut64 from, ut64 to, bool followCalls, int followDepth, bool is_json)
Definition: canalysis.c:5121

rz_core_analysis_function_rename
RZ_API bool rz_core_analysis_function_rename(RzCore *core, ut64 addr, const char *_name)
Definition: canalysis.c:5270

rz_core_analysis_graph
RZ_API bool rz_core_analysis_graph(RzCore *core, ut64 addr, int opts)
Definition: canalysis.c:2917

rz_core_analysis_coverage_count
RZ_API st64 rz_core_analysis_coverage_count(RZ_NONNULL RzCore *core)
Compute analysis coverage count.
Definition: canalysis.c:7072

rz_core_analysis_calls_count
RZ_API st64 rz_core_analysis_calls_count(RZ_NONNULL RzCore *core)
Compute analysis function xrefs count.
Definition: canalysis.c:7115

rz_core_analysis_stats_get_block_to
RZ_API ut64 rz_core_analysis_stats_get_block_to(RZ_NONNULL const RzCoreAnalysisStats *s, size_t i)
Definition: canalysis.c:3837

rz_core_analysis_fcn
RZ_API int rz_core_analysis_fcn(RzCore *core, ut64 at, ut64 from, int reftype, int depth)
Definition: canalysis.c:2026

rz_core_analysis_resolve_jumps
RZ_API void rz_core_analysis_resolve_jumps(RZ_NONNULL RzCore *core)
Resolves any unresolved jump.
Definition: canalysis.c:3242

rz_analysis_bytes_free
RZ_API void rz_analysis_bytes_free(RZ_NULLABLE void *ptr)
Definition: canalysis.c:6791

rz_core_analysis_rename
RZ_API bool rz_core_analysis_rename(RZ_NONNULL RzCore *core, RZ_NONNULL const char *name, ut64 addr)
Rename whatever var/flag/function is used at addr to name.
Definition: canalysis.c:7166

rz_core_print_bb_gml
RZ_API int rz_core_print_bb_gml(RzCore *core, RzAnalysisFunction *fcn)
Definition: canalysis.c:2193

rz_core_search_value_in_range
RZ_API int rz_core_search_value_in_range(RzCore *core, RzInterval search_itv, ut64 vmin, ut64 vmax, int vsize, inRangeCb cb, void *cb_user)
Definition: canalysis.c:4895

rz_core_analysis_importxrefs
RZ_API RzGraph * rz_core_analysis_importxrefs(RzCore *core)
Definition: canalysis.c:2387

rz_core_analysis_name
RZ_API RZ_OWN RzCoreAnalysisName * rz_core_analysis_name(RZ_NONNULL RzCore *core, ut64 addr)
Get information on whatever var/flag/function is used at addr.
Definition: canalysis.c:7203

rz_core_analysis_data
RZ_API int rz_core_analysis_data(RzCore *core, ut64 addr, int count, int depth, int wordsize)
Definition: canalysis.c:3635

rz_core_analysis_function_autoname
RZ_API RZ_OWN char * rz_core_analysis_function_autoname(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisFunction *fcn)
Suggest a name for the function.
Definition: canalysis.c:545

rz_core_analysis_sigdb_apply
RZ_API bool rz_core_analysis_sigdb_apply(RZ_NONNULL RzCore *core, RZ_NULLABLE int *n_applied, RZ_NULLABLE const char *filter)
tries to apply the signatures in the flirt.sigdb.path
Definition: canalysis.c:6057

rz_core_analysis_name_free
RZ_API void rz_core_analysis_name_free(RZ_NULLABLE RzCoreAnalysisName *p)
Definition: canalysis.c:7153

rz_core_analysis_refs
RZ_API bool rz_core_analysis_refs(RZ_NONNULL RzCore *core, size_t nbytes)
Analyze xrefs and prints the result.
Definition: canalysis.c:3272

rz_core_analysis_hint_set_offset
RZ_API bool rz_core_analysis_hint_set_offset(RZ_NONNULL RzCore *core, RZ_NONNULL const char *struct_member)
Set analysis hint for the first immediate of the instruction at current offset to struct_member.
Definition: canalysis.c:6947

rz_core_annotated_code_print_json
RZ_API void rz_core_annotated_code_print_json(RzAnnotatedCode *code)
Definition: cannotated_code.c:10

rz_core_annotated_code_print
RZ_API void rz_core_annotated_code_print(RzAnnotatedCode *code, RzVector *line_offsets)
Definition: cannotated_code.c:145

rz_core_annotated_code_print_comment_cmds
RZ_API void rz_core_annotated_code_print_comment_cmds(RzAnnotatedCode *code)
Definition: cannotated_code.c:271

rz_core_print_func_args
RZ_API void rz_core_print_func_args(RzCore *core)
Definition: carg.c:203

rz_core_get_func_args
RZ_API RZ_OWN RzList * rz_core_get_func_args(RzCore *core, const char *fcn_name)
Definition: carg.c:276

rz_core_arg_get
RZ_DEPRECATE RZ_API ut64 rz_core_arg_get(RzCore *core, const char *cc, int num)
Get the value of the num-th argument from the current debug or emulation state.
Definition: carg.c:13

resolve_fcn_name
RZ_API char * resolve_fcn_name(RzAnalysis *analysis, const char *func_name)
Definition: carg.c:86

rz_core_asm_search
RZ_API char * rz_core_asm_search(RzCore *core, const char *input)
Definition: casm.c:56

rz_core_asm_bwdis_len
RZ_API ut32 rz_core_asm_bwdis_len(RzCore *core, int *instr_len, ut64 *start_addr, ut32 nb)
Definition: casm.c:890

rz_core_asm_back_disassemble_byte
RZ_API RzList * rz_core_asm_back_disassemble_byte(RzCore *core, ut64 addr, int len, ut32 hit_count, ut32 extra_padding)
Definition: casm.c:882

rz_core_asm_strsearch
RZ_API RzList * rz_core_asm_strsearch(RzCore *core, const char *input, ut64 from, ut64 to, int maxhits, int regexp, int everyByte, int mode)
Definition: casm.c:185

rz_core_asm_hit_new
RZ_API RzCoreAsmHit * rz_core_asm_hit_new(void)
Definition: casm.c:28

rz_core_asm_hit_free
RZ_API void rz_core_asm_hit_free(void *_hit)
Definition: casm.c:46

rz_core_asm_plugins_print
RZ_API RzCmdStatus rz_core_asm_plugins_print(RzCore *core, const char *arch, RzCmdStateOutput *state)
Definition: casm.c:150

rz_core_asm_hit_list_new
RZ_API RzList * rz_core_asm_hit_list_new(void)
Definition: casm.c:38

rz_core_asm_bwdisassemble
RZ_API RzList * rz_core_asm_bwdisassemble(RzCore *core, ut64 addr, int n, int len)
Definition: casm.c:612

rz_core_asm_back_disassemble_instr
RZ_API RzList * rz_core_asm_back_disassemble_instr(RzCore *core, ut64 addr, int len, ut32 hit_count, ut32 extra_padding)
Definition: casm.c:876

rz_core_autocomplete_rzshell
RZ_API RzLineNSCompletionResult * rz_core_autocomplete_rzshell(RzCore *core, RzLineBuffer *buf, RzLinePromptType prompt_type)
Definition: cautocmpl.c:1048

rz_core_bin_class_as_source_print
RZ_API bool rz_core_bin_class_as_source_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, const char *class_name)
Definition: cbin.c:3773

rz_core_sym_is_export
RZ_API bool rz_core_sym_is_export(RZ_NONNULL RzBinSymbol *s)
Is RzBinSymbol exported?
Definition: cbin.c:1916

rz_core_bin_exports_print
RZ_API bool rz_core_bin_exports_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter)
Definition: cbin.c:2044

rz_core_bin_method_flags_str
RZ_API char * rz_core_bin_method_flags_str(ut64 flags, int mode)
Definition: cbin.c:4731

rz_core_bin_export_info
RZ_API void rz_core_bin_export_info(RzCore *core, int mode)
Definition: cbin.c:108

rz_core_bin_headers_print
RZ_API bool rz_core_bin_headers_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf)
Definition: cbin.c:4122

rz_core_bin_print_source_line_info
RZ_API void rz_core_bin_print_source_line_info(RzCore *core, const RzBinSourceLineInfo *li, RzCmdStateOutput *state)
Definition: cbin.c:1811

rz_core_sym_name_init
RZ_API void rz_core_sym_name_init(RZ_NONNULL RzCore *r, RZ_OUT RzBinSymNames *sn, RZ_NONNULL RzBinSymbol *sym, RZ_NULLABLE const char *lang)
Initlize sn.
Definition: cbin.c:1322

rz_core_bin_fields_print
RZ_API bool rz_core_bin_fields_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:4070

rz_core_bin_apply_info
RZ_API bool rz_core_bin_apply_info(RzCore *r, RzBinFile *binfile, ut32 mask)
Definition: cbin.c:261

rz_core_bin_entries_print
RZ_API bool rz_core_bin_entries_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:1907

rz_core_bin_apply_main
RZ_API bool rz_core_bin_apply_main(RzCore *r, RzBinFile *binfile, bool va)
Definition: cbin.c:637

rz_core_bin_field_build_flag_name
RZ_API RZ_OWN char * rz_core_bin_field_build_flag_name(RZ_NONNULL RzBinClass *cls, RZ_NONNULL RzBinField *field)
Returns the flag name of a class field.
Definition: cbin.c:4708

rz_core_bin_apply_relocs
RZ_API bool rz_core_bin_apply_relocs(RzCore *core, RzBinFile *binfile, bool va_bool)
Definition: cbin.c:1206

rz_core_bin_apply_maps
RZ_API bool rz_core_bin_apply_maps(RzCore *core, RzBinFile *binfile, bool va)
Definition: cbin.c:887

rz_core_bin_cur_symbol_print
RZ_API bool rz_core_bin_cur_symbol_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:2036

rz_core_bin_memory_print
RZ_API bool rz_core_bin_memory_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:4955

rz_core_bin_whole_strings_print
RZ_API bool rz_core_bin_whole_strings_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:2917

rz_core_bin_create_digests
RZ_API RZ_OWN HtPP * rz_core_bin_create_digests(RzCore *core, ut64 paddr, ut64 size, RzList *digests)
Create a hashtable of digests.
Definition: cbin.c:1641

rz_core_bin_signatures_print
RZ_API bool rz_core_bin_signatures_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:4038

rz_core_bin_cur_export_print
RZ_API bool rz_core_bin_cur_export_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:2050

rz_core_bin_libs_print
RZ_API bool rz_core_bin_libs_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:2163

rz_core_bin_apply_sections
RZ_API bool rz_core_bin_apply_sections(RzCore *core, RzBinFile *binfile, bool va)
Definition: cbin.c:926

rz_core_bin_apply_symbols
RZ_API bool rz_core_bin_apply_symbols(RzCore *core, RzBinFile *binfile, bool va)
Definition: cbin.c:1447

rz_core_bin_whole_strings
RZ_API RZ_OWN RzList * rz_core_bin_whole_strings(RZ_NONNULL RzCore *core, RZ_NULLABLE RzBinFile *bf)
Definition: cbin.c:2866

rz_core_bin_set_cur
RZ_API bool rz_core_bin_set_cur(RZ_NONNULL RzCore *core, RZ_NULLABLE RzBinFile *binfile)
Set binfile as current binfile.
Definition: cbin.c:1673

rz_core_bin_initfini_print
RZ_API bool rz_core_bin_initfini_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:1901

rz_core_bin_print
RZ_API bool rz_core_bin_print(RzCore *core, RZ_NONNULL RzBinFile *bf, ut32 mask, RzCoreBinFilter *filter, RzCmdStateOutput *state, RzList *hashes)
Print (to RzCons or inside RzCmdStateOutput) the binary information specified in mask.
Definition: cbin.c:386

rz_core_bin_super_build_flag_name
RZ_API RZ_OWN char * rz_core_bin_super_build_flag_name(RZ_NONNULL RzBinClass *cls)
Returns the flag name of a super class.
Definition: cbin.c:4657

rz_core_bin_apply_dwarf
RZ_API bool rz_core_bin_apply_dwarf(RzCore *core, RzBinFile *binfile)
Definition: cbin.c:654

rz_core_bin_set_by_name
RZ_API int rz_core_bin_set_by_name(RzCore *core, const char *name)
Definition: cbin.c:253

rz_core_binfiles_delete
RZ_API bool rz_core_binfiles_delete(RzCore *core, RzBinFile *bf)
Close an opened binary file.
Definition: cbin.c:4542

rz_core_bin_set_by_fd
RZ_API int rz_core_bin_set_by_fd(RzCore *core, ut64 bin_fd)
Definition: cbin.c:100

rz_core_bin_sections_mapping_print
RZ_API bool rz_core_bin_sections_mapping_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:5117

rz_core_bin_update_arch_bits
RZ_API int rz_core_bin_update_arch_bits(RzCore *r)
Definition: cbin.c:4503

rz_core_binfiles_print
RZ_API bool rz_core_binfiles_print(RzCore *core, RzCmdStateOutput *state)
Print all the opened binary files according to state.
Definition: cbin.c:4603

rz_core_bin_class_build_flag_name
RZ_API RZ_OWN char * rz_core_bin_class_build_flag_name(RZ_NONNULL RzBinClass *cls)
Returns the flag name of a class.
Definition: cbin.c:4634

rz_core_bin_size_print
RZ_API bool rz_core_bin_size_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:5151

rz_core_bin_apply_config
RZ_API bool rz_core_bin_apply_config(RzCore *r, RzBinFile *binfile)
Definition: cbin.c:582

rz_core_bin_relocs_print
RZ_API bool rz_core_bin_relocs_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:2224

rz_core_bin_resources_print
RZ_API bool rz_core_bin_resources_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RZ_NULLABLE RzList *hashes)
Definition: cbin.c:5045

rz_core_bin_print_source_line_sample
RZ_API void rz_core_bin_print_source_line_sample(RzCore *core, const RzBinSourceLineSample *s, RzCmdStateOutput *state)
Definition: cbin.c:1778

rz_core_bin_archs_print
RZ_API bool rz_core_bin_archs_print(RZ_NONNULL RzBin *bin, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:5217

rz_core_bin_info_print
RZ_API bool rz_core_bin_info_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:3044

rz_core_bin_segments_print
RZ_API bool rz_core_bin_segments_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter, RzList *hashes)
Definition: cbin.c:2633

rz_core_bin_plugins_print
RZ_API RzCmdStatus rz_core_bin_plugins_print(RzBin *bin, RzCmdStateOutput *state)
Definition: cbin.c:4855

rz_core_bin_options_init
RZ_API void rz_core_bin_options_init(RzCore *core, RZ_OUT RzBinOptions *opts, int fd, ut64 baseaddr, ut64 loadaddr)
Definition: cbin.c:87

rz_core_bin_apply_imports
RZ_API bool rz_core_bin_apply_imports(RzCore *core, RzBinFile *binfile, bool va)
Definition: cbin.c:1255

rz_core_bin_cur_section_print
RZ_API bool rz_core_bin_cur_section_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzList *hashes)
Definition: cbin.c:2541

rz_core_bin_method_build_flag_name
RZ_API RZ_OWN char * rz_core_bin_method_build_flag_name(RZ_NONNULL RzBinClass *cls, RZ_NONNULL RzBinSymbol *meth)
Returns the flag name of a class method.
Definition: cbin.c:4680

rz_core_bin_get_compile_time
RZ_API RZ_BORROW const char * rz_core_bin_get_compile_time(RZ_NONNULL RzBinFile *bf)
Get TimeDateStamp string from bf->sdb with key "info.image_file_header.TimeDateStamp_string".
Definition: cbin.c:1707

rz_core_bin_strings_print
RZ_API bool rz_core_bin_strings_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:2853

rz_core_bin_symbols_print
RZ_API bool rz_core_bin_symbols_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter)
Definition: cbin.c:2030

rz_core_bin_apply_resources
RZ_API bool rz_core_bin_apply_resources(RzCore *core, RzBinFile *binfile)
Definition: cbin.c:1596

rz_core_bin_classes_print
RZ_API bool rz_core_bin_classes_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:3939

rz_core_bin_apply_strings
RZ_API bool rz_core_bin_apply_strings(RzCore *r, RzBinFile *binfile)
Definition: cbin.c:531

rz_core_bin_pdb_get_filename
RZ_API RZ_OWN char * rz_core_bin_pdb_get_filename(RZ_NONNULL RzCore *core)
Definition: cbin.c:4886

rz_core_bin_dwarf_print
RZ_API bool rz_core_bin_dwarf_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:4880

rz_core_bin_cur_segment_print
RZ_API bool rz_core_bin_cur_segment_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzList *hashes)
Definition: cbin.c:2549

rz_core_bin_class_fields_print
RZ_API bool rz_core_bin_class_fields_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, const char *class_name)
Definition: cbin.c:3814

rz_core_bin_raise
RZ_API bool rz_core_bin_raise(RzCore *core, ut32 bfid)
Definition: cbin.c:4524

rz_core_bin_apply_entry
RZ_API bool rz_core_bin_apply_entry(RzCore *core, RzBinFile *binfile, bool va)
Definition: cbin.c:699

rz_core_bin_load_structs
RZ_API bool rz_core_bin_load_structs(RZ_NONNULL RzCore *core, RZ_NONNULL const char *file)
Definition: cbin.c:236

rz_core_bin_set_arch_bits
RZ_API int rz_core_bin_set_arch_bits(RzCore *r, const char *name, const char *arch, ut16 bits)
Definition: cbin.c:4467

rz_core_file_info_print
RZ_API bool rz_core_file_info_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *binfile, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:2943

rz_core_sym_name_fini
RZ_API void rz_core_sym_name_fini(RZ_NULLABLE RzBinSymNames *sn)
RZ_FREE all member of sn (sn->*)
Definition: cbin.c:1371

rz_core_bin_sections_print
RZ_API bool rz_core_bin_sections_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter, RzList *hashes)
Definition: cbin.c:2472

rz_core_bin_imports_print
RZ_API bool rz_core_bin_imports_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter)
Definition: cbin.c:2058

rz_core_bin_apply_classes
RZ_API bool rz_core_bin_apply_classes(RzCore *core, RzBinFile *binfile)
Definition: cbin.c:1552

rz_core_bin_basefind_print
RZ_API bool rz_core_bin_basefind_print(RzCore *core, ut32 pointer_size, RzCmdStateOutput *state)
Definition: cbin.c:2573

rz_core_bin_pdb_load
RZ_API bool rz_core_bin_pdb_load(RZ_NONNULL RzCore *core, RZ_NONNULL const char *filename)
Definition: cbin.c:5264

rz_core_bin_versions_print
RZ_API bool rz_core_bin_versions_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:5084

rz_core_bin_apply_all_info
RZ_API bool rz_core_bin_apply_all_info(RzCore *r, RzBinFile *binfile)
Definition: cbin.c:311

rz_core_bin_trycatch_print
RZ_API bool rz_core_bin_trycatch_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:5102

rz_core_bin_main_print
RZ_API bool rz_core_bin_main_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state)
Definition: cbin.c:2192

rz_core_bin_class_methods_print
RZ_API bool rz_core_bin_class_methods_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, const char *class_name)
Definition: cbin.c:3881

rz_core_parse_rizinrc
RZ_API void rz_core_parse_rizinrc(RzCore *r)
Definition: cconfig.c:3704

rz_core_config_print_all
RZ_API void rz_core_config_print_all(RzConfig *cfg, const char *str, RzCmdStateOutput *state)
Prints the configuation variables with their description and its values.
Definition: cconfig.c:1770

rz_core_esil_cmd
RZ_API bool rz_core_esil_cmd(RzAnalysisEsil *esil, const char *cmd, ut64 a1, ut64 a2)
Definition: cconfig.c:1669

rz_core_config_init
RZ_API int rz_core_config_init(RzCore *core)
Definition: cconfig.c:2830

rz_core_config_in_space
RZ_API RZ_OWN RzList * rz_core_config_in_space(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *space)
Get config variable spaces.
Definition: cconfig.c:3759

rz_core_debug_bp_add_noreturn_func
RZ_API void rz_core_debug_bp_add_noreturn_func(RzCore *core)
Put a breakpoint into every no-return function.
Definition: cdebug.c:256

rz_core_debug_map_print
RZ_API void rz_core_debug_map_print(RzCore *core, ut64 addr, RzCmdStateOutput *state)
Definition: cdebug.c:481

rz_backtrace_free
RZ_API void rz_backtrace_free(RZ_NULLABLE RzBacktrace *bt)
Definition: cdebug.c:853

rz_core_debug_step_over
RZ_API bool rz_core_debug_step_over(RzCore *core, int steps)
Step over.
Definition: cdebug.c:802

rz_core_debug_breakpoint_toggle
RZ_API void rz_core_debug_breakpoint_toggle(RZ_NONNULL RzCore *core, ut64 addr)
Toggle breakpoint.
Definition: cdebug.c:235

rz_core_debug_step_skip
RZ_API bool rz_core_debug_step_skip(RzCore *core, int times)
Skip operations.
Definition: cdebug.c:831

rz_core_debug_step_back
RZ_API bool rz_core_debug_step_back(RzCore *core, int steps)
Step back.
Definition: cdebug.c:777

rz_core_debug_step_until_frame
RZ_API bool rz_core_debug_step_until_frame(RzCore *core)
Step until end of frame.
Definition: cdebug.c:745

rz_core_debug_backtraces
RZ_API RZ_OWN RzList * rz_core_debug_backtraces(RzCore *core)
Get backtraces based on dbg.btdepth and dbg.btalgo.
Definition: cdebug.c:926

rz_core_is_debug
RZ_API bool rz_core_is_debug(RzCore *core)
Check whether the core is in debug mode (equivalent to cfg.debug)
Definition: cdebug.c:13

rz_core_debug_continue_until
RZ_API bool rz_core_debug_continue_until(RzCore *core, ut64 addr, ut64 to)
Definition: cdebug.c:98

rz_core_debug_process_close
RZ_API bool rz_core_debug_process_close(RzCore *core)
Close debug process (Kill debugee and all child processes)
Definition: cdebug.c:707

rz_core_debug_map_update_flags
RZ_API void rz_core_debug_map_update_flags(RzCore *core)
Definition: cdebug.c:462

rz_core_debug_plugins_print
RZ_API RzCmdStatus rz_core_debug_plugins_print(RzCore *core, RzCmdStateOutput *state)
Definition: cdebug.c:329

rz_core_debug_step_one
RZ_API bool rz_core_debug_step_one(RzCore *core, int times)
Definition: cdebug.c:56

rz_core_bin_dwarf_print_abbrev_section
RZ_API void rz_core_bin_dwarf_print_abbrev_section(const RzBinDwarfDebugAbbrev *da)
Definition: cdwarf.c:6

rz_core_bin_dwarf_print_debug_info
RZ_API void rz_core_bin_dwarf_print_debug_info(const RzBinDwarfDebugInfo *inf)
Definition: cdwarf.c:121

rz_core_bin_dwarf_print_attr_value
RZ_API void rz_core_bin_dwarf_print_attr_value(const RzBinDwarfAttrValue *val)
Definition: cdwarf.c:32

rz_core_bin_dwarf_print_line_units
RZ_API void rz_core_bin_dwarf_print_line_units(RzList *lines)
Definition: cdwarf.c:343

rz_core_bin_dwarf_print_aranges
RZ_API void rz_core_bin_dwarf_print_aranges(RzList *aranges)
Definition: cdwarf.c:222

rz_core_bin_dwarf_print_loc
RZ_API void rz_core_bin_dwarf_print_loc(HtUP *loc_table, int addr_size)
Definition: cdwarf.c:196

rz_core_file_cur_fd
RZ_API ut32 rz_core_file_cur_fd(RzCore *core)
Definition: cfile.c:1584

rz_core_file_open_many
RZ_API RZ_BORROW RzCoreFile * rz_core_file_open_many(RZ_NONNULL RzCore *r, RZ_NULLABLE const char *file, int perm, ut64 base_address)
Open the file as a compilation of files.
Definition: cfile.c:1133

rz_core_file_close_all_but
RZ_API bool rz_core_file_close_all_but(RzCore *core)
Definition: cfile.c:1505

rz_core_sysenv_begin
RZ_API void rz_core_sysenv_begin(RzCore *core)
Definition: cfile.c:540

rz_core_file_cur
RZ_API RzCoreFile * rz_core_file_cur(RzCore *r)
Definition: cfile.c:1591

rz_core_file_reopen
RZ_API bool rz_core_file_reopen(RzCore *core, const char *args, int perm, int loadbin)
Definition: cfile.c:322

rz_core_file_find_by_fd
RZ_API RzCoreFile * rz_core_file_find_by_fd(RzCore *core, ut64 fd)
Definition: cfile.c:1528

rz_core_file_print
RZ_API bool rz_core_file_print(RzCore *core, RzOutputMode mode)
Definition: cfile.c:1372

rz_core_file_reopen_debug
RZ_API void rz_core_file_reopen_debug(RzCore *core, const char *args)
Definition: cfile.c:269

rz_core_file_close
RZ_API void rz_core_file_close(RzCoreFile *fh)
Definition: cfile.c:1299

rz_core_io_file_open
RZ_API void rz_core_io_file_open(RZ_NONNULL RzCore *core, int fd)
Open file use read-only Permission.
Definition: cfile.c:1601

rz_core_file_set_by_file
RZ_API int rz_core_file_set_by_file(RzCore *core, RzCoreFile *cf)
Definition: cfile.c:1573

rz_core_file_resize
RZ_API bool rz_core_file_resize(RzCore *core, ut64 newsize)
Definition: cfile.c:518

rz_core_file_bin_raise
RZ_API bool rz_core_file_bin_raise(RzCore *core, ut32 bfid)
Definition: cfile.c:1451

rz_core_file_reopen_remote_debug
RZ_API void rz_core_file_reopen_remote_debug(RzCore *core, const char *uri, ut64 addr)
Definition: cfile.c:222

rz_core_raw_file_print
RZ_API bool rz_core_raw_file_print(RzCore *core)
Definition: cfile.c:1339

rz_core_bin_rebase
RZ_API int rz_core_bin_rebase(RzCore *core, ut64 baddr)
Definition: cfile.c:822

rz_core_io_file_reopen
RZ_API void rz_core_io_file_reopen(RZ_NONNULL RzCore *core, int fd, int perms)
Reopen file.
Definition: cfile.c:1650

rz_core_file_open
RZ_API RZ_BORROW RzCoreFile * rz_core_file_open(RZ_NONNULL RzCore *r, RZ_NONNULL const char *file, int flags, ut64 loadaddr)
Tries to open the file as is, otherwise tries as is a compilation of files.
Definition: cfile.c:1182

rz_core_sysenv_end
RZ_API void rz_core_sysenv_end(RzCore *core)
Definition: cfile.c:526

rz_core_file_get_by_fd
RZ_API RzCoreFile * rz_core_file_get_by_fd(RzCore *core, int fd)
Definition: cfile.c:1328

rz_core_file_find_by_name
RZ_API RzCoreFile * rz_core_file_find_by_name(RzCore *core, const char *name)
Definition: cfile.c:1540

rz_core_file_binlist
RZ_API int rz_core_file_binlist(RzCore *core)
Definition: cfile.c:1465

rz_core_file_set_by_name
RZ_API int rz_core_file_set_by_name(RzCore *core, const char *name)
Definition: cfile.c:1568

rz_core_file_close_fd
RZ_API bool rz_core_file_close_fd(RzCore *core, int fd)
Definition: cfile.c:1510

rz_core_file_resize_delta
RZ_API bool rz_core_file_resize_delta(RzCore *core, st64 delta)
Definition: cfile.c:522

rz_core_file_open_load
RZ_API bool rz_core_file_open_load(RZ_NONNULL RzCore *core, RZ_NONNULL const char *filepath, ut64 addr, int perms, bool write_mode)
Tries to open the file, load binary info and make RzIOMap.
Definition: cfile.c:189

rz_core_bin_load
RZ_API bool rz_core_bin_load(RZ_NONNULL RzCore *r, RZ_NULLABLE const char *filenameuri, ut64 baddr)
Definition: cfile.c:942

rz_core_file_set_by_fd
RZ_API int rz_core_file_set_by_fd(RzCore *core, ut64 fd)
Definition: cfile.c:1559

rz_core_hash_plugins_print
RZ_API RzCmdStatus rz_core_hash_plugins_print(RzHash *hash, RzCmdStateOutput *state)
Definition: chash.c:34

rz_heap_windows_heap_list
RZ_API RZ_OWN RzList * rz_heap_windows_heap_list(RzCore *core)
Definition: cheap.c:32

rz_heap_windows_blocks_list
RZ_API RZ_OWN RzList * rz_heap_windows_blocks_list(RzCore *core)
Definition: cheap.c:28

rz_core_analysis_esil_init_mem
RZ_API void rz_core_analysis_esil_init_mem(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *name, ut64 addr, ut32 size)
Definition: cil.c:149

rz_core_analysis_esil_init_regs
RZ_API void rz_core_analysis_esil_init_regs(RZ_NONNULL RzCore *core)
Definition: cil.c:264

rz_core_analysis_esil_step_over
RZ_API void rz_core_analysis_esil_step_over(RZ_NONNULL RzCore *core)
Definition: cil.c:269

rz_core_analysis_esil_reinit
RZ_API void rz_core_analysis_esil_reinit(RZ_NONNULL RzCore *core)
Reinitialize ESIL.
Definition: cil.c:54

rz_core_analysis_esil_deinit
RZ_API void rz_core_analysis_esil_deinit(RZ_NONNULL RzCore *core)
Deinitialize ESIL.
Definition: cil.c:66

rz_core_analysis_esil_init_mem_del
RZ_API void rz_core_analysis_esil_init_mem_del(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *name, ut64 addr, ut32 size)
Remove ESIL VM stack.
Definition: cil.c:241

rz_core_setup_debugger
RZ_API int rz_core_setup_debugger(RzCore *r, const char *debugbackend, bool attach)
Definition: cio.c:7

rz_core_write_block_op_at
RZ_API bool rz_core_write_block_op_at(RzCore *core, ut64 addr, RzCoreWriteOp op, ut8 *hex, int hexlen)
Write a full block of data according to the operation op and the hexvalue hex.
Definition: cio.c:1038

rz_core_write_string_at
RZ_API bool rz_core_write_string_at(RzCore *core, ut64 addr, RZ_NONNULL const char *s)
Write a given string s at the specified addr.
Definition: cio.c:605

rz_core_extend_at
RZ_API bool rz_core_extend_at(RzCore *core, ut64 addr, ut64 size)
Extend the file at current offset by inserting size 0 bytes at addr.
Definition: cio.c:172

rz_core_write_string_wide_at
RZ_API bool rz_core_write_string_wide_at(RzCore *core, ut64 addr, const char *s)
Write a given string s as a wide string at the specified addr.
Definition: cio.c:630

rz_core_write_hexpair
RZ_API int rz_core_write_hexpair(RzCore *core, ut64 addr, const char *pairs)
Definition: cio.c:268

rz_core_write_at
RZ_API bool rz_core_write_at(RzCore *core, ut64 addr, const ut8 *buf, int size)
Definition: cio.c:145

rz_core_shift_block
RZ_API bool rz_core_shift_block(RzCore *core, ut64 addr, ut64 b_size, st64 dist)
Shift a block of data from addr of size b_size left or right based on dist.
Definition: cio.c:197

rz_core_io_pcache_print
RZ_API RzCmdStatus rz_core_io_pcache_print(RzCore *core, RzIODesc *desc, RzCmdStateOutput *state)
Definition: cio.c:854

rz_core_io_cache_print
RZ_API RzCmdStatus rz_core_io_cache_print(RzCore *core, RzCmdStateOutput *state)
Definition: cio.c:797

rz_core_arch_bits_at
RZ_API void rz_core_arch_bits_at(RzCore *core, ut64 addr, RZ_OUT RZ_NULLABLE int *bits, RZ_OUT RZ_BORROW RZ_NULLABLE const char **arch)
Definition: cio.c:97

rz_core_seek_arch_bits
RZ_API void rz_core_seek_arch_bits(RzCore *core, ut64 addr)
Definition: cio.c:132

rz_core_write_block
RZ_API bool rz_core_write_block(RzCore *core, ut64 addr, ut8 *data, size_t len)
Definition: cio.c:299

rz_core_write_string_zero_at
RZ_API bool rz_core_write_string_zero_at(RzCore *core, ut64 addr, const char *s)
Write a given string s, followed by the zero terminator, at the specified addr.
Definition: cio.c:905

rz_core_write_assembly
RZ_API int rz_core_write_assembly(RzCore *core, ut64 addr, RZ_NONNULL const char *instructions)
Assembles instructions and writes the resulting data at the given offset.
Definition: cio.c:327

rz_core_block_read
RZ_API int rz_core_block_read(RzCore *core)
Definition: cio.c:243

rz_core_write_base64d_at
RZ_API bool rz_core_write_base64d_at(RzCore *core, ut64 addr, RZ_NONNULL const char *s)
Write a given base64 string s at the specified addr, decoded.
Definition: cio.c:745

rz_core_write_value_inc_at
RZ_API bool rz_core_write_value_inc_at(RzCore *core, ut64 addr, st64 value, int sz)
Write at addr the current value + value passed as argument.
Definition: cio.c:551

rz_core_write_length_string_at
RZ_API bool rz_core_write_length_string_at(RzCore *core, ut64 addr, const char *s)
Write at the specified addr the length of the string in one byte, followed by the given string s.
Definition: cio.c:673

rz_core_dump
RZ_API bool rz_core_dump(RzCore *core, const char *file, ut64 addr, ut64 size, int append)
Definition: cio.c:50

rz_core_is_valid_offset
RZ_API int rz_core_is_valid_offset(RzCore *core, ut64 offset)
Definition: cio.c:250

rz_core_write_seq_at
RZ_API bool rz_core_write_seq_at(RzCore *core, ut64 addr, ut64 from, ut64 to, ut64 step, int value_size)
Write a full block of data with a sequence.
Definition: cio.c:1069

rz_core_write_base64_at
RZ_API bool rz_core_write_base64_at(RzCore *core, ut64 addr, RZ_NONNULL const char *s)
Write a given string s at the specified addr encoded as base64.
Definition: cio.c:700

rz_core_write_random_at
RZ_API bool rz_core_write_random_at(RzCore *core, ut64 addr, size_t len)
Write len random bytes at address addr.
Definition: cio.c:773

rz_core_write_assembly_fill
RZ_API int rz_core_write_assembly_fill(RzCore *core, ut64 addr, RZ_NONNULL const char *instructions)
Assemble instructions and write the resulting data inside the current instruction.
Definition: cio.c:365

rz_core_io_plugins_print
RZ_API RzCmdStatus rz_core_io_plugins_print(RzIO *io, RzCmdStateOutput *state)
Print the registered IO plugins according to state.
Definition: cio.c:481

rz_core_write_duplicate_at
RZ_API bool rz_core_write_duplicate_at(RzCore *core, ut64 addr, ut64 from, int len)
Copy len bytes from from to addr.
Definition: cio.c:1106

rz_core_write_value_at
RZ_API bool rz_core_write_value_at(RzCore *core, ut64 addr, ut64 value, int sz)
Write a given value at the specified address, using sz bytes.
Definition: cio.c:506

rz_core_transform_op
RZ_API RZ_OWN ut8 * rz_core_transform_op(RzCore *core, ut64 addr, RzCoreWriteOp op, ut8 *hex, int hexlen, int *buflen)
Transform a block of data at addr according to the operation op and the hexvalue hex.
Definition: cio.c:934

rz_core_lang_plugins_print
RZ_API RzCmdStatus rz_core_lang_plugins_print(RzLang *lang, RzCmdStateOutput *state)
Definition: clang.c:33

rz_core_cmd_foreach3
RZ_API int rz_core_cmd_foreach3(RzCore *core, const char *cmd, char *each)
Definition: cmd.c:2449

rz_core_cmd_str_pipe
RZ_API char * rz_core_cmd_str_pipe(RzCore *core, const char *cmd)
Definition: cmd.c:5438

rz_core_cmd_new
RZ_API RzCmd * rz_core_cmd_new(bool has_cons)
Create an instance of RzCmd for the Rizin language.
Definition: cmd.c:5220

rz_core_cmd_buffer
RZ_API int rz_core_cmd_buffer(RzCore *core, const char *buf)
Definition: cmd.c:5395

rz_core_cmd_lines
RZ_API int rz_core_cmd_lines(RzCore *core, const char *lines)
Definition: cmd.c:5336

rz_core_cmd0
RZ_API int rz_core_cmd0(RzCore *core, const char *cmd)
Definition: cmd.c:5428

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: cmd.c:5521

rz_core_cmd_foreach
RZ_API int rz_core_cmd_foreach(RzCore *core, const char *cmd, char *each)
Definition: cmd.c:2798

rz_core_cmd_help
RZ_API void rz_core_cmd_help(const RzCore *core, const char *help[])
Definition: cmd.c:163

rz_core_cmd
RZ_API int rz_core_cmd(RzCore *core, const char *cstr, int log)
Definition: cmd.c:5328

rz_core_cmd_file
RZ_API int rz_core_cmd_file(RzCore *core, const char *file)
Definition: cmd.c:5341

rz_core_cmd_command
RZ_API int rz_core_cmd_command(RzCore *core, const char *command)
Definition: cmd.c:5360

rz_core_run_script
RZ_API bool rz_core_run_script(RzCore *core, RZ_NONNULL const char *file)
Definition: cmd.c:457

rz_core_cmd_strf
RZ_API char * rz_core_cmd_strf(RzCore *core, const char *fmt,...)
Definition: cmd.c:5472

rz_core_cmd_init
RZ_API void rz_core_cmd_init(RzCore *core)
Definition: cmd.c:5562

rz_core_cmdf
RZ_API int rz_core_cmdf(RzCore *core, const char *fmt,...)
Definition: cmd.c:5413

rz_core_cmd_lines_rzshell
RZ_API RzCmdStatus rz_core_cmd_lines_rzshell(RzCore *core, const char *lines)
Definition: cmd.c:5332

rz_core_cmd0_rzshell
RZ_API RzCmdStatus rz_core_cmd0_rzshell(RzCore *core, const char *cmd)
Definition: cmd.c:5424

rz_core_disassemble_instr
RZ_API char * rz_core_disassemble_instr(RzCore *core, ut64 addr, int l)
Definition: cmd.c:5375

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: cmd.c:5513

rz_core_cmd_rzshell
RZ_API RzCmdStatus rz_core_cmd_rzshell(RzCore *core, const char *cstr, int log)
Definition: cmd.c:5324

rz_core_disassemble_bytes
RZ_API char * rz_core_disassemble_bytes(RzCore *core, ut64 addr, int b)
Definition: cmd.c:5385

rz_core_cmd_pipe_old
RZ_API int rz_core_cmd_pipe_old(RzCore *core, char *rizin_cmd, char *shell_cmd)
Definition: cmd.c:1058

rz_core_flush
RZ_API int rz_core_flush(RzCore *core, const char *cmd)
Definition: cmd.c:5432

rz_core_esil_continue_back
RZ_API bool rz_core_esil_continue_back(RZ_NONNULL RzCore *core)
Definition: cmd_analysis.c:1086

rz_core_analysis_calls
RZ_API void rz_core_analysis_calls(RZ_NONNULL RzCore *core, bool imports_only)
Definition: cmd_analysis.c:2287

rz_core_esil_step_back
RZ_API int rz_core_esil_step_back(RzCore *core)
Definition: cmd_analysis.c:1075

rz_core_agraph_print
RZ_API void rz_core_agraph_print(RzCore *core, int use_utf, const char *input)
Definition: cmd_analysis.c:2638

rz_core_esil_dumpstack
RZ_API bool rz_core_esil_dumpstack(RzAnalysisEsil *esil)
Definition: cmd_analysis.c:1794

rz_core_esil_step
RZ_API int rz_core_esil_step(RzCore *core, ut64 until_addr, const char *until_expr, ut64 *prev_addr, bool stepOver)
Definition: cmd_analysis.c:860

value
static int value
Definition: cmd_api.c:93

rz_core_dbg_follow_seek_register
RZ_API void rz_core_dbg_follow_seek_register(RzCore *core)
Seek to PC if needed.
Definition: cmd_debug.c:474

rz_core_debug_clear_register_flags
RZ_API void rz_core_debug_clear_register_flags(RzCore *core)
Definition: cmd_debug.c:1449

rz_core_debug_ri
RZ_API void rz_core_debug_ri(RzCore *core)
Definition: cmd_debug.c:3616

rz_core_debug_set_register_flags
RZ_API void rz_core_debug_set_register_flags(RzCore *core)
Definition: cmd_debug.c:1443

rz_core_theme_nextpal
RZ_API void rz_core_theme_nextpal(RzCore *core, RzConsPalSeekMode mode)
Definition: cmd_eval.c:148

rz_core_theme_list
RZ_API RZ_OWN RzList * rz_core_theme_list(RZ_NONNULL RzCore *core)
Returns the list of the rizin themes.
Definition: cmd_eval.c:119

rz_core_theme_get
RZ_API char * rz_core_theme_get(RzCore *core)
Definition: cmd_eval.c:103

rz_core_theme_load
RZ_API bool rz_core_theme_load(RzCore *core, const char *name)
Definition: cmd_eval.c:56

rz_core_help_vars_print
RZ_API void rz_core_help_vars_print(RzCore *core)
Definition: cmd_help.c:370

rz_core_help_vars_get
RZ_API const char ** rz_core_help_vars_get(RzCore *core)
Returns all the $ variable names in a NULL-terminated array.
Definition: cmd_help.c:360

rz_core_clippy
RZ_API void rz_core_clippy(RzCore *core, const char *msg)
Definition: cmd_help.c:385

rz_heap_write_chunk
RZ_API bool rz_heap_write_chunk(RzCore *core, RzHeapChunkSimple *chunk_simple)
Write a heap chunk header to memory.
Definition: cmd_linux_heap_glibc.c:159

rz_heap_chunk
RZ_API RzHeapChunkSimple * rz_heap_chunk(RzCore *core, ut64 addr)
Returns detailed information about a heap chunk. The chunk is represented by RzHeapChunkSimple struct...
Definition: cmd_linux_heap_glibc.c:102

rz_heap_chunks_list
RZ_API RzList * rz_heap_chunks_list(RzCore *core, ut64 m_arena)
Returns RzList* for a list of chunks from the arena. Each chunk is represented by RzHeapChunkListItem...
Definition: cmd_linux_heap_glibc.c:92

rz_heap_tcache_content
RZ_API RzList * rz_heap_tcache_content(RzCore *core, ut64 arena_base)
Get a list of bins for the tcache associated with an arena The list is in form of RzList and the bins...
Definition: cmd_linux_heap_glibc.c:149

rz_heap_arenas_list
RZ_API RzList * rz_heap_arenas_list(RzCore *core)
Returns RzList* for a list of arenas. Each arena is represented by RzArenaListItem struct.
Definition: cmd_linux_heap_glibc.c:82

rz_heap_get_arena
RZ_API MallocState * rz_heap_get_arena(RzCore *core, ut64 m_state)
Returns MallocState struct for given base address of the arena. This function checks if the arena is ...
Definition: cmd_linux_heap_glibc.c:137

rz_heap_fastbin_content
RZ_API RzHeapBin * rz_heap_fastbin_content(RzCore *core, MallocState *arena, int bin_num)
Returns information about a fastbin. The information is represented as RzHeapBin struct.
Definition: cmd_linux_heap_glibc.c:125

rz_heap_bin_content
RZ_API RzHeapBin * rz_heap_bin_content(RzCore *core, MallocState *arena, int bin_num, ut64 m_arena)
Returns information about a heap bin. The information is represented as RzHeapBin struct The bins cov...
Definition: cmd_linux_heap_glibc.c:114

rz_core_set_asm_configs
RZ_API void rz_core_set_asm_configs(RzCore *core, char *arch, ut32 bits, int segoff)
Definition: cmd_print.c:1057

append
#define append(x, y)
Definition: cmd_print.c:1740

rz_core_gadget_free
RZ_API void rz_core_gadget_free(RzCoreGadget *g)
Frees a visual print gadget.
Definition: cmd_print.c:1174

rz_core_gadget_print
RZ_API void rz_core_gadget_print(RzCore *core)
Prints or displays the print gadgets while in visual mode.
Definition: cmd_print.c:1185

rz_core_project_load_for_cli
RZ_API bool rz_core_project_load_for_cli(RzCore *core, const char *file, bool load_bin_io)
Definition: cmd_project.c:6

rz_core_reg_filter_items_sync
RZ_API RZ_OWN RzList * rz_core_reg_filter_items_sync(RZ_NONNULL RzCore *core, RZ_NONNULL RzReg *reg, RzCmdRegSync sync_cb, RZ_NULLABLE const char *filter)
Definition: cmd_regs.c:203

rz_core_reg_assign_sync
RZ_API bool rz_core_reg_assign_sync(RZ_NONNULL RzCore *core, RZ_NONNULL RzReg *reg, RzCmdRegSync sync_cb, RZ_NONNULL const char *name, ut64 val)
Definition: cmd_regs.c:138

rz_core_get_boundaries_prot
RZ_API RZ_OWN RzList * rz_core_get_boundaries_prot(RzCore *core, int perm, const char *mode, const char *prefix)
Definition: cmd_search.c:577

rz_core_search_preludes
RZ_API int rz_core_search_preludes(RzCore *core, bool log)
Definition: cmd_search.c:330

rz_core_search_prelude
RZ_API int rz_core_search_prelude(RzCore *core, ut64 from, ut64 to, const ut8 *buf, int blen, const ut8 *mask, int mlen)
Definition: cmd_search.c:292

rz_core_meta_pascal_string_add
RZ_API bool rz_core_meta_pascal_string_add(RzCore *core, ut64 addr, RzStrEnc encoding, RZ_NULLABLE const char *name)
add a pascal string to RzCore
Definition: cmeta.c:516

rz_core_meta_string_add
RZ_API bool rz_core_meta_string_add(RzCore *core, ut64 addr, ut64 size, RzStrEnc encoding, RZ_NULLABLE const char *name)
add a string to RzCore
Definition: cmeta.c:474

rz_core_analysis_recover_golang_functions
RZ_API bool rz_core_analysis_recover_golang_functions(RzCore *core)
reads pclntab table in go binaries and recovers functions. Follows the code https://github....
Definition: golang.c:405

rz_core_analysis_resolve_golang_strings
RZ_API void rz_core_analysis_resolve_golang_strings(RzCore *core)
Attempts to recover all golang string.
Definition: golang.c:1613

rz_core_plugin_dex
RzCorePlugin rz_core_plugin_dex
Definition: core_dex.c:312

rz_core_plugin_java
RzCorePlugin rz_core_plugin_java
Definition: core_java.c:317

RZ_API
#define RZ_API
Definition: core_plugin_example.c:36

rz_core_parser_plugins_print
RZ_API RzCmdStatus rz_core_parser_plugins_print(RzParse *parser, RzCmdStateOutput *state)
Definition: cparser.c:27

rz_core_pdb_info_print
RZ_API void rz_core_pdb_info_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzTypeDB *db, RZ_NONNULL RzPdb *pdb, RZ_NONNULL RzCmdStateOutput *state)
Print parsed PDB file info.
Definition: cpdb.c:273

rz_core_bin_pdb_gvars_as_string
RZ_API char * rz_core_bin_pdb_gvars_as_string(RZ_NONNULL const RzPdb *pdb, const ut64 img_base, PJ *pj, const RzOutputMode mode)
Return the PDB global vars string.
Definition: cpdb.c:128

rz_core_pdb_load_info
RZ_API RzPdb * rz_core_pdb_load_info(RZ_NONNULL RzCore *core, RZ_NONNULL const char *file)
Parse PDB file info and integrate with typedb.
Definition: cpdb.c:245

rz_core_plugin_init
RZ_API bool rz_core_plugin_init(RzCore *core)
Definition: cplugin.c:37

rz_core_plugin_fini
RZ_API bool rz_core_plugin_fini(RzCore *core)
Definition: cplugin.c:12

rz_core_plugin_add
RZ_API bool rz_core_plugin_add(RzCore *core, RzCorePlugin *plugin)
Definition: cplugin.c:27

rz_core_assembly_of_hex
RZ_API RZ_OWN char * rz_core_assembly_of_hex(RzCore *core, ut8 *hex, int len)
Get the assembly of the hexstr.
Definition: cprint.c:109

rz_core_print_dump_str
RZ_API char * rz_core_print_dump_str(RZ_NONNULL RzCore *core, RzOutputMode mode, ut64 addr, ut8 n, int len, RzCorePrintFormatType format)
Print dump at addr.
Definition: cprint.c:281

rz_core_esil_of_hex
RZ_API RZ_OWN char * rz_core_esil_of_hex(RzCore *core, ut8 *hex, int len)
Get the esil of the hexstr.
Definition: cprint.c:134

rz_core_print_hexdump_byline_str
RZ_API RZ_OWN char * rz_core_print_hexdump_byline_str(RZ_NONNULL RzCore *core, bool hex_offset, ut64 addr, int len, ut8 size)
Hexdump at addr.
Definition: cprint.c:406

rz_core_hex_of_assembly
RZ_API RZ_OWN char * rz_core_hex_of_assembly(RzCore *core, const char *assembly)
Get the hexpair of the assembly.
Definition: cprint.c:41

rz_core_print_hexdump_diff_str
RZ_API char * rz_core_print_hexdump_diff_str(RZ_NONNULL RzCore *core, ut64 aa, ut64 ba, ut64 len)
Print hexdump diff between aa and ba with len.
Definition: cprint.c:195

rz_core_print_hexdump_or_hexdiff_str
RZ_API char * rz_core_print_hexdump_or_hexdiff_str(RZ_NONNULL RzCore *core, RzOutputMode mode, ut64 addr, int len, bool use_comment)
Print hexdump at addr, but maybe print hexdiff if (diff.from or diff.to),.
Definition: cprint.c:337

rz_core_print_string_c_cpp
RZ_API RZ_OWN char * rz_core_print_string_c_cpp(RzCore *core)
Definition: cprint.c:13

rz_core_esil_of_assembly
RZ_API RZ_OWN char * rz_core_esil_of_assembly(RzCore *core, const char *assembly)
Get the esil of the assembly.
Definition: cprint.c:68

rz_core_reg_update_flags
RZ_API void rz_core_reg_update_flags(RzCore *core)
Update or create flags for all registers where it makes sense.
Definition: creg.c:106

rz_core_reg_default
RZ_API RzReg * rz_core_reg_default(RzCore *core)
Get the currently relevant RzReg.
Definition: creg.c:17

rz_core_reg_getv_by_role_or_name
RZ_API ut64 rz_core_reg_getv_by_role_or_name(RzCore *core, const char *name)
rz_reg_getv_by_role_or_name() on rz_core_reg_default()
Definition: creg.c:24

rz_core_reg_set_by_role_or_name
RZ_API bool rz_core_reg_set_by_role_or_name(RzCore *core, const char *name, ut64 num)
set on rz_core_reg_default()
Definition: creg.c:39

r
#define r
Definition: crypto_rc6.c:12

rz_core_flirt_os_from_option_list
RZ_API ut16 rz_core_flirt_os_from_option_list(RZ_NONNULL const char *os_list)
Returns the FLIRT file flags from a given list (comma spaced) of file types Returns RZ_FLIRT_SIG_OS_A...
Definition: csign.c:222

rz_core_flirt_app_from_option_list
RZ_API ut16 rz_core_flirt_app_from_option_list(RZ_NONNULL const char *app_list)
Returns the FLIRT file flags from a given list (comma spaced) of file types Returns RZ_FLIRT_SIG_APP_...
Definition: csign.c:258

rz_core_flirt_convert_file
RZ_API bool rz_core_flirt_convert_file(RZ_NONNULL RzCore *core, RZ_NONNULL const char *input_file, RZ_NONNULL const char *output_file)
converts a FLIRT file to the other format.
Definition: csign.c:510

rz_core_flirt_arch_from_id
RZ_API const char * rz_core_flirt_arch_from_id(ut8 arch)
Returns the FLIRT arch name (string format) from a given arch id Returns "unknown" if name is not fou...
Definition: csign.c:168

rz_core_flirt_file_from_option_list
RZ_API ut32 rz_core_flirt_file_from_option_list(RZ_NONNULL const char *file_list)
Returns the FLIRT file flags from a given list (comma spaced) of file types Returns RZ_FLIRT_SIG_FILE...
Definition: csign.c:186

rz_core_flirt_arch_from_name
RZ_API ut8 rz_core_flirt_arch_from_name(RZ_NONNULL const char *arch)
Returns the FLIRT arch id from a given arch name Returns RZ_FLIRT_SIG_ARCH_ANY if name is not found.
Definition: csign.c:148

rz_core_flirt_create_file
RZ_API bool rz_core_flirt_create_file(RZ_NONNULL RzCore *core, RZ_NONNULL const char *output_file, RZ_NULLABLE ut32 *written_nodes)
Generates a new FLIRT file from a given RzCore structure.
Definition: csign.c:431

rz_core_flirt_dump_file
RZ_API bool rz_core_flirt_dump_file(RZ_NONNULL const char *flirt_file)
Dumps the contents of a FLIRT file.
Definition: csign.c:372

arch
cs_arch arch
Definition: cstool.c:13

rz_core_syscall_as_string
RZ_API RZ_OWN char * rz_core_syscall_as_string(RzCore *core, st64 n, ut64 addr)
Returns the syscall representation as a string.
Definition: csyscall.c:26

rz_core_types_as_c
RZ_API RZ_OWN char * rz_core_types_as_c(RZ_NONNULL RzCore *core, RZ_NONNULL const char *name, bool multiline)
Get a type string by name (.
Definition: ctypes.c:424

rz_core_link_stroff
RZ_API void rz_core_link_stroff(RzCore *core, RzAnalysisFunction *fcn)
Definition: ctypes.c:717

rz_core_types_as_c_all
RZ_API RZ_OWN char * rz_core_types_as_c_all(RZ_NONNULL RzCore *core, bool multiline)
Get all types with pretty printing.
Definition: ctypes.c:439

rz_core_types_link
RZ_API void rz_core_types_link(RzCore *core, const char *typestr, ut64 addr)
Link an address addr to the type referenced by typestr.
Definition: ctypes.c:954

path
static static fork const void static count static fd const char const char static newpath const char static path const char path
Definition: sflib.h:35

write
static static fork write
Definition: sflib.h:33

nbytes
static static sync static getppid static getegid const char static filename char static len const char char static bufsiz static mask static vfork const void static prot static getpgrp const char static swapflags static arg static fd static protocol static who struct sockaddr static addrlen static backlog struct timeval struct timezone static tz const struct iovec static count static mode const void const struct sockaddr static tolen const char static pathname void static offset struct stat static buf void nbytes
Definition: sflib.h:113

count
static static sync static getppid static getegid const char static filename char static len const char char static bufsiz static mask static vfork const void static prot static getpgrp const char static swapflags static arg static fd static protocol static who struct sockaddr static addrlen static backlog struct timeval struct timezone static tz const struct iovec static count static mode const void const struct sockaddr static tolen const char static pathname void count
Definition: sflib.h:98

cmd
static static sync static getppid static getegid const char static filename char static len const char char static bufsiz static mask static vfork const void static prot static getpgrp const char static swapflags cmd
Definition: sflib.h:79

length
static static sync static getppid static getegid const char static filename char static len const char char static bufsiz static mask static vfork const void static prot static getpgrp const char static swapflags static arg static fd static protocol static who struct sockaddr static addrlen static backlog struct timeval struct timezone static tz const struct iovec static count static mode const void const struct sockaddr static tolen const char static pathname void static offset struct stat static buf void long static basep static whence static length const void static len static semflg const void static shmflg const struct timespec struct timespec static rem const char static group const void length
Definition: sflib.h:133

ut16
uint16_t ut16
Definition: demangler_util.h:30

ut32
uint32_t ut32
Definition: demangler_util.h:31

rz_core_print_disasm_instructions_with_buf
RZ_API int rz_core_print_disasm_instructions_with_buf(RzCore *core, ut64 address, ut8 *buf, int nb_bytes, int nb_opcodes)
Definition: disasm.c:5814

rz_core_flag_in_middle
RZ_API int rz_core_flag_in_middle(RzCore *core, ut64 at, int oplen, int *midflags)
Definition: disasm.c:1702

rz_core_print_disasm_json
RZ_API int rz_core_print_disasm_json(RzCore *core, ut64 addr, ut8 *buf, int nb_bytes, int nb_opcodes, PJ *pj)
Definition: disasm.c:6040

rz_core_disasm_pdi_with_buf
RZ_API int rz_core_disasm_pdi_with_buf(RzCore *core, ut64 address, ut8 *buf, ut32 nb_opcodes, ut32 nb_bytes, int fmt)
Definition: disasm.c:6324

rz_analysis_disasm_text_free
RZ_API void rz_analysis_disasm_text_free(RzAnalysisDisasmText *t)
Free RzAnalysisDisasmText p.
Definition: disasm.c:5317

rz_core_print_function_disasm_json
RZ_API bool rz_core_print_function_disasm_json(RzCore *core, RzAnalysisFunction *fcn, PJ *pj)
Definition: disasm.c:6726

rz_core_get_section_name
RZ_API const char * rz_core_get_section_name(RzCore *core, ut64 addr)
Definition: disasm.c:457

rz_core_print_disasm_all
RZ_API int rz_core_print_disasm_all(RzCore *core, ut64 addr, int l, int len, int mode)
Definition: disasm.c:6205

rz_core_bb_starts_in_middle
RZ_API int rz_core_bb_starts_in_middle(RzCore *core, ut64 at, int oplen)
Definition: disasm.c:1714

rz_core_pava
RZ_API ut64 rz_core_pava(RzCore *core, ut64 addr)
Definition: disasm.c:364

rz_core_disasm_instruction
RZ_API RZ_OWN char * rz_core_disasm_instruction(RzCore *core, ut64 addr, ut64 reladdr, RZ_NULLABLE RzAnalysisFunction *fcn, bool color)
Returns a disassembly of one instruction.
Definition: disasm.c:6770

rz_core_print_disasm
RZ_API int rz_core_print_disasm(RZ_NONNULL RzCore *core, ut64 addr, RZ_NONNULL ut8 *buf, int len, int nlines, RZ_NULLABLE RzCmdStateOutput *state, RZ_NULLABLE RzCoreDisasmOptions *options)
Disassemble len bytes and nlines opcodes restricted by len and nlines at the same time.
Definition: disasm.c:5336

rz_core_disasm_pdi
RZ_API int rz_core_disasm_pdi(RzCore *core, int nb_opcodes, int nb_bytes, int fmt)
Definition: disasm.c:6558

rz_core_disasm_pde
RZ_API int rz_core_disasm_pde(RzCore *core, int nb_opcodes, RzCmdStateOutput *state)
Definition: disasm.c:6581

rz_core_print_disasm_instructions
RZ_API int rz_core_print_disasm_instructions(RzCore *core, int nb_bytes, int nb_opcodes)
Definition: disasm.c:6030

step
static states step(struct re_guts *, sopno, sopno, states, int, states)
Definition: engine.c:888

g
struct @667 g

strings
checking print the parsed form of the magic use in n conjunction with m to debug a new magic file n before installing it n output MIME type strings(--mime-type and\n"
		    " --mime-encoding)\n") OPT('s'

rz_core_fortune_list
RZ_API void rz_core_fortune_list(RzCore *core)
Definition: fortune.c:28

rz_core_fortune_list_types
RZ_API void rz_core_fortune_list_types(void)
Definition: fortune.c:21

rz_core_fortune_get_random
RZ_API RZ_OWN char * rz_core_fortune_get_random(RzCore *core)
Definition: fortune.c:49

rz_core_fortune_print_random
RZ_API void rz_core_fortune_print_random(RzCore *core)
Definition: fortune.c:60

rz_core_gdiff_function_2_files
RZ_API bool rz_core_gdiff_function_2_files(RzCore *c, RzCore *c2, ut64 addr, ut64 addr2)
Calculates basic block differences of 2 functions within 2 files.
Definition: gdiff.c:47

rz_core_gdiff_function_1_file
RZ_API bool rz_core_gdiff_function_1_file(RzCore *c, ut64 addr, ut64 addr2)
Calculates basic block differences of 2 functions within the same file.
Definition: gdiff.c:17

rz_core_diff_show_function
RZ_API bool rz_core_diff_show_function(RzCore *core, RzCore *core2, ut64 addr1, bool json)
Generate a json or dot output of the graph and its data.
Definition: gdiff.c:574

rz_core_diff_show
RZ_API void rz_core_diff_show(RzCore *c, RzCore *c2, bool json)
Definition: gdiff.c:161

rz_core_gdiff_2_files
RZ_API bool rz_core_gdiff_2_files(RzCore *c, RzCore *c2)
Calculates basic block differences of all functions within 2 files.
Definition: gdiff.c:89

prefix
unsigned short prefix[65536]
Definition: gun.c:163

rz_core_hack_help
RZ_API void rz_core_hack_help(const RzCore *core)
Definition: hack.c:11

rz_core_hack
RZ_API bool rz_core_hack(RzCore *core, const char *op)
Write/Modify instructions at current offset based on op.
Definition: hack.c:280

ht_uu.h

size
voidpf void uLong size
Definition: ioapi.h:138

filename
const char * filename
Definition: ioapi.h:137

offset
voidpf uLong offset
Definition: ioapi.h:144

mode
const char int mode
Definition: ioapi.h:137

buf
voidpf void * buf
Definition: ioapi.h:138

reg
#define reg(n)

ut8
uint8_t ut8
Definition: lh5801.h:11

p
void * p
Definition: libc.cpp:67

const
#define const
Definition: ansidecl.h:240

rz_core_op_analysis
RZ_API RzAnalysisOp * rz_core_op_analysis(RzCore *core, ut64 addr, RzAnalysisOpMask mask)
Definition: core.c:2880

rz_core_prompt
RZ_API int rz_core_prompt(RzCore *r, int sync)
Definition: core.c:2805

rz_core_editor
RZ_API RZ_OWN char * rz_core_editor(const RzCore *core, RZ_NULLABLE const char *file, RZ_NULLABLE const char *str)
Definition: core.c:3214

rz_core_table
RZ_API RzTable * rz_core_table(RzCore *core)
Definition: core.c:3449

rz_core_getreloc
RZ_API RzBinReloc * rz_core_getreloc(RzCore *core, ut64 addr, int size)
Definition: core.c:178

rz_core_get_asmqjmps
RZ_API ut64 rz_core_get_asmqjmps(RzCore *core, const char *str)
Definition: core.c:203

rz_core_autocomplete_reload
RZ_API void rz_core_autocomplete_reload(RzCore *core)
Definition: core.c:2274

rz_core_analysis_optype_colorfor
RZ_API const char * rz_core_analysis_optype_colorfor(RzCore *core, ut64 addr, bool verbose)
Definition: core.c:2108

rz_core_bind
RZ_API int rz_core_bind(RzCore *core, RzCoreBind *bnd)
Definition: core.c:369

rz_core_search_cb
RZ_API int rz_core_search_cb(RzCore *core, ut64 from, ut64 to, RzCoreSearchCallback cb)
Definition: core.c:3184

rz_core_autocomplete_free
RZ_API void rz_core_autocomplete_free(RzCoreAutocomplete *obj)
Definition: core.c:3389

rz_core_notify_begin
RZ_API void rz_core_notify_begin(RZ_NONNULL RzCore *core, RZ_NONNULL const char *format,...)
Prints a message definining the beginning of a task.
Definition: core.c:33

rz_core_autocomplete_find
RZ_API RzCoreAutocomplete * rz_core_autocomplete_find(RzCoreAutocomplete *parent, const char *cmd, bool exact)
Definition: core.c:3403

rz_core_prompt_loop
RZ_API void rz_core_prompt_loop(RzCore *r)
Definition: core.c:2688

rz_core_bind_cons
RZ_API void rz_core_bind_cons(RzCore *core)
Definition: core.c:2612

rz_core_syscall
RZ_API RzBuffer * rz_core_syscall(RzCore *core, const char *name, const char *args)
Definition: core.c:3305

rz_core_fini
RZ_API void rz_core_fini(RzCore *c)
Definition: core.c:2623

rz_core_ncast
RZ_API RzCore * rz_core_ncast(ut64 p)
Definition: core.c:392

rz_core_autocomplete
RZ_API void rz_core_autocomplete(RZ_NULLABLE RzCore *core, RzLineCompletion *completion, RzLineBuffer *buf, RzLinePromptType prompt_type)
Definition: core.c:1550

rz_core_core_plugins_print
RZ_API RzCmdStatus rz_core_core_plugins_print(RzCore *core, RzCmdStateOutput *state)
Definition: core.c:3483

rz_core_syscallf
RZ_API RzBuffer * rz_core_syscallf(RzCore *core, const char *name, const char *fmt,...)
Definition: core.c:3292

rz_core_flag_get_by_spaces
RZ_API RzFlagItem * rz_core_flag_get_by_spaces(RzFlag *f, ut64 off)
Definition: core.c:2280

rz_core_block_size
RZ_API bool rz_core_block_size(RzCore *core, ut32 bsize)
Definition: core.c:2842

rz_core_autocomplete_add
RZ_API RzCoreAutocomplete * rz_core_autocomplete_add(RzCoreAutocomplete *parent, const char *cmd, int type, bool lock)
Definition: core.c:3366

rz_core_analysis_get_comments
RZ_API char * rz_core_analysis_get_comments(RzCore *core, ut64 addr)
Definition: core.c:2091

rz_core_free
RZ_API void rz_core_free(RzCore *c)
Definition: core.c:2683

rz_core_notify_done
RZ_API void rz_core_notify_done(RZ_NONNULL RzCore *core, RZ_NONNULL const char *format,...)
Prints a message definining the end of a task which succeeded.
Definition: core.c:60

rz_core_fgets
RZ_API int rz_core_fgets(char *buf, int len, void *user)
Definition: core.c:1694

rz_core_autocomplete_remove
RZ_API bool rz_core_autocomplete_remove(RzCoreAutocomplete *parent, const char *cmd)
Definition: core.c:3419

rz_core_notify_error
RZ_API void rz_core_notify_error(RZ_NONNULL RzCore *core, RZ_NONNULL const char *format,...)
Prints a message definining the end of a task which errored.
Definition: core.c:87

rz_core_init
RZ_API bool rz_core_init(RzCore *core)
Definition: core.c:2381

rz_core_op_str
RZ_API char * rz_core_op_str(RzCore *core, ut64 addr)
Definition: core.c:2869

rz_core_get_cons
RZ_API RzCons * rz_core_get_cons(RzCore *core)
Definition: core.c:3280

rz_core_cast
RZ_API RzCore * rz_core_cast(void *p)
Definition: core.c:396

rz_core_set_asmqjmps
RZ_API void rz_core_set_asmqjmps(RzCore *core, char *str, size_t len, int pos)
Definition: core.c:282

rz_core_get_bin
RZ_API RzBin * rz_core_get_bin(RzCore *core)
Definition: core.c:3288

rz_core_get_config
RZ_API RzConfig * rz_core_get_config(RzCore *core)
Definition: core.c:3284

rz_core_analysis_hasrefs
RZ_API char * rz_core_analysis_hasrefs(RzCore *core, ut64 value, int mode)
Definition: core.c:1805

rz_core_add_asmqjmp
RZ_API char * rz_core_add_asmqjmp(RzCore *core, ut64 addr)
Definition: core.c:238

rz_core_new
RZ_API RzCore * rz_core_new(void)
Definition: core.c:866

rz_core_get_reloc_to
RZ_API RzBinReloc * rz_core_get_reloc_to(RzCore *core, ut64 addr)
Definition: core.c:189

rz_core_analysis_hasrefs_to_depth
RZ_API char * rz_core_analysis_hasrefs_to_depth(RzCore *core, ut64 value, PJ *pj, int depth)
Definition: core.c:1853

rz_core_prompt_exec
RZ_API int rz_core_prompt_exec(RzCore *r)
Definition: core.c:2830

rz_core_serve
RZ_API bool rz_core_serve(RzCore *core, RzIODesc *file)
Definition: core.c:2904

list
static void list(RzEgg *egg)
Definition: rz-gg.c:52

save
static int save
Definition: main.c:14

rz_core_loadlibs_init
RZ_API void rz_core_loadlibs_init(RzCore *core)
Definition: libs.c:89

rz_core_loadlibs
RZ_API int rz_core_loadlibs(RzCore *core, int where)
Definition: libs.c:119

times
static static fork const void static count static fd const char const char static newpath char char char static envp time_t static t const char static mode static whence const char static dir time_t static t unsigned static seconds const char struct utimbuf static buf static inc static sig const char static mode static oldfd times
Definition: sflib.h:70

num
static static fork const void static count static fd const char const char static newpath char char char static envp time_t static t const char static mode static whence const char static dir time_t static t unsigned static seconds const char struct utimbuf static buf static inc static sig const char static mode static oldfd struct tms static buf static getgid static geteuid const char static filename static arg static mask struct ustat static ubuf static getppid static setsid static egid sigset_t static set struct timeval struct timezone static tz fd_set fd_set fd_set struct timeval static timeout const char char static bufsiz const char static swapflags void static offset const char static length static mode static who const char struct statfs static buf unsigned unsigned num
Definition: sflib.h:126

argv
static static fork const void static count static fd const char const char static newpath char char argv
Definition: sflib.h:40

options
static const char struct stat static buf struct stat static buf static vhangup int options
Definition: sflib.h:145

args
int args
Definition: mipsasm.c:18

x
int x
Definition: mipsasm.c:20

n
int n
Definition: mipsasm.c:19

type
int type
Definition: mipsasm.c:17

cmd_descs_generate.encoding
encoding
Definition: cmd_descs_generate.py:813

cmd_descs_generate.str
str
Definition: cmd_descs_generate.py:785

cmd_descs_generate.help
help
Definition: cmd_descs_generate.py:785

cmd_descs_generate.parser
parser
Definition: cmd_descs_generate.py:781

setup.line
line
Definition: setup.py:34

setup.idx
int idx
Definition: setup.py:197

name
const char * name
Definition: op.c:541

id
int id
Definition: op.c:540

off
int off
Definition: pal.c:13

code
const char * code
Definition: pal.c:98

rz_core_visual_panels_root
RZ_API bool rz_core_visual_panels_root(RzCore *core, RzPanelsRoot *panels_root)
Definition: panels.c:5947

hex
static const char hex[16]
Definition: print.c:21

rz_core_rtr_session
RZ_API void rz_core_rtr_session(RzCore *core, const char *input)
Definition: rtr.c:814

rz_core_rtr_list
RZ_API void rz_core_rtr_list(RzCore *core)
Definition: rtr.c:631

rz_core_rtr_http_stop
RZ_API int rz_core_rtr_http_stop(RzCore *u)
Definition: rtr.c:110

rz_core_rtr_add
RZ_API void rz_core_rtr_add(RzCore *core, const char *_input)
Definition: rtr.c:651

rz_core_rtr_cmds_query
RZ_API char * rz_core_rtr_cmds_query(RzCore *core, const char *host, const char *port, const char *cmd)
Definition: rtr.c:983

rz_core_rtr_gdb
RZ_API int rz_core_rtr_gdb(RzCore *core, int launch, const char *path)
Definition: rtr.c:571

rz_core_rtr_init
RZ_API bool rz_core_rtr_init(RZ_NONNULL RzCore *core)
Allocates core rtr structure.
Definition: rtr.c:1020

s
static RzSocket * s
Definition: rtr.c:28

rz_core_rtr_remove
RZ_API void rz_core_rtr_remove(RzCore *core, const char *input)
Definition: rtr.c:793

rz_core_wait
RZ_API void rz_core_wait(RzCore *core)
Definition: rtr.c:52

rz_core_rtr_cmds
RZ_API int rz_core_rtr_cmds(RzCore *core, const char *port)
Definition: rtr.c:1225

rz_core_rtr_pushout
RZ_API void rz_core_rtr_pushout(RzCore *core, const char *input)
Definition: rtr.c:582

rz_core_rtr_cmd
RZ_API void rz_core_rtr_cmd(RzCore *core, const char *input)
Definition: rtr.c:850

rz_core_rtr_http
RZ_API int rz_core_rtr_http(RzCore *core, int launch, int browse, const char *path)
Definition: rtr_http.c:491

rz_agraph.h

rz_analysis.h

RzAnalysisOpMask
RzAnalysisOpMask
Definition: rz_analysis.h:439

rz_annotated_code.h

rz_asm.h

rz_bin.h

rz_bind.h

rz_cmd.h

RzCmdStatus
enum rz_cmd_status_t RzCmdStatus

rz_config.h

rz_cons.h

RzLinePromptType
RzLinePromptType
Definition: rz_cons.h:1037

RzConsPalSeekMode
RzConsPalSeekMode
Definition: rz_cons.h:460

RzCorePluginFini
bool(* RzCorePluginFini)(RzCore *core)
Definition: rz_core.h:121

RzCoreVisualTab
struct rz_core_visual_tab_t RzCoreVisualTab

RzCoreTaskContextSwitch
void(* RzCoreTaskContextSwitch)(RzCoreTask *next, void *user)
Definition: rz_core.h:259

RzCoreSeekHistory
struct rz_core_seek_history_t RzCoreSeekHistory

RzCoreWriteOp
RzCoreWriteOp
Definition: rz_core.h:105

RZ_CORE_WRITE_OP_BYTESWAP8
@ RZ_CORE_WRITE_OP_BYTESWAP8
Swap the endianess of 8-bytes values.
Definition: rz_core.h:108

RZ_CORE_WRITE_OP_SHIFT_LEFT
@ RZ_CORE_WRITE_OP_SHIFT_LEFT
Write the shift left of existing byte by argument value.
Definition: rz_core.h:116

RZ_CORE_WRITE_OP_AND
@ RZ_CORE_WRITE_OP_AND
Write the bitwise-and of existing byte and argument value.
Definition: rz_core.h:113

RZ_CORE_WRITE_OP_SHIFT_RIGHT
@ RZ_CORE_WRITE_OP_SHIFT_RIGHT
Write the shift right of existing byte and argument value.
Definition: rz_core.h:117

RZ_CORE_WRITE_OP_BYTESWAP2
@ RZ_CORE_WRITE_OP_BYTESWAP2
Swap the endianess of 2-bytes values.
Definition: rz_core.h:106

RZ_CORE_WRITE_OP_OR
@ RZ_CORE_WRITE_OP_OR
Write the bitwise-or of existing byte and argument value.
Definition: rz_core.h:114

RZ_CORE_WRITE_OP_ADD
@ RZ_CORE_WRITE_OP_ADD
Write the addition of existing byte and argument value.
Definition: rz_core.h:109

RZ_CORE_WRITE_OP_MUL
@ RZ_CORE_WRITE_OP_MUL
Write the multiplication of existing byte and argument value.
Definition: rz_core.h:112

RZ_CORE_WRITE_OP_DIV
@ RZ_CORE_WRITE_OP_DIV
Write the division of existing byte and argument value.
Definition: rz_core.h:111

RZ_CORE_WRITE_OP_BYTESWAP4
@ RZ_CORE_WRITE_OP_BYTESWAP4
Swap the endianess of 4-bytes values.
Definition: rz_core.h:107

RZ_CORE_WRITE_OP_XOR
@ RZ_CORE_WRITE_OP_XOR
Write the bitwise-xor of existing byte and argument value.
Definition: rz_core.h:115

RZ_CORE_WRITE_OP_SUB
@ RZ_CORE_WRITE_OP_SUB
Write the subtraction of existing byte and argument value.
Definition: rz_core.h:110

RzCoreTimes
struct rz_core_times_t RzCoreTimes

RzCoreTaskScheduler
struct rz_core_tasks_t RzCoreTaskScheduler

rz_core_autocomplete_types_t
rz_core_autocomplete_types_t
Definition: rz_core.h:188

RZ_CORE_AUTOCMPLT_FCN
@ RZ_CORE_AUTOCMPLT_FCN
Definition: rz_core.h:193

RZ_CORE_AUTOCMPLT_MS
@ RZ_CORE_AUTOCMPLT_MS
Definition: rz_core.h:201

RZ_CORE_AUTOCMPLT_BRKP
@ RZ_CORE_AUTOCMPLT_BRKP
Definition: rz_core.h:196

RZ_CORE_AUTOCMPLT_END
@ RZ_CORE_AUTOCMPLT_END
Definition: rz_core.h:204

RZ_CORE_AUTOCMPLT_OPTN
@ RZ_CORE_AUTOCMPLT_OPTN
Definition: rz_core.h:200

RZ_CORE_AUTOCMPLT_MACR
@ RZ_CORE_AUTOCMPLT_MACR
Definition: rz_core.h:197

RZ_CORE_AUTOCMPLT_DFLT
@ RZ_CORE_AUTOCMPLT_DFLT
Definition: rz_core.h:189

RZ_CORE_AUTOCMPLT_EVAL
@ RZ_CORE_AUTOCMPLT_EVAL
Definition: rz_core.h:194

RZ_CORE_AUTOCMPLT_FILE
@ RZ_CORE_AUTOCMPLT_FILE
Definition: rz_core.h:198

RZ_CORE_AUTOCMPLT_SDB
@ RZ_CORE_AUTOCMPLT_SDB
Definition: rz_core.h:202

RZ_CORE_AUTOCMPLT_FLAG
@ RZ_CORE_AUTOCMPLT_FLAG
Definition: rz_core.h:190

RZ_CORE_AUTOCMPLT_MINS
@ RZ_CORE_AUTOCMPLT_MINS
Definition: rz_core.h:195

RZ_CORE_AUTOCMPLT_THME
@ RZ_CORE_AUTOCMPLT_THME
Definition: rz_core.h:199

RZ_CORE_AUTOCMPLT_FLSP
@ RZ_CORE_AUTOCMPLT_FLSP
Definition: rz_core.h:191

RZ_CORE_AUTOCMPLT_SEEK
@ RZ_CORE_AUTOCMPLT_SEEK
Definition: rz_core.h:192

RzCoreSeekItem
struct rz_core_seek_undo_t RzCoreSeekItem

RzCoreVisual
struct rz_core_visual_t RzCoreVisual

RzCoreItem
struct rz_core_item_t RzCoreItem

RzCoreSearchCallback
int(* RzCoreSearchCallback)(RzCore *core, ut64 from, ut8 *buf, int len)
Definition: rz_core.h:419

RzAnalysisDisasmText
struct rz_analysis_disasm_text_t RzAnalysisDisasmText
Message for pdJ

RzCoreFile
struct rz_core_file_t RzCoreFile

RzCoreAutocompleteType
enum rz_core_autocomplete_types_t RzCoreAutocompleteType

RZ_LIB_VERSION_HEADER
RZ_LIB_VERSION_HEADER(rz_core)

RzCorePluginInit
bool(* RzCorePluginInit)(RzCore *core)
Definition: rz_core.h:120

RzCoreIOMapInfo
struct rz_core_io_map_info_t RzCoreIOMapInfo

RzBinSymNames
struct rz_bin_sym_names_t RzBinSymNames
Store some display name from RzBinSymbol.

RAutocompleteType
RAutocompleteType
Definition: rz_core.h:135

AUTOCOMPLETE_MS
@ AUTOCOMPLETE_MS
Definition: rz_core.h:137

AUTOCOMPLETE_DEFAULT
@ AUTOCOMPLETE_DEFAULT
Definition: rz_core.h:136

RzCorePlugin
struct rz_core_plugin_t RzCorePlugin

RzCoreAutocomplete
struct rz_core_autocomplete_t RzCoreAutocomplete

RzCoreVisualMode
RzCoreVisualMode
Definition: rz_core.h:97

RZ_CORE_VISUAL_MODE_PD
@ RZ_CORE_VISUAL_MODE_PD
Disassembly view.
Definition: rz_core.h:99

RZ_CORE_VISUAL_MODE_OV
@ RZ_CORE_VISUAL_MODE_OV
Color blocks (entropy)
Definition: rz_core.h:101

RZ_CORE_VISUAL_MODE_CD
@ RZ_CORE_VISUAL_MODE_CD
Print in string format.
Definition: rz_core.h:102

RZ_CORE_VISUAL_MODE_DB
@ RZ_CORE_VISUAL_MODE_DB
Debug mode.
Definition: rz_core.h:100

RZ_CORE_VISUAL_MODE_PX
@ RZ_CORE_VISUAL_MODE_PX
Hexadecimal view.
Definition: rz_core.h:98

RzCoreTask
struct rz_core_task_t RzCoreTask
Definition: rz_core.h:254

RzCoreTaskBreak
void(* RzCoreTaskBreak)(RzCoreTask *task, void *user)
Definition: rz_core.h:264

rz_crypto.h

rz_debug.h

rz_diff.h

rz_egg.h

rz_flag.h

rz_hash.h

rz_heap_glibc.h

rz_io.h

rz_lang.h

rz_lib.h

rz_magic.h

rz_main.h

RzMainCallback
int(* RzMainCallback)(int argc, const char **argv)
Definition: rz_main.h:34

rz_parse.h

rz_print.h

RzRegisterType
RzRegisterType
Definition: rz_reg.h:20

rz_search.h

rz_sign.h

RzStrEnc
RzStrEnc
Definition: rz_str.h:19

rz_types.h

RZ_NULLABLE
#define RZ_NULLABLE
Definition: rz_types.h:65

RZ_OWN
#define RZ_OWN
Definition: rz_types.h:62

RZ_OUT
#define RZ_OUT
Definition: rz_types.h:51

RZ_NONNULL
#define RZ_NONNULL
Definition: rz_types.h:64

RZ_PRINTF_CHECK
#define RZ_PRINTF_CHECK(fmt, dots)
Definition: rz_types.h:192

RzOutputMode
RzOutputMode
Enum to describe the way data are printed.
Definition: rz_types.h:38

RZ_BORROW
#define RZ_BORROW
Definition: rz_types.h:63

RZ_DEPRECATE
#define RZ_DEPRECATE
Definition: rz_types.h:66

st64
#define st64
Definition: rz_types_base.h:10

UT8_MAX
#define UT8_MAX
Definition: rz_types_base.h:107

rz_util.h

rz_windows_heap.h

rz_core_seek_redo
RZ_API bool rz_core_seek_redo(RzCore *core)
Definition: seek.c:316

rz_core_seek_list
RZ_API RzList * rz_core_seek_list(RzCore *core)
Return the seek history.
Definition: seek.c:411

rz_core_seek_peek
RZ_API RzCoreSeekItem * rz_core_seek_peek(RzCore *core, int idx)
Return a element in the undo/redo list.
Definition: seek.c:361

rz_core_seek_delta
RZ_API bool rz_core_seek_delta(RzCore *core, st64 delta, bool save)
Seek relative to current offset and optionally save the current offset in seek history.
Definition: seek.c:152

rz_core_seek_and_save
RZ_API bool rz_core_seek_and_save(RzCore *core, ut64 addr, bool rb)
Save currently marked state in seek history and seek to addr .
Definition: seek.c:101

rz_core_seek_mark
RZ_API bool rz_core_seek_mark(RzCore *core)
Mark current state (offset+cursor) as the next state to save in history.
Definition: seek.c:57

rz_core_seek_next
RZ_API bool rz_core_seek_next(RzCore *core, const char *type, bool save)
Seek to the next type of item from current offset.
Definition: seek.c:203

rz_core_seek_base
RZ_API int rz_core_seek_base(RzCore *core, const char *hex, bool save)
Seek to a new address composed of current offset with last hex digits replaced with those of hex.
Definition: seek.c:171

rz_core_seek_reset
RZ_API void rz_core_seek_reset(RzCore *core)
Definition: seek.c:388

rz_core_seek_prev
RZ_API bool rz_core_seek_prev(RzCore *core, const char *type, bool save)
Seek to the previous type of item from current offset.
Definition: seek.c:241

rz_core_seek_undo
RZ_API bool rz_core_seek_undo(RzCore *core)
Definition: seek.c:301

rz_core_seek_free
RZ_API void rz_core_seek_free(RzCore *core)
Definition: seek.c:398

rz_core_seek_opt
RZ_API bool rz_core_seek_opt(RzCore *core, ut64 addr, bool rb, bool save)
Seek to addr and optionally save the current offset in seek history.
Definition: seek.c:141

rz_core_seek_item_free
RZ_API void rz_core_seek_item_free(RzCoreSeekItem *item)
Definition: seek.c:7

rz_core_seek_align
RZ_API bool rz_core_seek_align(RzCore *core, ut64 align, bool save)
Seek to current offset aligned to align.
Definition: seek.c:274

rz_core_seek_save
RZ_API bool rz_core_seek_save(RzCore *core)
Save last marked position, if any, in the seek history.
Definition: seek.c:87

rz_core_seek_analysis_bb
RZ_API bool rz_core_seek_analysis_bb(RzCore *core, ut64 addr, bool save)
Seek to basic block that contains address addr.
Definition: seek.c:289

rz_core_seek
RZ_API bool rz_core_seek(RzCore *core, ut64 addr, bool rb)
Seek to addr.
Definition: seek.c:116

rz_serialize_core_load
RZ_API bool rz_serialize_core_load(RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, bool load_bin_io, RZ_NULLABLE const char *prj_file, RZ_NULLABLE RzSerializeResultInfo *res)
Definition: serialize_core.c:69

rz_serialize_core_save
RZ_API void rz_serialize_core_save(RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, RZ_NULLABLE const char *prj_file)
Definition: serialize_core.c:23

from
static struct sockaddr static addrlen static backlog const void static flags void struct sockaddr from
Definition: sfsocketcall.h:123

to
static struct sockaddr static addrlen static backlog const void static flags void struct sockaddr socklen_t static fromlen const void const struct sockaddr to
Definition: sfsocketcall.h:125

flags
static struct sockaddr static addrlen static backlog const void static flags void flags
Definition: sfsocketcall.h:123

int
static int
Definition: sfsocketcall.h:114

msg
static struct sockaddr static addrlen static backlog const void msg
Definition: sfsocketcall.h:119

b
#define b(i)
Definition: sha256.c:42

f
#define f(i)
Definition: sha256.c:46

c
#define c(i)
Definition: sha256.c:43

a
#define a(i)
Definition: sha256.c:41

RzBinDwarfDebugAbbrev
Definition: rz_bin_dwarf.h:798

RzBinDwarfDebugInfo
Definition: rz_bin_dwarf.h:769

RzCoreGadget
Definition: rz_core.h:246

RzCoreGadget::x
int x
Definition: rz_core.h:247

RzCoreGadget::w
int w
Definition: rz_core.h:249

RzCoreGadget::cmd
char * cmd
Definition: rz_core.h:251

RzCoreGadget::y
int y
Definition: rz_core.h:248

RzCoreGadget::h
int h
Definition: rz_core.h:250

RzListInfo
Definition: rz_table.h:25

RzStrBuf
Definition: rz_strbuf.h:10

RzTable
Definition: rz_table.h:43

arg
Definition: sparc-opc.c:1836

bin
Definition: malloc.c:26

code
Definition: inftree9.h:24

dwarf_attr_kind
Definition: rz_bin_dwarf.h:701

file
Definition: gzappend.c:170

filter
Definition: cabextract.c:114

log
Definition: gzlog.c:289

name
Definition: z80asm.h:102

pj_t
Definition: rz_pj.h:12

rz_analysis_disasm_text_t
Message for pdJ
Definition: rz_core.h:443

rz_analysis_disasm_text_t::arrow
ut64 arrow
In general, arrow = UT64_MAX, if there is a jump(jmp, ...), arrow = dst offset.
Definition: rz_core.h:445

rz_analysis_disasm_text_t::text
char * text
Definition: rz_core.h:446

rz_analysis_disasm_text_t::offset
ut64 offset
Definition: rz_core.h:444

rz_analysis_esil_t
Definition: rz_analysis.h:1042

rz_analysis_function_t
Definition: rz_analysis.h:239

rz_analysis_op_t
Definition: rz_analysis.h:811

rz_analysis_t
Definition: rz_analysis.h:553

rz_annotated_code_t
This structure contains the decompiled code and all the annotations for the decompiled code.
Definition: rz_annotated_code.h:79

rz_ascii_graph_t
Definition: rz_agraph.h:46

rz_asm_op_t
Definition: rz_asm.h:66

rz_asm_t
Definition: rz_asm.h:98

rz_backtrace_t
Definition: rz_debug.h:420

rz_bin_class_t
Definition: rz_bin.h:646

rz_bin_field_t
Definition: rz_bin.h:761

rz_bin_file_t
XX curplugin == o->plugin.
Definition: rz_bin.h:298

rz_bin_reloc_t
Definition: rz_bin.h:711

rz_bin_source_line_info_t
Definition: rz_bin.h:478

rz_bin_source_line_sample_t
A single sample of source line info for a specific address.
Definition: rz_bin.h:441

rz_bin_sym_names_t
Store some display name from RzBinSymbol.
Definition: rz_core.h:426

rz_bin_sym_names_t::methname
char * methname
methods [class]::[method]
Definition: rz_core.h:436

rz_bin_sym_names_t::demname
char * demname
demangled raw symbol name
Definition: rz_core.h:432

rz_bin_sym_names_t::methflag
char * methflag
methods flag sym.[class].[method]
Definition: rz_core.h:437

rz_bin_sym_names_t::nameflag
char * nameflag
flag name for symbol
Definition: rz_core.h:431

rz_bin_sym_names_t::classflag
char * classflag
flag for classname
Definition: rz_core.h:435

rz_bin_sym_names_t::name
char * name
raw symbol name
Definition: rz_core.h:428

rz_bin_sym_names_t::symbolname
char * symbolname
display symbol name
Definition: rz_core.h:429

rz_bin_sym_names_t::pfx
const char * pfx
prefix for flags
Definition: rz_core.h:427

rz_bin_sym_names_t::classname
char * classname
classname
Definition: rz_core.h:434

rz_bin_sym_names_t::libname
char * libname
name of the lib this symbol is specific to, if any
Definition: rz_core.h:430

rz_bin_sym_names_t::demflag
char * demflag
flag name for demangled symbol
Definition: rz_core.h:433

rz_bin_symbol_t
Definition: rz_bin.h:673

rz_bin_t
Definition: rz_bin.h:328

rz_buf_t
Definition: rz_buf.h:43

rz_cmd_descriptor_t
Definition: rz_cmd.h:504

rz_cmd_state_output_t
Represent the output state of a command handler.
Definition: rz_cmd.h:91

rz_cmd_t
Definition: rz_cmd.h:478

rz_config_t
Definition: rz_config.h:52

rz_cons_t
Definition: rz_cons.h:501

rz_core_autocomplete_t
Definition: rz_core.h:207

rz_core_autocomplete_t::subcmds
struct rz_core_autocomplete_t ** subcmds
Definition: rz_core.h:213

rz_core_autocomplete_t::length
int length
Definition: rz_core.h:209

rz_core_autocomplete_t::locked
bool locked
Definition: rz_core.h:211

rz_core_autocomplete_t::type
int type
Definition: rz_core.h:212

rz_core_autocomplete_t::cmd
const char * cmd
Definition: rz_core.h:208

rz_core_autocomplete_t::n_subcmds
int n_subcmds
Definition: rz_core.h:210

rz_core_bind_t
Definition: rz_bind.h:30

rz_core_file_t
Definition: rz_core.h:151

rz_core_file_t::binfiles
RzPVector binfiles
all bin files that have been created for this core file
Definition: rz_core.h:155

rz_core_file_t::extra_files
RzPVector extra_files
additional files opened during mapping, for example for zeroed maps
Definition: rz_core.h:156

rz_core_file_t::dbg
int dbg
Definition: rz_core.h:153

rz_core_file_t::core
struct rz_core_t * core
Definition: rz_core.h:152

rz_core_file_t::maps
RzPVector maps
all maps that have been created as a result of loading this file
Definition: rz_core.h:157

rz_core_file_t::fd
int fd
Definition: rz_core.h:154

rz_core_io_map_info_t
Definition: rz_core.h:163

rz_core_io_map_info_t::cf
RzCoreFile * cf
Definition: rz_core.h:164

rz_core_io_map_info_t::perm_orig
int perm_orig
Definition: rz_core.h:174

rz_core_item_t
Definition: rz_core.h:406

rz_core_item_t::addr
ut64 addr
Definition: rz_core.h:408

rz_core_item_t::prev
ut64 prev
Definition: rz_core.h:410

rz_core_item_t::perm
int perm
Definition: rz_core.h:412

rz_core_item_t::type
const char * type
Definition: rz_core.h:407

rz_core_item_t::comment
char * comment
Definition: rz_core.h:414

rz_core_item_t::next
ut64 next
Definition: rz_core.h:409

rz_core_item_t::size
int size
Definition: rz_core.h:411

rz_core_item_t::fcnname
char * fcnname
Definition: rz_core.h:416

rz_core_item_t::sectname
char * sectname
Definition: rz_core.h:415

rz_core_item_t::data
char * data
Definition: rz_core.h:413

rz_core_plugin_t
Definition: rz_core.h:123

rz_core_plugin_t::license
const char * license
Definition: rz_core.h:126

rz_core_plugin_t::version
const char * version
Definition: rz_core.h:128

rz_core_plugin_t::desc
const char * desc
Definition: rz_core.h:125

rz_core_plugin_t::init
RzCorePluginInit init
Definition: rz_core.h:129

rz_core_plugin_t::author
const char * author
Definition: rz_core.h:127

rz_core_plugin_t::name
const char * name
Definition: rz_core.h:124

rz_core_plugin_t::fini
RzCorePluginFini fini
Definition: rz_core.h:130

rz_core_rtr_host_t
Definition: rtr.c:32

rz_core_seek_history_t
Definition: rz_core.h:290

rz_core_seek_history_t::saved_item
RzCoreSeekItem saved_item
Position to save in history.
Definition: rz_core.h:294

rz_core_seek_history_t::undos
RzVector undos
Stack of RzCoreSeekItems, allowing to "go back in time".
Definition: rz_core.h:291

rz_core_seek_history_t::redos
RzVector redos
Stack of RzCoreSeekItems, allowing to re-do an action that was undone.
Definition: rz_core.h:292

rz_core_seek_history_t::saved_set
bool saved_set
When true, the saved field is set.
Definition: rz_core.h:293

rz_core_seek_undo_t
Definition: rz_core.h:144

rz_core_seek_undo_t::idx
int idx
Position of the item relative to the current seek item (0 current seek, < 0 for undos,...
Definition: rz_core.h:148

rz_core_seek_undo_t::offset
ut64 offset
Value of core->offset at the given time in history.
Definition: rz_core.h:145

rz_core_seek_undo_t::is_current
bool is_current
True if this is the current seek value.
Definition: rz_core.h:147

rz_core_seek_undo_t::cursor
int cursor
Position of the cursor at the given time in history.
Definition: rz_core.h:146

rz_core_t
Definition: rz_core.h:297

rz_core_t::rz_main_rz_asm
int(* rz_main_rz_asm)(int argc, const char **argv)
Definition: rz_core.h:401

rz_core_t::vmode
bool vmode
Definition: rz_core.h:309

rz_core_t::yank_addr
ut64 yank_addr
Definition: rz_core.h:307

rz_core_t::marks
ut64 marks[UT8_MAX+1]
Definition: rz_core.h:392

rz_core_t::break_loop
bool break_loop
Definition: rz_core.h:373

rz_core_t::yank_buf
RzBuffer * yank_buf
Definition: rz_core.h:306

rz_core_t::cons
RzCons * cons
Definition: rz_core.h:312

rz_core_t::rtr_host
RzCoreRtrHost * rtr_host
Definition: rz_core.h:345

rz_core_t::cmdlog
char * cmdlog
Definition: rz_core.h:340

rz_core_t::autocomplete
RzCoreAutocomplete * autocomplete
Definition: rz_core.h:380

rz_core_t::scr_gadgets
bool scr_gadgets
Definition: rz_core.h:385

rz_core_t::printidx
RzCoreVisualMode printidx
Definition: rz_core.h:357

rz_core_t::cmdrepeat
int cmdrepeat
Definition: rz_core.h:341

rz_core_t::visual_is_inputing
bool visual_is_inputing
Definition: rz_core.h:353

rz_core_t::files
RzList * files
Definition: rz_core.h:315

rz_core_t::rz_main_rz_bin
int(* rz_main_rz_bin)(int argc, const char **argv)
Definition: rz_core.h:398

rz_core_t::search
RzSearch * search
Definition: rz_core.h:331

rz_core_t::is_lastcmd
bool is_lastcmd
Definition: rz_core.h:338

rz_core_t::rc
ut64 rc
Definition: rz_core.h:317

rz_core_t::egg
RzEgg * egg
Definition: rz_core.h:332

rz_core_t::rcmd
RzCmd * rcmd
Definition: rz_core.h:319

rz_core_t::cmdqueue
char * cmdqueue
Definition: rz_core.h:336

rz_core_t::bin
RzBin * bin
Definition: rz_core.h:298

rz_core_t::interrupted
int interrupted
Definition: rz_core.h:310

rz_core_t::offset
ut64 offset
Definition: rz_core.h:301

rz_core_t::rz_main_rz_gg
int(* rz_main_rz_gg)(int argc, const char **argv)
Definition: rz_core.h:400

rz_core_t::rasm
RzAsm * rasm
Definition: rz_core.h:323

rz_core_t::lastcmd
char * lastcmd
Definition: rz_core.h:337

rz_core_t::lang
RzLang * lang
Definition: rz_core.h:328

rz_core_t::max_cmd_depth
int max_cmd_depth
Definition: rz_core.h:363

rz_core_t::blocksize_max
ut32 blocksize_max
Definition: rz_core.h:304

rz_core_t::analysis
RzAnalysis * analysis
Definition: rz_core.h:322

rz_core_t::marks_init
bool marks_init
Definition: rz_core.h:391

rz_core_t::rz_main_rz_ax
int(* rz_main_rz_ax)(int argc, const char **argv)
Definition: rz_core.h:402

rz_core_t::rtr_n
int rtr_n
Definition: rz_core.h:344

rz_core_t::rz_main_rz_run
int(* rz_main_rz_run)(int argc, const char **argv)
Definition: rz_core.h:399

rz_core_t::table_query
char * table_query
Definition: rz_core.h:378

rz_core_t::c2
struct rz_core_t * c2
Definition: rz_core.h:379

rz_core_t::seltab
int seltab
Definition: rz_core.h:368

rz_core_t::dbg
RzDebug * dbg
Definition: rz_core.h:329

rz_core_t::panels
RzPanels * panels
Definition: rz_core.h:335

rz_core_t::gdbserver_up
int gdbserver_up
Definition: rz_core.h:356

rz_core_t::io
RzIO * io
Definition: rz_core.h:313

rz_core_t::ev
RzEvent * ev
Definition: rz_core.h:383

rz_core_t::cmdtimes
const char * cmdtimes
Definition: rz_core.h:342

rz_core_t::ropchain
RzList * ropchain
Definition: rz_core.h:387

rz_core_t::asmqjmps_size
int asmqjmps_size
Definition: rz_core.h:348

rz_core_t::asmqjmps_count
int asmqjmps_count
Definition: rz_core.h:347

rz_core_t::root_cmd_descriptor
RzCmdDescriptor root_cmd_descriptor
Definition: rz_core.h:320

rz_core_t::keep_asmqjmps
bool keep_asmqjmps
Definition: rz_core.h:350

rz_core_t::num
RzNum * num
Definition: rz_core.h:316

rz_core_t::lib
RzLib * lib
Definition: rz_core.h:318

rz_core_t::fixedbits
bool fixedbits
Definition: rz_core.h:375

rz_core_t::rz_main_rizin
RzMainCallback rz_main_rizin
Definition: rz_core.h:394

rz_core_t::cmd_in_backticks
RZ_DEPRECATE bool cmd_in_backticks
Definition: rz_core.h:343

rz_core_t::asmqjmps
ut64 * asmqjmps
Definition: rz_core.h:346

rz_core_t::scriptstack
RzList * scriptstack
Definition: rz_core.h:361

rz_core_t::graph
RzAGraph * graph
Definition: rz_core.h:333

rz_core_t::binat
bool binat
Definition: rz_core.h:374

rz_core_t::rz_main_rz_diff
int(* rz_main_rz_diff)(int argc, const char **argv)
Definition: rz_core.h:397

rz_core_t::watchers
RzList * watchers
Definition: rz_core.h:360

rz_core_t::plugins
RzList * plugins
List of registered core plugins.
Definition: rz_core.h:299

rz_core_t::log_events
bool log_events
Definition: rz_core.h:386

rz_core_t::parser
RzParse * parser
Definition: rz_core.h:326

rz_core_t::tasks
RzCoreTaskScheduler tasks
Definition: rz_core.h:362

rz_core_t::visual
RzCoreVisual visual
Definition: rz_core.h:351

rz_core_t::autocomplete_type
int autocomplete_type
Definition: rz_core.h:381

rz_core_t::curtab
int curtab
Definition: rz_core.h:367

rz_core_t::is_pipe
bool is_pipe
Definition: rz_core.h:339

rz_core_t::incomment
int incomment
Definition: rz_core.h:366

rz_core_t::prompt_offset
ut64 prompt_offset
Definition: rz_core.h:302

rz_core_t::cmd_descriptors
RzList * cmd_descriptors
Definition: rz_core.h:321

rz_core_t::maxtab
int maxtab
Definition: rz_core.h:382

rz_core_t::tmpseek
bool tmpseek
Definition: rz_core.h:308

rz_core_t::sdb
Sdb * sdb
Definition: rz_core.h:365

rz_core_t::stkcmd
char * stkcmd
Definition: rz_core.h:358

rz_core_t::block
ut8 * block
Definition: rz_core.h:305

rz_core_t::gadgets
RzList * gadgets
Definition: rz_core.h:384

rz_core_t::flags
RzFlag * flags
Definition: rz_core.h:330

rz_core_t::cmdfilter
char * cmdfilter
Definition: rz_core.h:371

rz_core_t::fixedblock
bool fixedblock
Definition: rz_core.h:377

rz_core_t::rz_main_rz_find
int(* rz_main_rz_find)(int argc, const char **argv)
Definition: rz_core.h:396

rz_core_t::switch_file_view
ut8 switch_file_view
Definition: rz_core.h:364

rz_core_t::curtheme
char * curtheme
Definition: rz_core.h:372

rz_core_t::fixedarch
bool fixedarch
Definition: rz_core.h:376

rz_core_t::panels_root
RzPanelsRoot * panels_root
Definition: rz_core.h:334

rz_core_t::seek_history
RzCoreSeekHistory seek_history
Definition: rz_core.h:388

rz_core_t::in_search
bool in_search
Definition: rz_core.h:359

rz_core_t::print
RzPrint * print
Definition: rz_core.h:327

rz_core_t::cmdremote
char * cmdremote
Definition: rz_core.h:369

rz_core_t::hash
RzHash * hash
Definition: rz_core.h:389

rz_core_t::lastsearch
char * lastsearch
Definition: rz_core.h:370

rz_core_t::file
RzCoreFile * file
Definition: rz_core.h:314

rz_core_t::blocksize
ut32 blocksize
Definition: rz_core.h:303

rz_core_t::visual_inputing
char * visual_inputing
Definition: rz_core.h:354

rz_core_t::is_asmqjmps_letter
bool is_asmqjmps_letter
Definition: rz_core.h:349

rz_core_t::config
RzConfig * config
Definition: rz_core.h:300

rz_core_t::times
RzCoreTimes * times
Definition: rz_core.h:325

rz_core_t::http_up
int http_up
Definition: rz_core.h:355

rz_core_tasks_t
Definition: rz_core.h:266

rz_core_tasks_t::oneshots_enqueued
int oneshots_enqueued
Definition: rz_core.h:275

rz_core_tasks_t::lock
RzThreadLock * lock
Definition: rz_core.h:278

rz_core_tasks_t::tasks_queue
RzList * tasks_queue
Definition: rz_core.h:273

rz_core_tasks_t::ctx_switch
RzCoreTaskContextSwitch ctx_switch
Definition: rz_core.h:267

rz_core_tasks_t::ctx_switch_user
void * ctx_switch_user
Definition: rz_core.h:268

rz_core_tasks_t::tasks_running
int tasks_running
Definition: rz_core.h:279

rz_core_tasks_t::break_cb
RzCoreTaskBreak break_cb
Definition: rz_core.h:269

rz_core_tasks_t::oneshot_running
bool oneshot_running
Definition: rz_core.h:280

rz_core_tasks_t::tasks
RzList * tasks
Definition: rz_core.h:272

rz_core_tasks_t::current_task
struct rz_core_task_t * current_task
Definition: rz_core.h:276

rz_core_tasks_t::oneshot_queue
RzList * oneshot_queue
Definition: rz_core.h:274

rz_core_tasks_t::break_cb_user
void * break_cb_user
Definition: rz_core.h:270

rz_core_tasks_t::task_id_next
int task_id_next
Definition: rz_core.h:271

rz_core_tasks_t::main_task
struct rz_core_task_t * main_task
Definition: rz_core.h:277

rz_core_times_t
Definition: rz_core.h:177

rz_core_times_t::file_open_time
ut64 file_open_time
Definition: rz_core.h:180

rz_core_times_t::loadlibs_init_time
ut64 loadlibs_init_time
Definition: rz_core.h:178

rz_core_times_t::loadlibs_time
ut64 loadlibs_time
Definition: rz_core.h:179

rz_core_visual_t
Definition: rz_core.h:240

rz_core_visual_t::tabs
RzList * tabs
Definition: rz_core.h:241

rz_core_visual_t::tab
int tab
Definition: rz_core.h:242

rz_core_visual_tab_t
Definition: rz_core.h:216

rz_core_visual_tab_t::ocur
int ocur
Definition: rz_core.h:221

rz_core_visual_tab_t::current5format
int current5format
Definition: rz_core.h:233

rz_core_visual_tab_t::hexMode
int hexMode
Definition: rz_core.h:224

rz_core_visual_tab_t::cur
int cur
Definition: rz_core.h:220

rz_core_visual_tab_t::offset
ut64 offset
Definition: rz_core.h:218

rz_core_visual_tab_t::printidx
int printidx
Definition: rz_core.h:217

rz_core_visual_tab_t::printMode
int printMode
Definition: rz_core.h:230

rz_core_visual_tab_t::asm_instr
int asm_instr
Definition: rz_core.h:226

rz_core_visual_tab_t::dumpCols
int dumpCols
Definition: rz_core.h:234

rz_core_visual_tab_t::asm_cmt_col
int asm_cmt_col
Definition: rz_core.h:229

rz_core_visual_tab_t::cols
int cols
Definition: rz_core.h:222

rz_core_visual_tab_t::asm_bytes
int asm_bytes
Definition: rz_core.h:228

rz_core_visual_tab_t::cur_enabled
bool cur_enabled
Definition: rz_core.h:219

rz_core_visual_tab_t::asm_offset
int asm_offset
Definition: rz_core.h:225

rz_core_visual_tab_t::current3format
int current3format
Definition: rz_core.h:231

rz_core_visual_tab_t::asm_indent
int asm_indent
Definition: rz_core.h:227

rz_core_visual_tab_t::disMode
int disMode
Definition: rz_core.h:223

rz_core_visual_tab_t::current4format
int current4format
Definition: rz_core.h:232

rz_debug_t
Definition: rz_debug.h:241

rz_egg_t
Definition: rz_egg.h:93

rz_event_t
Definition: rz_event.h:14

rz_flag_item_t
Definition: rz_flag.h:34

rz_flag_t
Definition: rz_flag.h:46

rz_graph_t
Definition: rz_graph.h:25

rz_hash_t
Definition: rz_hash.h:41

rz_heap_bin
Definition: rz_heap_glibc.h:295

rz_heap_chunk_simple
Definition: rz_heap_glibc.h:282

rz_interval_t
Definition: rz_itv.h:13

rz_io_desc_t
Definition: rz_io.h:95

rz_io_t
Definition: rz_io.h:59

rz_lang_t
Definition: rz_lang.h:17

rz_lib_t
Definition: rz_lib.h:89

rz_line_buffer_t
Definition: rz_cons.h:1021

rz_line_comp_t
Definition: rz_cons.h:1043

rz_line_ns_completion_result_t
Definition: rz_cons.h:1059

rz_line_t
Definition: rz_cons.h:1088

rz_list_t
Definition: rz_list.h:18

rz_malloc_state
Definition: rz_heap_glibc.h:217

rz_num_t
Definition: rz_num.h:59

rz_panels_root_t
Definition: rz_cons.h:1232

rz_panels_t
Definition: rz_cons.h:1203

rz_parse_t
Definition: rz_parse.h:20

rz_pdb_t
Definition: rz_pdb.h:241

rz_print_t
Definition: rz_print.h:109

rz_pvector_t
Definition: rz_vector.h:55

rz_reg_t
Definition: rz_reg.h:144

rz_search_t
Definition: rz_search.h:54

rz_th_cond_t
Definition: thread.h:80

rz_th_lock_t
Definition: thread.h:76

rz_th_sem_t
Definition: thread.h:72

rz_th_t
Definition: thread.h:84

rz_type_db_t
Definition: rz_type.h:31

rz_vector_t
Definition: rz_vector.h:45

sdb_t
Definition: sdb.h:63

state
Definition: dis.h:43

command
const char * command
Definition: main.c:7

pos
int pos
Definition: main.c:11

valid
bool valid
Definition: core.c:77

maxlen
ut64 maxlen
Definition: core.c:76

buflen
ut64 buflen
Definition: core.c:76

blocks
uint64_t blocks
Definition: list.c:104

bool
#define bool
Definition: sysdefs.h:146

rz_core_task_is_cmd
RZ_API bool rz_core_task_is_cmd(RzCore *core, int id)
Definition: task.c:834

rz_core_task_join
RZ_API void rz_core_task_join(RzCoreTaskScheduler *scheduler, RzCoreTask *current, int id)
Definition: task.c:96

rz_core_task_scheduler_init
RZ_API void rz_core_task_scheduler_init(RzCoreTaskScheduler *sched, RzCoreTaskContextSwitch ctx_switch, void *ctx_switch_user, RzCoreTaskBreak break_cb, void *break_cb_user)
Definition: task.c:7

rz_core_task_new
RZ_API RzCoreTask * rz_core_task_new(RzCoreTaskScheduler *sched, RzCoreTaskRunner runner, RzCoreTaskRunnerFree runner_free, void *runner_user)
Definition: task.c:161

rz_core_task_decref
RZ_API void rz_core_task_decref(RzCoreTask *task)
Definition: task.c:200

rz_core_task_break_all
RZ_API void rz_core_task_break_all(RzCoreTaskScheduler *scheduler)
Definition: task.c:495

rz_core_task_sync_end
RZ_API void rz_core_task_sync_end(RzCoreTaskScheduler *scheduler)
Definition: task.c:432

rz_core_task_scheduler_fini
RZ_API void rz_core_task_scheduler_fini(RzCoreTaskScheduler *tasks)
Definition: task.c:27

rz_core_task_print
RZ_API void rz_core_task_print(RzCore *core, RzCoreTask *task, int mode, PJ *j)
Definition: task.c:758

rz_core_task_enqueue_oneshot
RZ_API void rz_core_task_enqueue_oneshot(RzCoreTaskScheduler *scheduler, RzCoreTaskOneShot func, void *user)
Definition: task.c:391

rz_core_task_sleep_end
RZ_API void rz_core_task_sleep_end(RzCoreTask *task)
Definition: task.c:442

rz_core_task_incref
RZ_API void rz_core_task_incref(RzCoreTask *task)
Definition: task.c:190

rz_core_task_del
RZ_API int rz_core_task_del(RzCoreTaskScheduler *scheduler, int id)
Definition: task.c:508

rz_core_task_del_all_done
RZ_API void rz_core_task_del_all_done(RzCore *core)
Definition: task.c:844

rz_core_task_running_tasks_count
RZ_API int rz_core_task_running_tasks_count(RzCoreTaskScheduler *scheduler)
Definition: task.c:71

rz_core_task_run_sync
RZ_API int rz_core_task_run_sync(RzCoreTaskScheduler *scheduler, RzCoreTask *task)
Definition: task.c:415

rz_core_function_task_new
RZ_API RzCoreTask * rz_core_function_task_new(RzCore *core, RzCoreTaskFunction fcn, void *fcn_user)
Definition: task.c:700

rz_core_task_enqueue
RZ_API void rz_core_task_enqueue(RzCoreTaskScheduler *scheduler, RzCoreTask *task)
Definition: task.c:374

rz_core_task_get_incref
RZ_API RzCoreTask * rz_core_task_get_incref(RzCoreTaskScheduler *scheduler, int id)
Definition: task.c:461

rz_core_cmd_task_new
RZ_API RzCoreTask * rz_core_cmd_task_new(RzCore *core, const char *cmd, RzCoreCmdTaskFinished finished_cb, void *finished_cb_user)
Definition: task.c:629

rz_core_task_list
RZ_API void rz_core_task_list(RzCore *core, int mode)
Definition: task.c:811

rz_core_task_sleep_begin
RZ_API void rz_core_task_sleep_begin(RzCoreTask *task)
Definition: task.c:438

rz_core_task_yield
RZ_API void rz_core_task_yield(RzCoreTaskScheduler *scheduler)
Definition: task.c:336

rz_core_cmd_task_get_result
RZ_API const char * rz_core_cmd_task_get_result(RzCoreTask *task)
Definition: task.c:646

rz_core_task_sync_begin
RZ_API void rz_core_task_sync_begin(RzCoreTaskScheduler *scheduler)
Definition: task.c:421

rz_core_task_break
RZ_API void rz_core_task_break(RzCoreTaskScheduler *scheduler, int id)
Definition: task.c:483

rz_core_task_self
RZ_API RzCoreTask * rz_core_task_self(RzCoreTaskScheduler *scheduler)
Definition: task.c:446

rz_core_function_task_get_result
RZ_API void * rz_core_function_task_get_result(RzCoreTask *task)
Definition: task.c:718

rz_core_task_status
RZ_API const char * rz_core_task_status(RzCoreTask *task)
Definition: task.c:743

lock
static void lock(volatile int *lk)
Definition: malloc.c:61

op
Definition: dis.c:32

rz_core_visual_asm
RZ_API void rz_core_visual_asm(RzCore *core, ut64 off)
Definition: vasm.c:73

rz_core_print_scrollbar_bottom
RZ_API void rz_core_print_scrollbar_bottom(RzCore *core)
Definition: visual.c:3608

color
static int color
Definition: visual.c:20

rz_core_visual_toggle_decompiler_disasm
RZ_API void rz_core_visual_toggle_decompiler_disasm(RzCore *core, bool for_graph, bool reset)
Definition: visual.c:127

rz_core_visual_prevopsz
RZ_API int rz_core_visual_prevopsz(RzCore *core, ut64 addr)
Definition: visual.c:1272

rz_core_visual_offset
RZ_API void rz_core_visual_offset(RzCore *core)
Definition: visual.c:1247

rz_core_visual_seek_animation_undo
RZ_API void rz_core_visual_seek_animation_undo(RzCore *core)
Definition: visual.c:1088

rz_core_visual_applyDisMode
RZ_API void rz_core_visual_applyDisMode(RzCore *core, int disMode)
Definition: visual.c:174

rz_core_visual_disasm_up
RZ_API void rz_core_visual_disasm_up(RzCore *core, int *cols)
Definition: visual.c:3802

rz_core_visual_hud
RZ_API bool rz_core_visual_hud(RzCore *core)
Definition: visual.c:471

rz_core_visual_cmd
RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg)
Definition: visual.c:2232

rz_core_visual_append_help
RZ_API void rz_core_visual_append_help(RzStrBuf *p, const char *title, const char **help)
Definition: visual.c:532

rz_core_prevop_addr
RZ_API bool rz_core_prevop_addr(RzCore *core, ut64 start_addr, int numinstrs, ut64 *prev_addr)
Definition: visual.c:1173

rz_core_visual_prompt_input
RZ_API void rz_core_visual_prompt_input(RzCore *core)
Definition: visual.c:733

rz_core_visual_prompt
RZ_API int rz_core_visual_prompt(RzCore *core)
Definition: visual.c:756

rz_core_visual_browse
RZ_API void rz_core_visual_browse(RzCore *core, const char *input)
Definition: visual.c:2067

rz_core_print_scrollbar
RZ_API void rz_core_print_scrollbar(RzCore *core)
Definition: visual.c:3541

rz_listinfo_new
RZ_API RzListInfo * rz_listinfo_new(const char *name, RzInterval pitv, RzInterval vitv, int perm, const char *extra)
Definition: visual.c:4020

rz_core_visual_applyHexMode
RZ_API void rz_core_visual_applyHexMode(RzCore *core, int hexMode)
Definition: visual.c:84

rz_core_visual
RZ_API int rz_core_visual(RzCore *core, const char *input)
Definition: visual.c:3856

rz_core_visual_disasm_down
RZ_API void rz_core_visual_disasm_down(RzCore *core, RzAsmOp *op, int *cols)
Definition: visual.c:3806

rz_core_visual_xrefs
RZ_API int rz_core_visual_xrefs(RzCore *core, bool xref_to, bool fcnInsteadOfAddr)
Definition: visual.c:1312

rz_listinfo_free
RZ_API void rz_listinfo_free(RzListInfo *info)
Definition: visual.c:4032

rz_core_visual_toggle_hints
RZ_API void rz_core_visual_toggle_hints(RzCore *core)
Definition: visual.c:109

rz_core_visual_showcursor
RZ_API void rz_core_visual_showcursor(RzCore *core, int x)
Definition: visual.c:420

rz_core_prevop_addr_force
RZ_API ut64 rz_core_prevop_addr_force(RzCore *core, ut64 start_addr, int numinstrs)
Definition: visual.c:1195

rz_core_visual_jump
RZ_API void rz_core_visual_jump(RzCore *core, ut8 ch)
Definition: visual.c:514

rz_core_visual_seek_animation
RZ_API void rz_core_visual_seek_animation(RzCore *core, ut64 addr)
Definition: visual.c:1077

rz_line_hist_offset_up
RZ_API int rz_line_hist_offset_up(RzLine *line)
Definition: visual.c:1222

rz_line_hist_offset_down
RZ_API int rz_line_hist_offset_down(RzLine *line)
Definition: visual.c:1235

rz_core_visual_seek_animation_redo
RZ_API void rz_core_visual_seek_animation_redo(RzCore *core)
Definition: visual.c:1082

hexMode
static int hexMode
Definition: visual.c:18

rz_core_visual_mark
RZ_API void rz_core_visual_mark(RzCore *core, ut8 ch)
Definition: vmarks.c:47

rz_core_visual_mark_dump
RZ_API bool rz_core_visual_mark_dump(RzCore *core)
Definition: vmarks.c:14

rz_core_visual_mark_seek
RZ_API void rz_core_visual_mark_seek(RzCore *core, ut8 ch)
Definition: vmarks.c:54

rz_core_visual_mark_set
RZ_API void rz_core_visual_mark_set(RzCore *core, ut8 ch, ut64 addr)
Definition: vmarks.c:33

rz_core_visual_mark_del
RZ_API void rz_core_visual_mark_del(RzCore *core, ut8 ch)
Definition: vmarks.c:40

rz_core_visual_mark_reset
RZ_API void rz_core_visual_mark_reset(RzCore *core)
Definition: vmarks.c:6

rz_core_visual_comments
RZ_API int rz_core_visual_comments(RzCore *core)
Definition: vmenus.c:1793

rz_core_visual_define
RZ_API void rz_core_visual_define(RzCore *core, const char *args, int distance)
Definition: vmenus.c:3149

rz_core_visual_view_rop
RZ_API int rz_core_visual_view_rop(RzCore *core)
Definition: vmenus.c:1232

rz_core_visual_debugtraces
RZ_API void rz_core_visual_debugtraces(RzCore *core, const char *input)
Definition: vmenus.c:2634

rz_core_visual_analysis
RZ_API void rz_core_visual_analysis(RzCore *core, const char *input)
Definition: vmenus.c:2739

rz_core_visual_esil
RZ_API bool rz_core_visual_esil(RzCore *core)
Definition: vmenus.c:89

rz_core_visual_config
RZ_API void rz_core_visual_config(RzCore *core)
Definition: vmenus.c:1984

rz_core_visual_trackflags
RZ_API int rz_core_visual_trackflags(RzCore *core)
Definition: vmenus.c:1485

rz_core_visual_bit_editor
RZ_API bool rz_core_visual_bit_editor(RzCore *core)
Definition: vmenus.c:234

rz_core_visual_hudstuff
RZ_API bool rz_core_visual_hudstuff(RzCore *core)
Definition: vmenus.c:539

delta
static st64 delta
Definition: vmenus.c:2425

rz_core_visual_colors
RZ_API void rz_core_visual_colors(RzCore *core)
Definition: vmenus.c:3615

rz_core_visual_analysis_classes
RZ_API int rz_core_visual_analysis_classes(RzCore *core)
Definition: vmenus.c:1077

rz_core_visual_classes
RZ_API int rz_core_visual_classes(RzCore *core)
Definition: vmenus.c:786

rz_core_visual_view_graph
RZ_API int rz_core_visual_view_graph(RzCore *core)
Definition: vmenus_graph.c:255

rz_str_widget_list
RZ_API char * rz_str_widget_list(void *user, RzList *list, int rows, int cur, PrintItemCallback cb)
Definition: vmenus_graph.c:9

breaked
static bool breaked
Definition: windows_debug.c:815

ut64
ut64(WINAPI *w32_GetEnabledXStateFeatures)()

rz_core_yank_to
RZ_API bool rz_core_yank_to(RzCore *core, ut64 len, ut64 addr)
Definition: yank.c:193

rz_core_yank_hud_file
RZ_API bool rz_core_yank_hud_file(RzCore *core, const char *input)
Definition: yank.c:333

rz_core_yank
RZ_API bool rz_core_yank(RzCore *core, ut64 addr, ut64 len)
Definition: yank.c:118

rz_core_yank_set_str
RZ_API bool rz_core_yank_set_str(RzCore *core, ut64 addr, RZ_NONNULL const char *str)
Definition: yank.c:101

rz_core_yank_set
RZ_API bool rz_core_yank_set(RzCore *core, ut64 addr, RZ_NONNULL const ut8 *buf, ut64 len)
Definition: yank.c:82

rz_core_yank_hexpair
RZ_API bool rz_core_yank_hexpair(RzCore *core, const char *str)
Definition: yank.c:362

rz_core_yank_file_all
RZ_API bool rz_core_yank_file_all(RzCore *core, const char *filename)
Definition: yank.c:398

rz_core_yank_hud_path
RZ_API bool rz_core_yank_hud_path(RzCore *core, const char *input, int dir)
Definition: yank.c:346

rz_core_yank_file
RZ_API bool rz_core_yank_file(RzCore *core, ut64 len, ut64 addr, const char *filename)
Definition: yank.c:384

rz_core_yank_string
RZ_API bool rz_core_yank_string(RzCore *core, ut64 addr, ut64 maxlen)
Definition: yank.c:147

rz_core_yank_print_string
RZ_API bool rz_core_yank_print_string(RzCore *core, ut64 pos)
Definition: yank.c:311

rz_core_yank_dump
RZ_API bool rz_core_yank_dump(RzCore *core, ut64 pos, RzCmdStateOutput *state)
Definition: yank.c:219

rz_core_yank_paste
RZ_API bool rz_core_yank_paste(RzCore *core, ut64 addr, ut64 len)
Definition: yank.c:174

rz_core_yank_print
RZ_API bool rz_core_yank_print(RzCore *core, ut64 pos)
Definition: yank.c:288

rz_core_yank_as_string
RZ_API RZ_OWN char * rz_core_yank_as_string(RzCore *core, ut64 pos)
Definition: yank.c:203

rz_core_yank_print_hexdump
RZ_API bool rz_core_yank_print_hexdump(RzCore *core, ut64 pos)
Definition: yank.c:267

fd
static const z80_opcode fd[]
Definition: z80_tab.h:997

cb
static const char * cb[]
Definition: z80_tab.h:176

verbose
static int verbose
Definition: z80asm.c:73

baseaddr
static int baseaddr
Definition: z80asm.c:79

addr
static int addr
Definition: z80asm.c:58

reftype
reftype
Definition: z80asm.h:66

input
static bool input(void *ud, zip_uint8_t *data, zip_uint64_t length)
Definition: zip_algorithm_bzip2.c:190

inf
int inf(FILE *source, FILE *dest)
Definition: zpipe.c:92