rz_num.h File Reference

#include <rz_list.h>

Go to the source code of this file.

Classes
struct	RzNumCalcValue
struct	rz_num_calc_t
struct	rz_num_t

Macros
#define	RZ_NUMCALC_STRSZ   1024
#define	CONVERT_TO_TWO_COMPLEMENT(x)
#define	RZ_NUM_CMP(a, b)   ((a) > (b) ? 1 : ((b) > (a) ? -1 : 0))
	Typical comparison (1/0/-1) for two numbers of arbitrary types, including unsigned. More...

Typedefs
typedef struct rz_num_calc_t	RzNumCalc
typedef struct rz_num_t	RzNum
typedef ut64(*	RzNumCallback) (struct rz_num_t *self, const char *str, int *ok)
typedef const char *(*	RzNumCallback2) (struct rz_num_t *self, ut64, int *ok)

Enumerations
enum	RzNumCalcToken {   RNCNAME , RNCNUMBER , RNCEND , RNCINC ,   RNCDEC , RNCLT , RNCGT , RNCPLUS = '+' ,   RNCMINUS = '-' , RNCMUL = '*' , RNCEXP = 'E' , RNCDIV = '/' ,   RNCMOD = '' , RNCNEG = '~' , RNCAND = '&' , RNCORR = '|' ,   RNCXOR = '^' , RNCPRINT = ';' , RNCASSIGN = '=' , RNCLEFTP = '(' ,   RNCRIGHTP = ')' , RNCSHL = '<' , RNCSHR = '>' , RNCROL = '#' ,   RNCROR = '$' }

Functions
RZ_API RzNum *	rz_num_new (RzNumCallback cb, RzNumCallback2 cb2, void *ptr)
RZ_API void	rz_num_free (RzNum *num)
RZ_API char *	rz_num_units (char *buf, size_t len, ut64 number)
RZ_API int	rz_num_conditional (RzNum *num, const char *str)
RZ_API ut64	rz_num_calc (RzNum *num, const char *str, const char **err)
RZ_API const char *	rz_num_calc_index (RzNum *num, const char *p)
RZ_API ut64	rz_num_chs (int cylinder, int head, int sector, int sectorsize)
RZ_API int	rz_num_is_valid_input (RzNum *num, const char *input_value)
RZ_API ut64	rz_num_get_input_value (RzNum *num, const char *input_value)
RZ_API const char *	rz_num_get_name (RzNum *num, ut64 n)
RZ_API char *	rz_num_as_string (RzNum *___, ut64 n, bool printable_only)
RZ_API ut64	rz_num_tail (RzNum *num, ut64 addr, const char *hex)
RZ_API ut64	rz_num_tail_base (RzNum *num, ut64 addr, ut64 off)
RZ_API void	rz_num_minmax_swap (ut64 *a, ut64 *b)
RZ_API void	rz_num_minmax_swap_i (int *a, int *b)
RZ_API ut64	rz_num_math (RzNum *num, const char *str)
RZ_API ut64	rz_num_get (RzNum *num, const char *str)
RZ_API int	rz_num_to_bits (char *out, ut64 num)
RZ_API int	rz_num_to_trits (char *out, ut64 num)
RZ_API int	rz_num_rand (int max)
RZ_API void	rz_num_irand (void)
RZ_API ut64	rz_get_input_num_value (RzNum *num, const char *input_value)
RZ_API bool	rz_is_valid_input_num_value (RzNum *num, const char *input_value)
RZ_API int	rz_num_between (RzNum *num, const char *input_value)
RZ_API bool	rz_num_is_op (const char c)
RZ_API int	rz_num_str_len (const char *str)
RZ_API int	rz_num_str_split (char *str)
RZ_API RzList *	rz_num_str_split_list (char *str)
RZ_API void *	rz_num_dup (ut64 n)
RZ_API size_t	rz_num_base_of_string (RzNum *num, RZ_NONNULL const char *str)
	Convert the base suffix to the numeric value. More...
RZ_API double	rz_num_cos (double a)
RZ_API double	rz_num_sin (double a)
RZ_API double	rz_num_get_float (RzNum *num, const char *str)
RZ_API bool	rz_num_is_hex_prefix (const char *p)
	Checks if the first two chars of p equal "0x". More...
static st64	rz_num_abs (st64 num)
static ut64	rz_num_align_delta (ut64 v, ut64 alignment)
	Padding to align v to the next alignment-boundary. More...
static ut64	rz_num_bitmask (ut8 width)
	Get the 64-bit value that has exactly its width lowest bits set to 1. e.g. rz_num_bitmask(2) == 0b11 rz_num_bitmask(3) == 0b111 ... More...
static ut64	rz_num_2_pow_64_div (ut64 divisor)

Macro Definition Documentation

CONVERT_TO_TWO_COMPLEMENT

#define CONVERT_TO_TWO_COMPLEMENT

(

x

)

Value:

    static inline st##x convert_to_two_complement_##x(ut##x value) { \
        if (value <= ST##x##_MAX) { \
            return (st##x)value; \
        } \
\
        value = ~value + 1; \
        return -(st##x)value; \
    }

Definition at line 141 of file rz_num.h.

RZ_NUM_CMP

#define RZ_NUM_CMP	(		a,
			b
	)		((a) > (b) ? 1 : ((b) > (a) ? -1 : 0))

Typical comparison (1/0/-1) for two numbers of arbitrary types, including unsigned.

Definition at line 157 of file rz_num.h.

RZ_NUMCALC_STRSZ

#define RZ_NUMCALC_STRSZ   1024

Definition at line 6 of file rz_num.h.

Typedef Documentation

RzNum

typedef struct rz_num_t RzNum

RzNumCalc

typedef struct rz_num_calc_t RzNumCalc

RzNumCallback

typedef ut64(* RzNumCallback) (struct rz_num_t *self, const char *str, int *ok)

Definition at line 70 of file rz_num.h.

RzNumCallback2

typedef const char*(* RzNumCallback2) (struct rz_num_t *self, ut64, int *ok)

Definition at line 71 of file rz_num.h.

Enumeration Type Documentation

RzNumCalcToken

enum RzNumCalcToken

Enumerator
RNCNAME
RNCNUMBER
RNCEND
RNCINC
RNCDEC
RNCLT
RNCGT
RNCPLUS
RNCMINUS
RNCMUL
RNCEXP
RNCDIV
RNCMOD
RNCNEG
RNCAND
RNCORR
RNCXOR
RNCPRINT
RNCASSIGN
RNCLEFTP
RNCRIGHTP
RNCSHL
RNCSHR
RNCROL
RNCROR

Definition at line 17 of file rz_num.h.

             {
    RNCNAME,
    RNCNUMBER,
    RNCEND,
    RNCINC,
    RNCDEC,
    RNCLT, // comparison operator <
    RNCGT, // comparison operator >
    RNCPLUS = '+',
    RNCMINUS = '-',
    RNCMUL = '*',
    RNCEXP = 'E',
    RNCDIV = '/',
    RNCMOD = '%',
    // RNCXOR='^', RNCOR='|', RNCAND='&',
    RNCNEG = '~',
    RNCAND = '&',
    RNCORR = '|',
    RNCXOR = '^',
    RNCPRINT = ';',
    RNCASSIGN = '=',
    RNCLEFTP = '(',
    RNCRIGHTP = ')',
    RNCSHL = '<',
    RNCSHR = '>',
    RNCROL = '#',
    RNCROR = '$'
} RzNumCalcToken;

Function Documentation

rz_get_input_num_value()

RZ_API ut64 rz_get_input_num_value	(	RzNum *	num,
		const char *	input_value
	)

Definition at line 743 of file unum.c.

                                                                {
    return (str && *str) ? rz_num_math(num, str) : 0;
}

References num, rz_num_math(), and cmd_descs_generate::str.

Referenced by sigdb_signature_resolve_details().

rz_is_valid_input_num_value()

RZ_API bool rz_is_valid_input_num_value	(	RzNum *	num,
		const char *	input_value
	)

Definition at line 735 of file unum.c.

                                                                             {
    if (!input_value) {
        return false;
    }
    ut64 value = rz_num_math(num, input_value);
    return !(value == 0 && *input_value != '0');
}

References num, rz_num_math(), ut64(), and value.

Referenced by encode_addr16(), encode_addr32(), encode_const_pool16(), encode_const_pool16_ut8(), encode_const_pool8(), encode_st16(), encode_st8(), encode_ut8(), encode_ut8x2(), lua_is_valid_num_value_string(), and subvar().

rz_num_2_pow_64_div()

static ut64 rz_num_2_pow_64_div ( ut64  divisor )

inlinestatic

Divide 2^64 by the given divisor

Idea: https://stackoverflow.com/a/55584872 Proof: https://git.sr.ht/~thestr4ng3r/isa-bit-twiddling/tree/808253ab4d262f9e7dd7b87d0396f1afd7c5804b/item/Bit_Twiddling.thy#L26-43

Parameters

divisor

must be non-zero

Definition at line 167 of file rz_num.h.

                                                     {
    return (-(st64)divisor) / divisor + 1;
}

References st64.

Referenced by rz_core_analysis_get_stats().

rz_num_abs()

static st64 rz_num_abs ( st64  num )

inlinestatic

Definition at line 108 of file rz_num.h.

                                        {
    return num < 0 ? -num : num;
}

References num.

Referenced by rz_io_shift().

rz_num_align_delta()

static ut64 rz_num_align_delta ( ut64  v, ut64  alignment  )

inlinestatic

Padding to align v to the next alignment-boundary.

Returns

the least d such that (v + d) % alignment == 0.

Definition at line 116 of file rz_num.h.

                                                              {
    if (!alignment) {
        return 0;
    }
    ut64 excess = v % alignment;
    if (!excess) {
        return 0;
    }
    return alignment - excess;
}

References ut64(), and v.

Referenced by parse_aranges_raw(), rz_bflt_get_data_base(), rz_bin_elf_get_targets_map_base(), rz_bin_relocs_patch_find_targets_map_base(), and rz_coff_get_reloc_targets_map_base().

rz_num_as_string()

RZ_API char* rz_num_as_string	(	RzNum *	___,
		ut64	n,
		bool	printable_only
	)

Definition at line 705 of file unum.c.

                                                                       {
    char str[34]; // 8 byte * 4 chars in \x?? format
    int stri, ret = 0, off = 0;
    int len = sizeof(ut64);
    ut64 num = n;
    str[stri = 0] = 0;
    while (len--) {
        char ch = (num & 0xff);
        if (ch >= 32 && ch < 127) {
            str[stri++] = ch;
            str[stri] = 0;
        } else if (!printable_only && (off = escape_char(str + stri, ch)) != 0) {
            stri += off;
        } else {
            if (ch) {
                return NULL;
            }
        }
        ret |= (num & 0xff);
        num >>= 8;
    }
    if (ret) {
        return strdup(str);
    }
    if (!printable_only) {
        return strdup("\\0");
    }
    return NULL;
}

References escape_char(), len, n, NULL, num, off, cmd_descs_generate::str, strdup(), and ut64().

Referenced by ds_print_as_string(), rax(), and rz_cmd_help().

rz_num_base_of_string()

RZ_API size_t rz_num_base_of_string	(	RzNum *	num,
		RZ_NONNULL const char *	str
	)

Convert the base suffix to the numeric value.

Definition at line 935 of file unum.c.

                                                                            {
    rz_return_val_if_fail(num && str, 10);
    size_t base = 10;
    if (rz_str_startswith(str, "10u") || rz_str_startswith(str, "du")) {
        base = 11;
    } else {
        switch (str[0]) {
        case 's':
            base = 1;
            break;
        case 'b':
            base = 2;
            break;
        case 'p':
            base = 3;
            break;
        case 'o':
            base = 8;
            break;
        case 'd':
            base = 10;
            break;
        case 'h':
            base = 16;
            break;
        case 'i':
            base = 32;
            break;
        case 'q':
            base = 64;
            break;
        case 'S':
            // IPv4 address
            base = 80;
            break;
        default:
            // syscall
            base = rz_num_math(num, str);
        }
    }
    return base;
}

References num, rz_num_math(), rz_return_val_if_fail, rz_str_startswith(), and cmd_descs_generate::str.

Referenced by rz_analysis_hint_set_immbase_handler(), and rz_core_visual_define().

rz_num_between()

RZ_API int rz_num_between	(	RzNum *	num,
		const char *	input_value
	)

Definition at line 826 of file unum.c.

                                                               {
    int i;
    ut64 ns[3];
    char *const str = strdup(input_value);
    RzList *nums = rz_num_str_split_list(str);
    int len = rz_list_length(nums);
    if (len < 3) {
        free(str);
        rz_list_free(nums);
        return -1;
    }
    if (len > 3) {
        len = 3;
    }
    for (i = 0; i < len; i++) {
        ns[i] = rz_num_math(num, rz_list_pop_head(nums));
    }
    free(str);
    rz_list_free(nums);
    return num->value = RZ_BETWEEN(ns[0], ns[1], ns[2]);
}

References free(), i, len, num, RZ_BETWEEN, rz_list_free(), rz_list_length(), rz_list_pop_head(), rz_num_math(), rz_num_str_split_list(), cmd_descs_generate::str, strdup(), and ut64().

Referenced by rz_cmd_help().

rz_num_bitmask()

static ut64 rz_num_bitmask ( ut8  width )

inlinestatic

Get the 64-bit value that has exactly its width lowest bits set to 1. e.g. rz_num_bitmask(2) == 0b11 rz_num_bitmask(3) == 0b111 ...

Definition at line 134 of file rz_num.h.

                                             {
    if (width >= 64) {
        return 0xffffffffffffffffull;
    }
    return (1ull << (ut64)width) - 1;
}

References ut64(), and width.

Referenced by bfc(), bfi(), bfm(), hex_op_masks_extract(), rz_arm_cs_analysis_op_32_esil(), rz_arm_cs_analysis_op_64_esil(), rz_bv_set_all(), and shifted_reg64_append().

rz_num_calc()

RZ_API ut64 rz_num_calc	(	RzNum *	num,
		const char *	str,
		const char **	err
	)

Definition at line 482 of file calc.c.

                                                                       {
    RzNumCalcValue n;
    RzNumCalc *nc, nc_local;
    if (!str || !*str) {
        return 0LL;
    }
    if (num) {
        nc = &num->nc;
        num->dbz = 0;
    } else {
        nc = &nc_local;
    }
    /* init */
    nc->curr_tok = RNCPRINT;
    nc->number_value.d = 0.0;
    nc->number_value.n = 0LL;
    nc->errors = 0;
    nc->oc = 0;
    nc->calc_err = NULL;
    nc->calc_i = 0;
    nc->calc_len = 0;
    nc->calc_buf = NULL;
    nc->under_calc = true;
 
    load_token(num, nc, str);
    get_token(num, nc);
    n = expr(num, nc, 0);
    if (err) {
        *err = nc->calc_err;
    }
    if (num) {
        num->fvalue = n.d;
    }
    nc->under_calc = false;
    return n.n;
}

References rz_num_calc_t::calc_buf, rz_num_calc_t::calc_err, rz_num_calc_t::calc_i, rz_num_calc_t::calc_len, rz_num_calc_t::curr_tok, RzNumCalcValue::d, err, rz_num_calc_t::errors, expr(), get_token(), load_token(), n, RzNumCalcValue::n, NULL, num, rz_num_calc_t::number_value, rz_num_calc_t::oc, RNCPRINT, cmd_descs_generate::str, and rz_num_calc_t::under_calc.

Referenced by rz_num_math().

rz_num_calc_index()

RZ_API const char* rz_num_calc_index	(	RzNum *	num,
		const char *	p
	)

Definition at line 288 of file calc.c.

                                                                {
    if (!num) {
        return NULL;
    }
    if (p) {
        num->nc.calc_buf = p;
        num->nc.calc_len = strlen(p);
        num->nc.calc_i = 0;
    }
    return num->nc.calc_buf + num->nc.calc_i;
}

References NULL, num, and p.

Referenced by num_callback().

rz_num_chs()

RZ_API ut64 rz_num_chs	(	int	cylinder,
		int	head,
		int	sector,
		int	sectorsize
	)

Definition at line 596 of file unum.c.

                                                                           {
    if (sectorsize < 1) {
        sectorsize = 512;
    }
    return (ut64)cylinder * (ut64)head * (ut64)sector * (ut64)sectorsize;
}

References test-lz4-versions::head, and ut64().

rz_num_conditional()

RZ_API int rz_num_conditional	(	RzNum *	num,
		const char *	str
	)

Definition at line 603 of file unum.c.

                                                           {
    char *lgt, *t, *p, *s = strdup(str);
    int res = 0;
    ut64 n, a, b;
    p = s;
    do {
        t = strchr(p, ',');
        if (t) {
            *t = 0;
        }
        lgt = strchr(p, '<');
        if (lgt) {
            *lgt = 0;
            a = rz_num_math(num, p);
            if (lgt[1] == '=') {
                b = rz_num_math(num, lgt + 2);
                if (a > b) {
                    goto fail;
                }
            } else {
                b = rz_num_math(num, lgt + 1);
                if (a >= b) {
                    goto fail;
                }
            }
        } else {
            lgt = strchr(p, '>');
            if (lgt) {
                *lgt = 0;
                a = rz_num_math(num, p);
                if (lgt[1] == '=') {
                    b = rz_num_math(num, lgt + 2);
                    if (a < b) {
                        goto fail;
                    }
                } else {
                    b = rz_num_math(num, lgt + 1);
                    if (a <= b) {
                        goto fail;
                    }
                }
            } else {
                lgt = strchr(p, '=');
                if (lgt && lgt > p) {
                    lgt--;
                    if (*lgt == '!') {
                        rz_str_replace_char(p, '!', ' ');
                        rz_str_replace_char(p, '=', '-');
                        n = rz_num_math(num, p);
                        if (!n) {
                            goto fail;
                        }
                    }
                }
                lgt = strstr(p, "==");
                if (lgt) {
                    *lgt = ' ';
                }
                rz_str_replace_char(p, '=', '-');
                n = rz_num_math(num, p);
                if (n) {
                    goto fail;
                }
            }
        }
        p = t + 1;
    } while (t);
    res = 1;
fail:
    free(s);
    return res;
}

References a, b, fail, free(), n, num, p, rz_num_math(), rz_str_replace_char(), s, cmd_descs_generate::str, strdup(), and ut64().

Referenced by rz_cmd_debug_step_cond_handler(), and rz_cmd_help().

rz_num_cos()

RZ_API double rz_num_cos

(

double

a

)

Definition at line 924 of file unum.c.

                                   {
    return cos(a);
}

References a.

rz_num_dup()

RZ_API void* rz_num_dup

(

ut64

n

)

Definition at line 915 of file unum.c.

                                {
    ut64 *hn = malloc(sizeof(ut64));
    if (!hn) {
        return NULL;
    }
    *hn = n;
    return (void *)hn;
}

References malloc(), n, NULL, and ut64().

Referenced by ds_show_xrefs().

rz_num_free()

RZ_API void rz_num_free

(

RzNum *

num

)

Definition at line 87 of file unum.c.

                                    {
    free(num);
}

References free(), and num.

Referenced by __as_free(), rz_core_fini(), rz_debug_free(), rz_flag_free(), and rz_main_rz_ax().

rz_num_get()

RZ_API ut64 rz_num_get	(	RzNum *	num,
		const char *	str
	)

Definition at line 172 of file unum.c.

                                                    {
    int i, j, ok;
    char lch, len;
    ut64 ret = 0LL;
    ut32 s, a;
 
    if (num && !num->nc.under_calc) {
        num->nc.errors = 0;
    }
    if (!str) {
        return 0;
    }
    for (; *str == ' ';) {
        str++;
    }
    if (!*str) {
        return 0;
    }
    if (!strncmp(str, "1u", 2)) { // '1' is captured by op :(
        if (num && num->value == UT64_MAX) {
            num->value = 0;
        }
        switch (atoi(str + 2)) {
        case 64: return (ut64)UT64_MAX;
        case 32: return (ut64)UT32_MAX;
        case 16: return (ut64)UT16_MAX;
        case 8: return (ut64)UT8_MAX;
        }
    }
    /* resolve string with an external callback */
    if (num && num->callback) {
        ok = 0;
        ret = num->callback(num->userptr, str, &ok);
        if (ok) {
            return ret;
        }
    }
 
    if (str[0] && str[1] && str[2]) {
        if (str[0] == '\'' && str[2] == '\'') {
            return (ut64)str[1];
        }
    }
 
    len = strlen(str);
    if (len > 3 && str[4] == ':') {
        if (sscanf(str, "%04x", &s) == 1) {
            if (sscanf(str + 5, "%04x", &a) == 1) {
                return (ut64)((s << 4) + a);
            }
        }
    } else if (len > 6 && str[6] == ':') {
        if (sscanf(str, "0x%04x:0x%04x", &s, &a) == 2) {
            return (ut64)((s << 4) + a);
        }
        if (sscanf(str, "0x%04x:%04x", &s, &a) == 2) {
            return (ut64)((s << 4) + a);
        }
    }
    if (str[0] == '0' && str[1] == 'b') {
        ret = 0;
        for (j = 0, i = strlen(str) - 1; i > 0; i--, j++) {
            if (str[i] == '1') {
                ret |= 1 << j;
            } else if (str[i] != '0') {
                break;
            }
        }
        sscanf(str, "0x%" PFMT64x, &ret);
    } else if (str[0] == '\'') {
        ret = str[1] & 0xff;
        // needs refactoring
    } else if (!strncmp(str, "0xff..", 6) || !strncmp(str, "0xFF..", 6)) {
        ret = rz_num_tailff(num, str + 6);
        // needs refactoring
    } else if (!strncmp(str, "0o", 2)) {
        if (sscanf(str + 2, "%" PFMT64o, &ret) != 1) {
            error(num, "invalid octal number");
        }
    } else if (!strncmp(str, "0xf..", 5) || !strncmp(str, "0xF..", 5)) {
        ret = rz_num_tailff(num, str + 5);
    } else if (str[0] == '0' && tolower(str[1]) == 'x') {
        const char *lodash = strchr(str + 2, '_');
        if (lodash) {
            // Support 0x1000_f000_4000
            // TODO: Only take underscores separated every 4 chars starting at the end
            char *s = strdup(str + 2);
            if (s) {
                rz_str_replace_char(s, '_', 0);
                errno = 0;
                ret = strtoull(s, NULL, 16);
                free(s);
            }
        } else {
            errno = 0;
            ret = strtoull(str + 2, NULL, 16);
            // sscanf (str+2, "%"PFMT64x, &ret);
        }
        if (errno == ERANGE) {
            error(num, "number won't fit into 64 bits");
        }
    } else {
        char *endptr;
        int len_num = len > 0 ? len - 1 : 0;
        // Trim separators on the right
        while (len_num > 0 && IS_SEPARATOR(str[len_num])) {
            len_num--;
        }
        int chars_read = len_num;
        bool zero_read = false;
        lch = str[len_num];
        if (*str == '0' && IS_DIGIT(*(str + 1)) && lch != 'b' && lch != 'h' && lch != 'H') {
            lch = 'o';
            len_num++;
        }
        switch (lch) {
        case 'H':
        case 'h': // hexa
            if (!sscanf(str, "%" PFMT64x "%n", &ret, &chars_read) || chars_read != len_num) {
                error(num, "invalid hex number");
            }
            break;
        case 'o': // octal
            if (!sscanf(str, "%" PFMT64o "%n", &ret, &chars_read) || chars_read != len_num) {
                error(num, "invalid octal number");
            }
            break;
        case 'b': // binary
            ret = 0;
            ok = true;
            if (strlen(str) <= 65) { // 64 bit + the 'b' suffix
                for (j = 0, i = strlen(str) - 2; i >= 0; i--, j++) {
                    if (str[i] == '1') {
                        ret |= (1ULL << j);
                    } else if (str[i] != '0') {
                        // eprintf ("Unexpected char in binary number string '%c'\n", str[i]);
                        ok = false;
                        break;
                    }
                }
            } else {
                ok = false;
                // eprintf ("Binary number is too large to fit in ut64\n");
            }
            if (!ok || !len_num) {
                error(num, "invalid binary number");
            }
            break;
        case 't': // ternary
            ret = 0;
            ok = true;
            ut64 x = 1;
            for (i = strlen(str) - 2; i >= 0; i--) {
                if (str[i] < '0' || '2' < str[i]) {
                    ok = false;
                    break;
                }
                ret += x * (str[i] - '0');
                x *= 3;
            }
            if (!ok || !len_num) {
                error(num, "invalid ternary number");
            }
            break;
        case 'K':
        case 'k':
            if (strchr(str, '.')) {
                double d = 0;
                if (sscanf(str, "%lf%n", &d, &chars_read)) {
                    ret = (ut64)(d * KB);
                } else {
                    zero_read = true;
                }
            } else {
                if (sscanf(str, "%" PFMT64d "%n", &ret, &chars_read)) {
                    ret *= KB;
                } else {
                    zero_read = true;
                }
            }
            if (zero_read || chars_read != len_num) {
                error(num, "invalid kilobyte number");
            }
            break;
        case 'M':
        case 'm':
            if (strchr(str, '.')) {
                double d = 0;
                if (sscanf(str, "%lf%n", &d, &chars_read)) {
                    ret = (ut64)(d * MB);
                } else {
                    zero_read = true;
                }
            } else {
                if (sscanf(str, "%" PFMT64d "%n", &ret, &chars_read)) {
                    ret *= MB;
                } else {
                    zero_read = true;
                }
            }
            if (zero_read || chars_read != len_num) {
                error(num, "invalid megabyte number");
            }
            break;
        case 'G':
        case 'g':
            if (strchr(str, '.')) {
                double d = 0;
                if (sscanf(str, "%lf%n", &d, &chars_read)) {
                    ret = (ut64)(d * GB);
                } else {
                    zero_read = true;
                }
            } else {
                if (sscanf(str, "%" PFMT64d "%n", &ret, &chars_read)) {
                    ret *= GB;
                } else {
                    zero_read = true;
                }
            }
            if (zero_read || chars_read != len_num) {
                error(num, "invalid gigabyte number");
            }
            break;
        default:
#if 0
            // sscanf (str, "%"PFMT64d"%n", &ret, &chars_read);
// 32bit chop
#if __WINDOWS__
            ret = _strtoui64 (str, &endptr, 10);
#endif
#endif
            errno = 0;
            ret = strtoull(str, &endptr, 10);
            if (errno == ERANGE) {
                error(num, "number won't fit into 64 bits");
            }
            if (!IS_DIGIT(*str) || (*endptr && *endptr != lch)) {
                error(num, "unknown symbol");
            }
            break;
        }
    }
    if (num) {
        num->value = ret;
    }
    return ret;
}

References a, d, ERANGE, error(), free(), GB, i, IS_DIGIT, IS_SEPARATOR, KB, len, MB, NULL, num, ok, PFMT64d, PFMT64o, PFMT64x, rz_num_tailff(), rz_str_replace_char(), s, cmd_descs_generate::str, strdup(), tolower, UT16_MAX, UT32_MAX, ut64(), UT64_MAX, UT8_MAX, and x.

Referenced by __panels_process(), __system(), buf_format(), cin_get_num(), cmp(), disasm_strings(), ds_build_op_str(), ds_init(), ds_sub_jumps(), extract_arg(), fold_asm_trace(), foreach_pairs(), gb_parse_arith1(), gb_parse_cb2(), gb_parse_ld2(), gb_parse_ld3(), gbAsm(), get_cf_offset(), get_msg_type(), getreg(), isnum(), le_get_symbols_at(), parse_enum_node(), parse_grep_expression(), parse_struct_node(), parse_type_abstract_declarator_node(), parse_type_declarator_node(), parse_union_node(), prim(), print_heap_bin(), print_heap_fastbin(), riscv_op(), rop_classify_arithmetic_const(), rop_classify_constant(), rz_analysis_aefa(), rz_analysis_all_esil_handler(), rz_analysis_class_vtable_get(), rz_analysis_esil_get_parm_size(), rz_analysis_functions_map_handler(), rz_analyze_cycles_handler(), rz_bin_strpurge(), rz_cf_value_integer_new(), rz_cmd_alias(), rz_cmd_debug_dmi(), rz_cmd_debug_trace_add_addrs_handler(), rz_cmd_heap_bins_list_print(), rz_cmd_heap_chunks_print_handler(), rz_cmd_heap_fastbins_print(), rz_cmd_heap_info_print_handler(), rz_cmd_help(), rz_cmd_main_arena_print_handler(), rz_cmd_search(), rz_config_node_new(), rz_config_set(), rz_core_analysis_continue_until_call(), rz_core_analysis_continue_until_syscall(), rz_core_bin_export_info(), rz_core_rtr_add(), rz_core_visual_cmd(), rz_core_visual_debugtraces(), rz_core_visual_hudclasses(), rz_core_visual_hudstuff(), rz_core_visual_view_rop(), rz_debug_bochs_breakpoint(), rz_debug_bochs_reg_read(), rz_debug_bochs_wait(), rz_debug_gdb_map_get(), rz_num_tailff(), rz_print_areas_no_functions_handler(), rz_range_add_from_string(), rz_resolve_jemalloc(), rz_socket_port_by_name(), rz_str_range_in(), rz_syscall_item_new_from_string(), rz_table_tojson(), sh_op_movl_param_bits(), sh_op_param_bits(), sortNumber(), subvar(), typelinks_load_sdb(), and visual_refresh().

rz_num_get_float()

RZ_API double rz_num_get_float	(	RzNum *	num,
		const char *	str
	)

Definition at line 536 of file unum.c.

                                                            {
    double d = 0.0f;
    (void)sscanf(str, "%lf", &d);
    return d;
}

References d, and cmd_descs_generate::str.

Referenced by is_tcache().

rz_num_get_input_value()

RZ_API ut64 rz_num_get_input_value	(	RzNum *	num,
		const char *	input_value
	)

Definition at line 681 of file unum.c.

                                                                        {
    ut64 value = input_value ? rz_num_math(num, input_value) : 0;
    return value;
}

References num, rz_num_math(), ut64(), and value.

Referenced by convert_offset_from_input().

rz_num_get_name()

RZ_API const char* rz_num_get_name	(	RzNum *	num,
		ut64	n
	)

Definition at line 147 of file unum.c.

                                                       {
    if (num->cb_from_value) {
        int ok = 0;
        const char *msg = num->cb_from_value(num, n, &ok);
        if (msg && *msg) {
            return msg;
        }
        if (ok) {
            return msg;
        }
    }
    return NULL;
}

References msg, n, NULL, num, and ok.

rz_num_irand()

RZ_API void rz_num_irand

(

void

)

Definition at line 43 of file unum.c.

                               {
    rz_srand(rz_time_now());
}

References rz_srand(), and rz_time_now().

Referenced by rz_core_rtr_http_run(), rz_core_write_random_at(), rz_file_slurp_random_line_count(), and rz_num_rand().

rz_num_is_hex_prefix()

RZ_API bool rz_num_is_hex_prefix

(

const char *

p

)

Checks if the first two chars of p equal "0x".

Parameters

p	The string which potentially represents a hex number.

Returns

bool True if p[0] == '0' && p[1] == 'x'. False otherwise.

Definition at line 17 of file unum.c.

                                                {
    rz_return_val_if_fail(p, false);
    if (!isascii(*p)) {
        return false; // UTF-8
    }
    return (p[0] == '0' && p[1] == 'x');
}

References p, and rz_return_val_if_fail.

Referenced by is_num(), seek_to_end_of_token(), and tokenize_asm_generic().

rz_num_is_op()

RZ_API bool rz_num_is_op

(

const char

c

)

Definition at line 848 of file unum.c.

                                       {
    return c == '/' || c == '+' || c == '-' || c == '*' ||
        c == '%' || c == '&' || c == '^' || c == '|';
}

References c.

Referenced by rz_num_math(), and rz_num_str_len().

rz_num_is_valid_input()

RZ_API int rz_num_is_valid_input	(	RzNum *	num,
		const char *	input_value
	)

Definition at line 676 of file unum.c.

                                                                      {
    ut64 value = input_value ? rz_num_math(num, input_value) : 0;
    return !(value == 0 && input_value && *input_value != '0') || !(value == 0 && input_value && *input_value != '@');
}

References num, rz_num_math(), ut64(), and value.

Referenced by convert_offset_from_input(), rz_open_close_handler(), rz_open_maps_relocate_current_handler(), rz_open_maps_relocate_handler(), rz_open_maps_remove_handler(), rz_open_maps_resize_handler(), rz_test_main(), and rz_write_random_handler().

rz_num_math()

RZ_API ut64 rz_num_math	(	RzNum *	num,
		const char *	str
	)

Definition at line 456 of file unum.c.

                                                     {
#if RZ_NUM_USE_CALC
    ut64 ret;
    const char *err = NULL;
    if (!str || !*str) {
        return 0LL;
    }
    // if (!str || !*str) return 0LL;
    if (num) {
        num->dbz = 0;
    }
    ret = rz_num_calc(num, str, &err);
    if (err) {
        eprintf("rz_num_calc error: (%s) in (%s)\n", err, str);
    }
    if (num) {
        num->value = ret;
    }
    return ret;
#else
    ut64 ret = 0LL;
    char op = '+';
    int len;
    char *p, *s, *os;
    char *group;
    if (!str)
        return 0LL;
 
    len = strlen(str) + 1;
    os = malloc(len + 1);
 
    s = os;
    memcpy(s, str, len);
    for (; *s == ' '; s++)
        ;
    p = s;
 
    do {
        group = strchr(p, '(');
        if (group) {
            group[0] = '\0';
            ret = rz_num_op(op, ret, rz_num_math_internal(num, p));
            for (; p < group; p += 1) {
                if (rz_num_is_op(*p)) {
                    op = *p;
                    break;
                }
            }
            group[0] = '(';
            p = group + 1;
            if (rz_str_delta(p, '(', ')') < 0) {
                char *p2 = strchr(p, '(');
                if (p2 != NULL) {
                    *p2 = '\0';
                    ret = rz_num_op(op, ret, rz_num_math_internal(num, p));
                    ret = rz_num_op(op, ret, rz_num_math(num, p2 + 1));
                    p = p2 + 1;
                    continue;
                }
                eprintf("something really bad has happened! can't find '('\n");
            } else {
                ret = rz_num_op(op, ret, rz_num_math_internal(num, p));
            }
        } else {
            ret = rz_num_op(op, ret, rz_num_math_internal(num, p));
        }
    } while (0);
 
    if (num) {
        num->value = ret;
    }
    free(os);
    return ret;
#endif
}

References eprintf, err, free(), len, malloc(), memcpy(), NULL, num, p, rz_num_calc(), rz_num_is_op(), rz_num_math(), rz_str_delta(), s, cmd_descs_generate::str, and ut64().

Referenced by __break_points_cb(), __esil_step_range_cb(), __esil_step_to_cb(), __handle_mouse_on_panel(), __open(), __panels_process(), __parse_string_on_cursor(), __printPattern(), __watch_points_cb(), assemble(), assign_reg(), bfvm_reg_set(), build(), cmd_analysis_esil(), cmd_analysis_graph(), cmd_analysis_trampoline(), cmd_dcu(), cmd_debug_cont_syscall(), cmd_debug_pid(), cmd_pCd(), cmd_pCD(), cmd_pCx(), cmd_print_bars(), cmd_print_blocks(), cmd_print_gadget(), cmd_print_pv(), cmd_Quit(), cmd_seek_opcode(), common_write_value_handler(), config_print_node(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), disasm_strings(), disasm_until_ret(), do_iter_offsets(), ds_init(), ds_show_flags(), evalFlag(), exprmatch(), exprmatchreg(), filter(), filterFlags(), foreachOffset(), format_output(), get_dispatchmessage_offset(), getnum(), jemalloc_get_chunks(), jemalloc_print_narenas(), loadGP(), num_callback(), numget(), parseOperands(), rabin_do_operation(), rax(), riscv_op(), rz_analysis_aefa(), rz_analysis_appcall_handler(), rz_analysis_basic_block_find_paths_handler(), rz_analysis_class_base_add_handler(), rz_analysis_class_base_get(), rz_analysis_class_method_add_handler(), rz_analysis_class_method_get(), rz_analysis_class_vtable_add_handler(), rz_analysis_class_vtable_get(), rz_analysis_class_vtable_lookup_handler(), rz_analysis_continue_until_addr_handler(), rz_analysis_esil_init_mem_handler(), rz_analysis_esil_init_mem_remove_handler(), rz_analysis_function_analyze_jmptable_handler(), rz_analysis_function_blocks_add_handler(), rz_analysis_function_blocks_color_handler(), rz_analysis_function_blocks_edge_handler(), rz_analysis_function_blocks_switch_type_handler(), rz_analysis_function_stacksz_handler(), rz_analysis_function_until_handler(), rz_analysis_function_vars_bp_getref_handler(), rz_analysis_function_vars_bp_handler(), rz_analysis_function_vars_bp_setref_handler(), rz_analysis_function_vars_regs_getref_handler(), rz_analysis_function_vars_regs_setref_handler(), rz_analysis_function_vars_sp_getref_handler(), rz_analysis_function_vars_sp_handler(), rz_analysis_function_vars_sp_setref_handler(), rz_analysis_functions_merge_handler(), rz_analysis_global_variable_add_handler(), rz_analysis_global_variable_delete_byaddr_handler(), rz_analysis_hint_del_handler(), rz_analysis_hint_set_bits_handler(), rz_analysis_hint_set_fail_handler(), rz_analysis_hint_set_immbase_handler(), rz_analysis_hint_set_jump_handler(), rz_analysis_hint_set_ptr_handler(), rz_analysis_hint_set_ret_handler(), rz_analysis_hint_set_size_handler(), rz_analysis_hint_set_stackframe_handler(), rz_analysis_hint_set_val_handler(), rz_analysis_list_struct_offsets_handler(), rz_analysis_noreturn_drop(), rz_analysis_syscall_number_handler(), rz_analysis_syscall_show_handler(), rz_analysis_xrefs_copy_handler(), rz_analysis_xrefs_del_handler(), rz_analyze_function_linked_offsets_handler(), rz_analyze_n_ins_esil_handler(), rz_analyze_n_ins_handler(), rz_analyze_n_ins_size_handler(), rz_analyze_xrefs_section_bytes_handler(), rz_asm_pseudo_align(), rz_asm_pseudo_bits(), rz_asm_pseudo_byte(), rz_asm_pseudo_incbin(), rz_asm_pseudo_intN(), rz_asm_pseudo_org(), rz_block_decrease_handler(), rz_block_handler(), rz_block_increase_handler(), rz_block_max_handler(), rz_cmd_alias(), rz_cmd_analysis(), rz_cmd_cmp_addr_handler(), rz_cmd_cmp_bits_handler(), rz_cmd_cmp_bytes_handler(), rz_cmd_cmp_disasm_handler(), rz_cmd_cmp_hex_block_handler(), rz_cmd_cmp_hex_block_hexdiff_handler(), rz_cmd_cmp_hex_diff_lines_handler(), rz_cmd_cmp_unified1_handler(), rz_cmd_cmp_unified2_handler(), rz_cmd_cmp_unified4_handler(), rz_cmd_cmp_unified8_handler(), rz_cmd_cmp_unified_disasm_handler(), rz_cmd_cmp_unified_handler(), rz_cmd_comments_in_n_instructions_handler(), rz_cmd_debug(), rz_cmd_debug_add_bp_module_handler(), rz_cmd_debug_allocate_maps_handler(), rz_cmd_debug_continue_execution_handler(), rz_cmd_debug_continue_send_signal_handler(), rz_cmd_debug_continue_traptrace_handler(), rz_cmd_debug_disable_bp_index_handler(), rz_cmd_debug_disable_bp_trace_index_handler(), rz_cmd_debug_dmL_handler(), rz_cmd_debug_dmS_handler(), rz_cmd_debug_enable_bp_index_handler(), rz_cmd_debug_enable_bp_trace_index_handler(), rz_cmd_debug_remove_bp_index_handler(), rz_cmd_debug_run_command_bp_index_handler(), rz_cmd_debug_set_expr_bp_index_handler(), rz_cmd_debug_step_back_handler(), rz_cmd_debug_step_handler(), rz_cmd_debug_step_line_handler(), rz_cmd_debug_step_over_handler(), rz_cmd_debug_step_prog_handler(), rz_cmd_debug_step_skip_handler(), rz_cmd_debug_step_until_handler(), rz_cmd_debug_toggle_bp_index_handler(), rz_cmd_debug_toggle_bp_trace_index_handler(), rz_cmd_debug_trace_add_handler(), rz_cmd_debug_trace_calls_handler(), rz_cmd_debug_trace_esil_handler(), rz_cmd_debug_trace_tag_handler(), rz_cmd_disassemble_ropchain_handler(), rz_cmd_disassemble_summarize_block_handler(), rz_cmd_disassemble_summarize_n_bytes_handler(), rz_cmd_disassembly_all_possible_opcodes_handler(), rz_cmd_disassembly_n_bytes_handler(), rz_cmd_disassembly_n_instrs_as_text_json_handler(), rz_cmd_disassembly_n_instructions_handler(), rz_cmd_disassembly_n_instructions_with_flow_handler(), rz_cmd_example_handler(), rz_cmd_help(), rz_cmd_javar_handler(), rz_cmd_macro_break(), rz_cmd_print(), rz_cmd_print_gadget_add_handler(), rz_cmd_print_gadget_move_handler(), rz_cmd_search(), rz_cmd_sizes_of_n_instructions_handler(), rz_config_get_i(), rz_config_set(), rz_convert_mne_handler(), rz_core_analysis_everything(), rz_core_analysis_function_delete_var(), rz_core_asm_strsearch(), rz_core_bin_export_info(), rz_core_bin_load(), rz_core_cmd_foreach(), rz_core_cmd_foreach3(), rz_core_cmd_lastcmd_repeat(), rz_core_cmd_subst_i(), rz_core_debug_esil(), rz_core_debug_kill(), rz_core_file_reopen(), rz_core_help_vars_print(), rz_core_print_examine(), rz_core_print_scrollbar(), rz_core_print_scrollbar_bottom(), rz_core_rtr_remove(), rz_core_setup_debugger(), rz_core_visual(), rz_core_visual_bit_editor(), rz_core_visual_cmd(), rz_core_visual_define(), rz_core_visual_offset(), rz_core_visual_trackflags(), rz_core_visual_view_rop(), rz_debug_bp_add(), rz_debug_drx_handler(), rz_debug_memory_permission_handler(), rz_egg_mkvar(), rz_flag_add_handler(), rz_flag_append_handler(), rz_flag_base_handler(), rz_flag_comment_handler(), rz_flag_hexdump_handler(), rz_flag_length_handler(), rz_flag_move_handler(), rz_flag_range_handler(), rz_flag_relocate_handler(), rz_get_input_num_value(), rz_get_size(), rz_heap_debug_block_win(), rz_hex_from_c_array(), rz_hex_from_py_array(), rz_il_step_evaluate_handler(), rz_il_step_handler(), rz_il_step_over_until_addr_handler(), rz_il_step_skip_until_addr_handler(), rz_il_step_until_addr_handler(), rz_il_vm_status_handler(), rz_il_vm_step_handler(), rz_il_vm_step_until_addr_handler(), rz_il_vm_step_with_events_handler(), rz_is_valid_input_num_value(), rz_main_rizin(), rz_main_rz_asm(), rz_main_rz_bin(), rz_main_rz_find(), rz_main_rz_gg(), rz_meta_data_handler(), rz_meta_data_remove_handler(), rz_meta_format_handler(), rz_meta_hidden_handler(), rz_meta_magic_handler(), rz_meta_string_8bit_handler(), rz_meta_string_handler(), rz_meta_string_utf8_handler(), rz_meta_string_wide16_handler(), rz_meta_string_wide32_handler(), rz_num_base_of_string(), rz_num_between(), rz_num_conditional(), rz_num_get_input_value(), rz_num_is_valid_input(), rz_num_math(), rz_num_tail(), rz_open_arch_bits_handler(), rz_open_binary_add_handler(), rz_open_binary_del_handler(), rz_open_binary_rebase_handler(), rz_open_binary_reload_handler(), rz_open_binary_select_fd_handler(), rz_open_binary_select_id_handler(), rz_open_close_handler(), rz_open_exchange_handler(), rz_open_handler(), rz_open_malloc_handler(), rz_open_maps_all_fd_handler(), rz_open_maps_deprioritize_handler(), rz_open_maps_flags_handler(), rz_open_maps_list_handler(), rz_open_maps_map_fd_handler(), rz_open_maps_map_handler(), rz_open_maps_name_id_del_handler(), rz_open_maps_name_id_handler(), rz_open_maps_prioritize_binid_handler(), rz_open_maps_prioritize_fd_handler(), rz_open_maps_prioritize_handler(), rz_open_maps_relocate_current_handler(), rz_open_maps_relocate_handler(), rz_open_maps_remove_handler(), rz_open_maps_resize_handler(), rz_open_nobin_handler(), rz_open_nobin_write_handler(), rz_open_use_handler(), rz_open_write_handler(), rz_print_areas_no_functions_handler(), rz_print_bitstream_handler(), rz_print_byte_bitstream_handler(), rz_print_commands_after_traps_handler(), rz_print_delta_pointer_table_handler(), rz_print_hexdump_annotated_handler(), rz_print_hexdump_bits_handler(), rz_print_hexdump_comments_handler(), rz_print_hexdump_emoji_handler(), rz_print_hexdump_handler(), rz_print_hexdump_hex_common_handler(), rz_print_hexdump_hexl_common_handler(), rz_print_hexdump_hexless_bytes_handler(), rz_print_hexdump_hexless_words_handler(), rz_print_hexdump_n_lines_handler(), rz_print_hexdump_oct_handler(), rz_print_hexdump_signed_integer_common_handler(), rz_print_hexdump_sparse_handler(), rz_print_hexword_references_common_handler(), rz_print_op_analysis_color_map_handler(), rz_print_utf16be_handler(), rz_print_utf16le_handler(), rz_print_utf32be_handler(), rz_print_utf32le_handler(), rz_rebase_handler(), rz_reg_set_bvalue(), rz_reopen_debug_file_handler(), rz_reopen_handler(), rz_reopen_write_handler(), rz_resize_handler(), rz_resize_insert_handler(), rz_resize_remove_handler(), rz_seek_asz_handler(), rz_seek_blocksize_backward_handler(), rz_seek_blocksize_forward_handler(), rz_seek_handler(), rz_table_filter(), rz_tasks_break_handler(), rz_tasks_delete_handler(), rz_tasks_output_handler(), rz_tasks_wait_handler(), rz_test_main(), rz_type_format_data_internal(), rz_type_format_struct_size(), rz_type_format_uleb(), rz_type_link_del_handler(), rz_type_link_handler(), rz_type_link_show_handler(), rz_type_list_noreturn_handler(), rz_type_print_handler(), rz_type_print_value_handler(), rz_type_xrefs_function_handler(), rz_w32_add_winmsg_breakpoint(), rz_write_bits_handler(), rz_write_cache_commit_handler(), rz_write_cache_remove_handler(), rz_write_debruijn_find_handler(), rz_write_debruijn_handler(), rz_write_duplicate_handler(), rz_write_extend_hexbytes_handler(), rz_write_extend_shift_handler(), rz_write_extend_zero_handler(), rz_write_from_file_handler(), rz_write_from_io_handler(), rz_write_from_io_xchg_handler(), rz_write_from_socket_handler(), rz_write_op_sequence_handler(), rz_write_pcache_commit_handler(), rz_write_pcache_list_handler(), rz_write_random_handler(), rz_write_unified_patch_handler(), rz_write_unset_bits_handler(), rz_write_zero_handler(), rz_yank_file_handler(), rz_yank_handler(), rz_yank_hex_print_handler(), rz_yank_paste_handler(), rz_yank_print_handler(), rz_yank_string_handler(), rz_yank_string_print_handler(), rz_yank_to_handler(), sdb_load_arch_profile(), set_prompt(), subvar(), syscalls_dump(), thumb_getoffset(), types_enum_member_find(), types_enum_member_find_all(), v_writebuf(), w_incdec_handler(), and xrefs_set().

rz_num_minmax_swap()

RZ_API void rz_num_minmax_swap	(	ut64 *	a,
		ut64 *	b
	)

Definition at line 59 of file unum.c.

                                                 {
    if (*a > *b) {
        ut64 tmp = *a;
        *a = *b;
        *b = tmp;
    }
}

References a, b, autogen_x86imm::tmp, and ut64().

Referenced by rz_range_add(), and rz_range_sub().

rz_num_minmax_swap_i()

RZ_API void rz_num_minmax_swap_i	(	int *	a,
		int *	b
	)

Definition at line 67 of file unum.c.

                                                 {
    if (*a > *b) {
        ut64 tmp = *a;
        *a = *b;
        *b = tmp;
    }
}

References a, b, autogen_x86imm::tmp, and ut64().

Referenced by rz_print_have_cursor().

rz_num_new()

RZ_API RzNum* rz_num_new	(	RzNumCallback	cb,
		RzNumCallback2	cb2,
		void *	ptr
	)

Definition at line 75 of file unum.c.

                                                                          {
    RzNum *num = RZ_NEW0(RzNum);
    if (!num) {
        return NULL;
    }
    num->value = 0LL;
    num->callback = cb;
    num->cb_from_value = cb2;
    num->userptr = ptr;
    return num;
}

References cb, NULL, num, and RZ_NEW0.

Referenced by __as_new(), rz_core_init(), rz_debug_new(), rz_flag_new(), and rz_main_rz_ax().

rz_num_rand()

RZ_API int rz_num_rand

(

int

max

)

Definition at line 47 of file unum.c.

                                {
    static bool rand_initialized = false;
    if (!rand_initialized) {
        rz_num_irand();
        rand_initialized = true;
    }
    if (!max) {
        max = 1;
    }
    return rz_rand(max);
}

References max, rz_num_irand(), and rz_rand().

Referenced by _sendResponsePacket(), rz_cmd_help(), rz_cons_color_random(), rz_core_clippy(), rz_core_rtr_http_run(), rz_core_visual_colors(), rz_core_write_random_at(), rz_file_slurp_random_line_count(), rz_io_zip_create_new_file(), rz_main_rz_agent(), and rz_socket_spawn().

rz_num_sin()

RZ_API double rz_num_sin

(

double

a

)

Definition at line 928 of file unum.c.

                                   {
    return sin(a);
}

References a.

rz_num_str_len()

RZ_API int rz_num_str_len

(

const char *

str

)

Definition at line 854 of file unum.c.

                                           {
    int i = 0, len = 0, st;
    st = 0; // 0: number, 1: op
    if (str[0] == '(') {
        i++;
    }
    while (str[i] != '\0') {
        switch (st) {
        case 0: // number
            while (!rz_num_is_op(str[i]) && str[i] != ' ' && str[i] != '\0') {
                i++;
                if (str[i] == '(') {
                    i += rz_num_str_len(str + i);
                }
            }
            len = i;
            st = 1;
            break;
        case 1: // op
            while (str[i] != '\0' && str[i] == ' ') {
                i++;
            }
            if (!rz_num_is_op(str[i])) {
                return len;
            }
            if (str[i] == ')') {
                return i + 1;
            }
            i++;
            while (str[i] != '\0' && str[i] == ' ') {
                i++;
            }
            st = 0;
            break;
        }
    }
    return len;
}

References i, len, rz_num_is_op(), rz_num_str_len(), and cmd_descs_generate::str.

Referenced by rz_num_str_len(), and rz_num_str_split().

rz_num_str_split()

RZ_API int rz_num_str_split

(

char *

str

)

Definition at line 893 of file unum.c.

                                       {
    int i = 0, count = 0;
    const int len = strlen(str);
    while (i < len) {
        i += rz_num_str_len(str + i);
        str[i] = '\0';
        i++;
        count++;
    }
    return count;
}

References count, i, len, rz_num_str_len(), and cmd_descs_generate::str.

Referenced by rz_num_str_split_list().

rz_num_str_split_list()

RZ_API RzList* rz_num_str_split_list

(

char *

str

)

Definition at line 905 of file unum.c.

                                                  {
    int i, count = rz_num_str_split(str);
    RzList *list = rz_list_new();
    for (i = 0; i < count; i++) {
        rz_list_append(list, str);
        str += strlen(str) + 1;
    }
    return list;
}

References count, i, list(), rz_list_append(), rz_list_new(), rz_num_str_split(), and cmd_descs_generate::str.

Referenced by rz_cmd_help(), rz_cmd_search(), and rz_num_between().

rz_num_tail()

RZ_API ut64 rz_num_tail	(	RzNum *	num,
		ut64	addr,
		const char *	hex
	)

Definition at line 775 of file unum.c.

                                                                {
    ut64 mask = 0LL;
    ut64 n = 0;
    char *p;
    int i;
 
    while (*hex && (*hex == ' ' || *hex == '.')) {
        hex++;
    }
    i = strlen(hex) * 4;
    p = malloc(strlen(hex) + 10);
    if (p) {
        strcpy(p, "0x");
        strcpy(p + 2, hex);
        if (isxdigit((ut8)hex[0])) {
            n = rz_num_math(num, p);
        } else {
            eprintf("Invalid argument\n");
            free(p);
            return addr;
        }
        free(p);
    }
    mask = UT64_MAX << i;
    return (addr & mask) | n;
}

References addr, eprintf, free(), hex, i, isxdigit, malloc(), mask, n, num, p, rz_num_math(), ut64(), and UT64_MAX.

Referenced by cmd_dcu(), num_callback(), rz_core_cmd_subst_i(), and rz_core_seek_base().

rz_num_tail_base()

RZ_API ut64 rz_num_tail_base	(	RzNum *	num,
		ut64	addr,
		ut64	off
	)

Definition at line 753 of file unum.c.

                                                              {
    int i;
    bool ready = false;
    ut64 res = 0;
    for (i = 0; i < 16; i++) {
        ut64 o = __nth_nibble(off, i);
        if (!ready) {
            bool iseq = __nth_nibble(addr, i) == o;
            if (i == 0 && !iseq) {
                return UT64_MAX;
            }
            if (iseq) {
                continue;
            }
        }
        ready = true;
        ut8 pos = (15 - i) * 4;
        res |= (o << pos);
    }
    return res;
}

References __nth_nibble(), addr, i, off, pos, ut64(), and UT64_MAX.

Referenced by filter().

rz_num_to_bits()

RZ_API int rz_num_to_bits	(	char *	out,
		ut64	num
	)

Definition at line 542 of file unum.c.

                                               {
    int size = 64, i;
 
    if (num >> 32) {
        size = 64;
    } else if (num & 0xff000000) {
        size = 32;
    } else if (num & 0xff0000) {
        size = 24;
    } else if (num & 0xff00) {
        size = 16;
    } else if (num & 0xff) {
        size = 8;
    }
    if (out) {
        int pos = 0;
        int realsize = 0;
        int hasbit = 0;
        for (i = 0; i < size; i++) {
            char bit = ((num >> (size - i - 1)) & 1) ? '1' : '0';
            if (hasbit || bit == '1') {
                out[pos++] = bit; // size - 1 - i] = bit;
            }
            if (!hasbit && bit == '1') {
                hasbit = 1;
                realsize = size - i;
            }
        }
        if (realsize == 0) {
            out[realsize++] = '0';
        }
        out[realsize] = '\0'; // Maybe not nesesary?
    }
    return size;
}

References bit, i, num, out, and pos.

Referenced by filter(), format_output(), rax(), and rz_cmd_help().

rz_num_to_trits()

RZ_API int rz_num_to_trits	(	char *	out,
		ut64	num
	)

Definition at line 578 of file unum.c.

                                                {
    if (out == NULL) {
        return false;
    }
    int i;
    for (i = 0; num; i++, num /= 3) {
        out[i] = (char)('0' + num % 3);
    }
    if (i == 0) {
        out[0] = '0';
        i++;
    }
    out[i] = '\0';
 
    rz_str_reverse(out);
    return true;
}

References i, NULL, num, out, and rz_str_reverse().

Referenced by format_output(), rax(), and rz_cmd_help().

rz_num_units()

RZ_API char* rz_num_units	(	char *	buf,
		size_t	len,
		ut64	num
	)

Convert size in bytes to human-readable string

Result is stored in buf (buf should be at least 8 bytes in size). If buf is NULL, memory for the new string is obtained with malloc(3), and can be freed with free(3).

On success, returns a pointer to buf. It returns NULL if insufficient memory was available.

Definition at line 108 of file unum.c.

                                                           {
    long double fnum;
    char unit;
    const char *fmt_str;
    if (!buf) {
        buf = malloc(len + 1);
        if (!buf) {
            return NULL;
        }
    }
    fnum = (long double)num;
    if (num >= EB) {
        unit = 'E';
        fnum /= EB;
    } else if (num >= PB) {
        unit = 'P';
        fnum /= PB;
    } else if (num >= TB) {
        unit = 'T';
        fnum /= TB;
    } else if (num >= GB) {
        unit = 'G';
        fnum /= GB;
    } else if (num >= MB) {
        unit = 'M';
        fnum /= MB;
    } else if (num >= KB) {
        unit = 'K';
        fnum /= KB;
    } else {
        unit = '\0';
    }
    fmt_str = ((double)ceill(fnum) == (double)fnum)
        ? "%.0" LDBLFMT "%c"
        : "%.1" LDBLFMT "%c";
    snprintf(buf, len, fmt_str, fnum, unit);
    return buf;
}

References EB, GB, KB, LDBLFMT, len, malloc(), MB, NULL, num, PB, snprintf, and TB.

Referenced by bin_resources_print_standard(), print_arena_stats(), print_debug_map_line(), print_debug_maps_ascii_art(), rax(), rz_cmd_help(), rz_cmd_info_section_bars_handler(), rz_cons_flush(), rz_core_file_info_print(), and rz_resize_human_handler().