NAME

       r_util — radare2 utility library

SYNOPSIS

       #include <r_util.h>

DESCRIPTION

       The r_util library provides a comprehensive collection of utility functions for radare2, including number
       parsing,  string  manipulation,  buffer  management,  memory  operations, file handling, and various data
       structures. It serves as the foundation for many other radare2 libraries.

NUMBERS

       Parse and format numeric values, convert textual representations into integers, recognize  human-friendly
       unit suffixes, and evaluate simple mathematical expressions. Useful for configuration parsing, user input
       handling and preparing numbers for display.

       RNum * r_num_new(RNumCallback cb, RNumCallback2 cb2, void *ptr)

       Creates a new number parsing context with custom callbacks.

       ut64 r_num_get(RNum *num, const char *str)

       Parses a string into a 64-bit unsigned integer, supporting various formats.

       ut64 r_num_math(RNum *num, const char *str)

       Evaluates mathematical expressions in strings.

       char * r_num_units(char *buf, size_t len, ut64 number)

       Formats a number with appropriate units (KB, MB, etc.).

BUFFERS

       Create  and  manipulate in-memory buffers that support reading, writing, seeking and size queries — handy
       for temporary storage, streaming data between components, or abstracting underlying storage.

       RBuffer * r_buf_new(void)

       Creates a new buffer.

       st64 r_buf_read(RBuffer *b, ut8 *buf, ut64 len)

       Reads data from a buffer.

       st64 r_buf_write(RBuffer *b, const ut8 *buf, ut64 len)

       Writes data to a buffer.

       st64 r_buf_seek(RBuffer *b, st64 addr, int whence)

       Seeks to a position in the buffer.

       ut64 r_buf_size(RBuffer *b)

       Returns the size of the buffer.

STRINGS

       Common string helpers for allocation, concatenation, searching, replacement and splitting. They make safe
       text manipulation and higher-level processing simpler and less error-prone.

       char * r_str_new(const char *str)

       Creates a new string (duplicate).

       char * r_str_append(char *str, const char *new)

       Appends a string to another.

       bool r_str_startswith(const char *str, const char *needle)

       Checks if a string starts with a prefix.

       char * r_str_replace(char *str, const char *find, const char *replace, int *count)

       Replaces substrings in a string.

       RList * r_str_split_list(char *str, const char *c, int n)

       Splits a string into a list.

LISTS

       Lightweight linked-list utilities for creating, appending, indexing and querying lists of  pointers.  Use
       these when a simple ordered collection is sufficient.

       RList * r_list_new(void)

       Creates a new linked list.

       void r_list_append(RList *list, void *data)

       Appends data to a list.

       void * r_list_get_n(RList *list, int n)

       Gets the nth element from a list.

       int r_list_length(RList *list)

       Returns the length of a list.

MEMORY

       Convenience  wrappers  for  allocating,  duplicating  and  comparing  raw  memory  blocks.  These helpers
       centralize  routine  memory  tasks  and  can  be  adapted  for  custom  allocator  hooks   or   debugging
       instrumentation.

       void * r_mem_alloc(size_t sz)

       Allocates memory.

       void * r_mem_dup(const void *src, size_t len)

       Duplicates memory.

       int r_mem_cmp(const void *a, const void *b, size_t len)

       Compares memory regions.

FILES

       Simple  filesystem  helpers to check existence, read entire files into memory, and write buffers to disk.
       Intended for straightforward file I/O needs in tools and utilities.

       bool r_file_exists(const char *str)

       Checks if a file exists.

       char * r_file_slurp(const char *str, size_t *usz)

       Reads an entire file into memory.

       bool r_file_dump(const char *file, const ut8 *buf, int len, bool append)

       Writes data to a file.

HEX

       Routines to convert between hexadecimal text and binary data, commonly used when  presenting  or  parsing
       hex-encoded blobs.

       int r_hex_str2bin(const char *str, ut8 *buf)

       Converts a hex string to binary.

       char * r_hex_bin2str(const ut8 *bin, int len)

       Converts binary data to a hex string.

BASE64

       Utilities to encode binary data to base64 and decode it back, useful for transporting or embedding binary
       content in text contexts.

       char * r_base64_encode(const ut8 *bin, int len)

       Encodes data to base64.

       ut8 * r_base64_decode(const char *str, int *olen)

       Decodes base64 data.

TABLES

       Helpers  for  building  textual tables: create table objects, add columns and rows, and format output for
       display when presenting structured, columnar data.

       RTable * r_table_new(void)

       Creates a new table.

       void r_table_add_column(RTable *t, RTableColumnType *type, const char *name, int maxwidth)

       Adds a column to a table.

       void r_table_add_row(RTable *t, const char *name, ...)

       Adds a row to a table.

GRAPHS

       APIs to build and traverse basic graph structures made of nodes  and  edges.  Suitable  for  representing
       relationships, control-flow, or dependency graphs.

       RGraph * r_graph_new(void)

       Creates a new graph.

       RGraphNode * r_graph_add_node(RGraph *graph, void *data)

       Adds a node to a graph.

       void r_graph_add_edge(RGraph *graph, RGraphNode *from, RGraphNode *to)

       Adds an edge between nodes.

QUEUES

       A  compact  FIFO  queue  API  for  enqueuing  and dequeuing pointer elements; useful in producer/consumer
       patterns and simple task scheduling.

       RQueue * r_queue_new(int n)

       Creates a new queue.

       void r_queue_enqueue(RQueue *q, void *el)

       Enqueues an element.

       void * r_queue_dequeue(RQueue *q)

       Dequeues an element.

STACKS

       A lightweight LIFO stack API for pushing and popping pointer elements, handy for depth-first  traversals,
       undo stacks and transient state storage.

       RStack * r_stack_new(ut32 n)

       Creates a new stack.

       void r_stack_push(RStack *s, void *el)

       Pushes an element onto the stack.

       void * r_stack_pop(RStack *s)

       Pops an element from the stack.

TIME

       Helpers  to  obtain timestamps and format them as human-readable strings, used for logging, profiling and
       displaying time-related information.

       ut64 r_time_now(void)

       Gets the current time in microseconds.

       char * r_time_stamp_to_str(ut64 ts)

       Converts a timestamp to a string.

LOGGING

       Minimal logging helpers to emit error and informational messages, acting as thin wrappers for diagnostics
       and user-facing feedback.

       void r_log_error(const char *fmt, ...)

       Logs an error message.

       void r_log_info(const char *fmt, ...)

       Logs an info message.

EXAMPLES

       Number parsing:

             RNum *num = r_num_new(NULL, NULL, NULL);
             ut64 val = r_num_get(num, "0x100");
             r_num_free(num);

       String manipulation:

             char *str = r_str_new("hello");
             str = r_str_append(str, " world");

       Buffer operations:

             RBuffer *buf = r_buf_new();
             r_buf_write(buf, data, len);
             ut8 *read_data = malloc(len);
             r_buf_read(buf, read_data, len);

       List usage:

             RList *list = r_list_new();
             r_list_append(list, item);
             void *first = r_list_get_n(list, 0);

SEE ALSO

       r_types(3)

Debian                                         September 20, 2025                                      R_UTIL(3)