unum.c File Reference

#include <errno.h>
#include <math.h>
#include <rz_util.h>

Go to the source code of this file.

Macros
#define	RZ_NUM_USE_CALC   1
#define	KB   (1ULL << 10)
#define	MB   (1ULL << 20)
#define	GB   (1ULL << 30)
#define	TB   (1ULL << 40)
#define	PB   (1ULL << 50)
#define	EB   (1ULL << 60)
#define	NIBBLE_TO_HEX(n)   (((n)&0xf) > 9 ? 'a' + ((n)&0xf) - 10 : '0' + ((n)&0xf))

Functions
static ut64	rz_num_tailff (RzNum *num, const char *hex)
RZ_API bool	rz_num_is_hex_prefix (const char *p)
	Checks if the first two chars of p equal "0x". More...
static void	rz_srand (int seed)
static int	rz_rand (int mod)
RZ_API void	rz_num_irand (void)
RZ_API int	rz_num_rand (int max)
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 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 num)
RZ_API const char *	rz_num_get_name (RzNum *num, ut64 n)
static void	error (RzNum *num, const char *err_str)
RZ_API ut64	rz_num_get (RzNum *num, const char *str)
RZ_API ut64	rz_num_math (RzNum *num, const char *str)
RZ_API int	rz_num_is_float (RzNum *num, const char *str)
RZ_API double	rz_num_get_float (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 ut64	rz_num_chs (int cylinder, int head, int sector, int sectorsize)
RZ_API int	rz_num_conditional (RzNum *num, const char *str)
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)
static int	escape_char (char *dst, char byte)
RZ_API char *	rz_num_as_string (RzNum *___, ut64 n, bool printable_only)
RZ_API bool	rz_is_valid_input_num_value (RzNum *num, const char *input_value)
RZ_API ut64	rz_get_input_num_value (RzNum *num, const char *str)
static ut64	__nth_nibble (ut64 n, ut32 i)
RZ_API ut64	rz_num_tail_base (RzNum *num, ut64 addr, ut64 off)
RZ_API ut64	rz_num_tail (RzNum *num, ut64 addr, const char *hex)
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 double	rz_num_cos (double a)
RZ_API double	rz_num_sin (double a)
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...

Macro Definition Documentation

EB

#define EB   (1ULL << 60)

Definition at line 96 of file unum.c.

GB

#define GB   (1ULL << 30)

Definition at line 93 of file unum.c.

KB

#define KB   (1ULL << 10)

Definition at line 91 of file unum.c.

MB

#define MB   (1ULL << 20)

Definition at line 92 of file unum.c.

NIBBLE_TO_HEX

#define NIBBLE_TO_HEX

(

n

)

(((n)&0xf) > 9 ? 'a' + ((n)&0xf) - 10 : '0' + ((n)&0xf))

Definition at line 686 of file unum.c.

PB

#define PB   (1ULL << 50)

Definition at line 95 of file unum.c.

RZ_NUM_USE_CALC

#define RZ_NUM_USE_CALC   1

Definition at line 7 of file unum.c.

TB

#define TB   (1ULL << 40)

Definition at line 94 of file unum.c.

Function Documentation

__nth_nibble()

static ut64 __nth_nibble ( ut64  n, ut32  i  )

inlinestatic

Definition at line 747 of file unum.c.

                                                {
    int sz = (sizeof(n) << 1) - 1;
    int s = (sz - i) * 4;
    return (n >> s) & 0xf;
}

References i, n, and s.

Referenced by rz_num_tail_base().

error()

static void error ( RzNum *  num, const char *  err_str  )

static

Definition at line 161 of file unum.c.

                                                   {
    if (num) {
        num->nc.errors++;
#if 0
        num->nc.calc_err = err_str;
#endif
    }
}

References num.

Referenced by rz_num_get().

escape_char()

static int escape_char ( char *  dst, char  byte  )

static

Definition at line 687 of file unum.c.

                                             {
    const char escape_map[] = "abtnvfr";
    if (byte >= 7 && byte <= 13) {
        *(dst++) = '\\';
        *(dst++) = escape_map[byte - 7];
        *dst = 0;
        return 2;
    } else if (byte) {
        *(dst++) = '\\';
        *(dst++) = 'x';
        *(dst++) = NIBBLE_TO_HEX(byte >> 4);
        *(dst++) = NIBBLE_TO_HEX(byte);
        *dst = 0;
        return 4;
    }
    return 0;
}

References dst, and NIBBLE_TO_HEX.

Referenced by rz_num_as_string().

rz_get_input_num_value()

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

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_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_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_float()

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

Definition at line 532 of file unum.c.

                                                        {
    return (IS_DIGIT(*str) && (strchr(str, '.') || str[strlen(str) - 1] == 'f'));
}

References IS_DIGIT, and cmd_descs_generate::str.

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_tailff()

static ut64 rz_num_tailff ( RzNum *  num, const char *  hex  )

static

Definition at line 802 of file unum.c.

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

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

Referenced by rz_num_get().

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().

rz_rand()

static int rz_rand ( int  mod )

static

Definition at line 35 of file unum.c.

                            {
#if HAVE_ARC4RANDOM_UNIFORM
    return (int)arc4random_uniform(mod);
#else
    return rand() % mod;
#endif
}

References mod().

Referenced by rz_num_rand().

rz_srand()

static void rz_srand ( int  seed )

static

Definition at line 26 of file unum.c.

                               {
#if HAVE_ARC4RANDOM_UNIFORM
    // no-op
    (void)seed;
#else
    srand(seed);
#endif
}

Referenced by rz_num_irand().