portugalfuturista/rizin
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename RNum to the RzNum (#1539)

Browse source
This commit is contained in:
Anton Kochkov 2021-08-30 03:06:29 +08:00 committed by GitHub
parent 04a094a2e3
commit b9cb29ac90
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
28 changed files with 340 additions and 340 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
doc/esil.md
View file

@ -137,7 +137,7 @@ Variables
1. No predefined bitness (should be easy to extend them to 128,256 and 512bits, e.g. for MMX, SSE, AVX, Neon)
2. Infinite number (for SSA-form compatibility)
3. Register names have no specific syntax. They are just strings
4. Numbers can be specified in any base supported by RNum (dec, hex, oct, binary ...)
4. Numbers can be specified in any base supported by RzNum (dec, hex, oct, binary ...)
5. Each ESIL backend should have an associated RReg profile to describe the esil register specs
Bitarrays

2
librz/core/cmd_analysis.c
View file

@ -5793,7 +5793,7 @@ static void cmd_analysis_syscall(RzCore *core, const char *input) {
RzSyscallItem *si;
RzListIter *iter;
RzList *list;
RNum *num = NULL;
RzNum *num = NULL;
int n;
switch (input[0]) {

10
librz/core/cmd_help.c
View file

@ -184,7 +184,7 @@ static const char *help_msg_question_v[] = {
"$v", "", "opcode immediate value (e.g. lui a0,0x8010 => 0x8010)",
"$w", "", "get word size, 4 if asm.bits=32, 8 if 64, ...",
"$Xn", "", "get nth xref of function",
"RNum", "", "$variables usable in math expressions",
"RzNum", "", "$variables usable in math expressions",
NULL
};
@ -574,7 +574,7 @@ RZ_IPI int rz_cmd_help(void *data, const char *input) {
}
n = rz_num_math(core->num, str);
if (core->num->dbz) {
eprintf("RNum ERROR: Division by Zero\n");
eprintf("RzNum ERROR: Division by Zero\n");
}
asnum = rz_num_as_string(NULL, n, false);
/* decimal, hexa, octal */
@ -651,7 +651,7 @@ RZ_IPI int rz_cmd_help(void *data, const char *input) {
} break;
case 'q': // "?q"
if (core->num->dbz) {
eprintf("RNum ERROR: Division by Zero\n");
eprintf("RzNum ERROR: Division by Zero\n");
}
if (input[1] == '?') {
rz_cons_printf("|Usage: ?q [num] # Update $? without printing anything\n"
@ -676,7 +676,7 @@ RZ_IPI int rz_cmd_help(void *data, const char *input) {
}
}
if (core->num->dbz) {
eprintf("RNum ERROR: Division by Zero\n");
eprintf("RzNum ERROR: Division by Zero\n");
}
switch (input[1]) {
case '?':
@ -1113,7 +1113,7 @@ RZ_IPI int rz_cmd_help(void *data, const char *input) {
}
} else {
if (core->num->dbz) {
eprintf("RNum ERROR: Division by Zero\n");
eprintf("RzNum ERROR: Division by Zero\n");
}
rz_cons_printf("%" PFMT64d "\n", core->num->value);
}

4
librz/core/core.c
View file

@ -414,7 +414,7 @@ static ut64 bbSize(RzAnalysisFunction *fcn, ut64 addr) {
return 0;
}
static const char *str_callback(RNum *user, ut64 off, int *ok) {
static const char *str_callback(RzNum *user, ut64 off, int *ok) {
RzFlag *f = (RzFlag *)user;
if (ok) {
*ok = 0;
@ -431,7 +431,7 @@ static const char *str_callback(RNum *user, ut64 off, int *ok) {
return NULL;
}
static ut64 num_callback(RNum *userptr, const char *str, int *ok) {
static ut64 num_callback(RzNum *userptr, const char *str, int *ok) {
RzCore *core = (RzCore *)userptr; // XXX ?
RzAnalysisFunction *fcn;
char *ptr, *bptr, *out = NULL;

4
librz/debug/debug.c
View file

@ -342,7 +342,7 @@ RZ_API RzBreakpointItem *rz_debug_bp_add(RzDebug *dbg, ut64 addr, int hw, bool w
return bpi;
}
static const char *rz_debug_str_callback(RNum *userptr, ut64 off, int *ok) {
static const char *rz_debug_str_callback(RzNum *userptr, ut64 off, int *ok) {
// RzDebug *dbg = (RzDebug *)userptr;
eprintf("rz_debug_str_callback has been called. this should not happen\n");
return NULL;
@ -1184,7 +1184,7 @@ repeat:
if (dbg->corebind.core) {
RzCore *core = (RzCore *)dbg->corebind.core;
RNum *num = core->num;
RzNum *num = core->num;
if (reason == RZ_DEBUG_REASON_COND) {
if (bp && bp->cond && dbg->corebind.cmd) {
dbg->corebind.cmd(dbg->corebind.core, bp->cond);

2
librz/debug/dreg.c
View file

@ -152,7 +152,7 @@ RZ_API ut64 rz_debug_reg_get_err(RzDebug *dbg, const char *name, int *err, utX *
}
// XXX: dup for get_Err!
RZ_API ut64 rz_debug_num_callback(RNum *userptr, const char *str, int *ok) {
RZ_API ut64 rz_debug_num_callback(RzNum *userptr, const char *str, int *ok) {
RzDebug *dbg = (RzDebug *)userptr;
// resolve using regnu
return rz_debug_reg_get_err(dbg, str, ok, NULL);

4
librz/flag/flag.c
View file

@ -13,7 +13,7 @@ RZ_LIB_VERSION(rz_flag);
#define IS_FI_IN_SPACE(fi, sp) (!(sp) || (fi)->space == (sp))
#define STRDUP_OR_NULL(s) (!RZ_STR_ISEMPTY(s) ? strdup(s) : NULL)
static const char *str_callback(RNum *user, ut64 off, int *ok) {
static const char *str_callback(RzNum *user, ut64 off, int *ok) {
RzFlag *f = (RzFlag *)user;
if (ok) {
*ok = 0;
@ -45,7 +45,7 @@ static int flag_skiplist_cmp(const void *va, const void *vb) {
return a->off < b->off ? -1 : 1;
}
static ut64 num_callback(RNum *user, const char *name, int *ok) {
static ut64 num_callback(RzNum *user, const char *name, int *ok) {
RzFlag *f = (RzFlag *)user;
if (ok) {
*ok = 0;

2
librz/include/rz_asm.h
View file

@ -108,7 +108,7 @@ typedef struct rz_asm_t {
RzParse *ofilter;
Sdb *pair;
RzSyscall *syscall;
RNum *num;
RzNum *num;
char *features;
char *platforms;
int invhex; // invalid instructions displayed in hex

2
librz/include/rz_cmd.h
View file

@ -141,7 +141,7 @@ typedef struct rz_cmd_macro_t {
RzCoreCmd cmd;
PrintfCallback cb_printf;
void *user;
RNum *num;
RzNum *num;
int labels_n;
RzCmdMacroLabel labels[MACRO_LABELS];
RzList *macros;

2
librz/include/rz_config.h
View file

@ -41,7 +41,7 @@ RZ_API const char *rz_config_node_type(RzConfigNode *node);
typedef struct rz_config_t {
int lock;
void *user;
RNum *num;
RzNum *num;
PrintfCallback cb_printf;
RzList *nodes;
HtPP *ht;

2
librz/include/rz_cons.h
View file

@ -523,7 +523,7 @@ typedef struct rz_cons_t {
UINT old_cp;
UINT old_ocp;
#endif
RNum *num;
RzNum *num;
/* Pager (like more or less) to use if the output doesn't fit on the
* current window. If NULL or "" no pager is used. */
char *pager;

2
librz/include/rz_core.h
View file

@ -287,7 +287,7 @@ struct rz_core_t {
RzIO *io;
RzCoreFile *file;
RzList *files;
RNum *num;
RzNum *num;
ut64 rc; // command's return code .. related to num->value;
RzLib *lib;
RzCmd *rcmd;

4
librz/include/rz_debug.h
View file

@ -322,7 +322,7 @@ typedef struct rz_debug_t {
RzCoreBind corebind;
// internal use only
int _mode;
RNum *num;
RzNum *num;
RzEgg *egg;
bool verbose;
bool main_arena_resolved; /* is the main_arena resolved already? */
@ -564,7 +564,7 @@ RZ_API int rz_debug_drx_set(RzDebug *dbg, int idx, ut64 addr, int len, int rwx,
RZ_API int rz_debug_drx_unset(RzDebug *dbg, int idx);
/* esil */
RZ_API ut64 rz_debug_num_callback(RNum *userptr, const char *str, int *ok);
RZ_API ut64 rz_debug_num_callback(RzNum *userptr, const char *str, int *ok);
RZ_API int rz_debug_esil_stepi(RzDebug *dbg);
RZ_API ut64 rz_debug_esil_step(RzDebug *dbg, ut32 count);
RZ_API ut64 rz_debug_esil_continue(RzDebug *dbg);

2
librz/include/rz_flag.h
View file

@ -48,7 +48,7 @@ typedef struct rz_flag_t {
st64 base; /* base address for all flag items */
bool realnames;
Sdb *tags;
RNum *num;
RzNum *num;
RzSkipList *by_off; /* flags sorted by offset, value=RzFlagsAtOffset */
HtPP *ht_name; /* hashmap key=item name, value=RzFlagItem * */
PrintfCallback cb_printf;

2
librz/include/rz_type.h
View file

@ -34,7 +34,7 @@ typedef struct rz_type_db_t {
HtPP /* <char *, RzCallable *> */ *callables; //< name -> RzCallable (function type)
RzTypeTarget *target;
RzTypeParser *parser;
RNum *num;
RzNum *num;
RzIOBind iob; // for RzIO in formats
} RzTypeDB;

58
librz/include/rz_util/rz_big.h
View file

@ -9,9 +9,9 @@ extern "C" {
#if HAVE_LIB_GMP
/* Use GMP's data struct */
#define RNumBig mpz_t
#define RzNumBig mpz_t
#elif HAVE_LIB_SSL
#define RNumBig BIGNUM
#define RzNumBig BIGNUM
#else
/* Use default impl */
#define RZ_BIG_WORD_SIZE 4
@ -28,43 +28,43 @@ extern "C" {
typedef struct rz_num_big_t {
RZ_BIG_DTYPE array[RZ_BIG_ARRAY_SIZE];
int sign;
} RNumBig;
} RzNumBig;
#endif
RZ_API RNumBig *rz_big_new(void);
RZ_API void rz_big_free(RNumBig *b);
RZ_API void rz_big_init(RNumBig *b);
RZ_API void rz_big_fini(RNumBig *b);
RZ_API RzNumBig *rz_big_new(void);
RZ_API void rz_big_free(RzNumBig *b);
RZ_API void rz_big_init(RzNumBig *b);
RZ_API void rz_big_fini(RzNumBig *b);
/* Assignment operations */
RZ_API void rz_big_from_int(RNumBig *b, st64 v);
RZ_API st64 rz_big_to_int(RNumBig *b);
RZ_API void rz_big_from_hexstr(RNumBig *b, const char *str);
RZ_API char *rz_big_to_hexstr(RNumBig *b);
RZ_API void rz_big_assign(RNumBig *dst, RNumBig *src);
RZ_API void rz_big_from_int(RzNumBig *b, st64 v);
RZ_API st64 rz_big_to_int(RzNumBig *b);
RZ_API void rz_big_from_hexstr(RzNumBig *b, const char *str);
RZ_API char *rz_big_to_hexstr(RzNumBig *b);
RZ_API void rz_big_assign(RzNumBig *dst, RzNumBig *src);
/* Basic arithmetic operations */
RZ_API void rz_big_add(RNumBig *c, RNumBig *a, RNumBig *b); /* c = a + b */
RZ_API void rz_big_sub(RNumBig *c, RNumBig *a, RNumBig *b); /* c = a - b */
RZ_API void rz_big_mul(RNumBig *c, RNumBig *a, RNumBig *b); /* c = a * b */
RZ_API void rz_big_div(RNumBig *c, RNumBig *a, RNumBig *b); /* c = a / b */
RZ_API void rz_big_mod(RNumBig *c, RNumBig *a, RNumBig *b); /* c = a % b */
RZ_API void rz_big_divmod(RNumBig *c, RNumBig *d, RNumBig *a, RNumBig *b); /* c = a/b, d = a%b */
RZ_API void rz_big_add(RzNumBig *c, RzNumBig *a, RzNumBig *b); /* c = a + b */
RZ_API void rz_big_sub(RzNumBig *c, RzNumBig *a, RzNumBig *b); /* c = a - b */
RZ_API void rz_big_mul(RzNumBig *c, RzNumBig *a, RzNumBig *b); /* c = a * b */
RZ_API void rz_big_div(RzNumBig *c, RzNumBig *a, RzNumBig *b); /* c = a / b */
RZ_API void rz_big_mod(RzNumBig *c, RzNumBig *a, RzNumBig *b); /* c = a % b */
RZ_API void rz_big_divmod(RzNumBig *c, RzNumBig *d, RzNumBig *a, RzNumBig *b); /* c = a/b, d = a%b */
/* Bitwise operations(for >= 0) */
RZ_API void rz_big_and(RNumBig *c, RNumBig *a, RNumBig *b); /* c = a & b */
RZ_API void rz_big_or(RNumBig *c, RNumBig *a, RNumBig *b); /* c = a | b */
RZ_API void rz_big_xor(RNumBig *c, RNumBig *a, RNumBig *b); /* c = a ^ b */
RZ_API void rz_big_lshift(RNumBig *c, RNumBig *a, size_t nbits); /* c = a << nbits */
RZ_API void rz_big_rshift(RNumBig *c, RNumBig *a, size_t nbits); /* c = a >> nbits */
RZ_API void rz_big_and(RzNumBig *c, RzNumBig *a, RzNumBig *b); /* c = a & b */
RZ_API void rz_big_or(RzNumBig *c, RzNumBig *a, RzNumBig *b); /* c = a | b */
RZ_API void rz_big_xor(RzNumBig *c, RzNumBig *a, RzNumBig *b); /* c = a ^ b */
RZ_API void rz_big_lshift(RzNumBig *c, RzNumBig *a, size_t nbits); /* c = a << nbits */
RZ_API void rz_big_rshift(RzNumBig *c, RzNumBig *a, size_t nbits); /* c = a >> nbits */
/* Special operators and comparison */
RZ_API int rz_big_cmp(RNumBig *a, RNumBig *b); /* Return 1 if a>b, -1 if a<b, else 0 */
RZ_API int rz_big_is_zero(RNumBig *a); /* For comparison with zero */
RZ_API void rz_big_inc(RNumBig *a); /* Increment: add one to n */
RZ_API void rz_big_dec(RNumBig *a); /* Decrement: subtract one from n */
RZ_API void rz_big_powm(RNumBig *c, RNumBig *a, RNumBig *b, RNumBig *m); /* Calculate a^b -- e.g. 2^10 => 1024 */
RZ_API void rz_big_isqrt(RNumBig *c, RNumBig *a); /* Integer square root -- e.g. isqrt(5) => 2*/
RZ_API int rz_big_cmp(RzNumBig *a, RzNumBig *b); /* Return 1 if a>b, -1 if a<b, else 0 */
RZ_API int rz_big_is_zero(RzNumBig *a); /* For comparison with zero */
RZ_API void rz_big_inc(RzNumBig *a); /* Increment: add one to n */
RZ_API void rz_big_dec(RzNumBig *a); /* Decrement: subtract one from n */
RZ_API void rz_big_powm(RzNumBig *c, RzNumBig *a, RzNumBig *b, RzNumBig *m); /* Calculate a^b -- e.g. 2^10 => 1024 */
RZ_API void rz_big_isqrt(RzNumBig *c, RzNumBig *a); /* Integer square root -- e.g. isqrt(5) => 2*/
#ifdef __cplusplus
}

56
librz/include/rz_util/rz_num.h
View file

@ -10,7 +10,7 @@ extern "C" {
typedef struct {
double d;
ut64 n;
} RNumCalcValue;
} RzNumCalcValue;
typedef enum {
RNCNAME,
@ -38,11 +38,11 @@ typedef enum {
RNCSHR = '>',
RNCROL = '#',
RNCROR = '$'
} RNumCalcToken;
} RzNumCalcToken;
typedef struct rz_num_calc_t {
RNumCalcToken curr_tok;
RNumCalcValue number_value;
RzNumCalcToken curr_tok;
RzNumCalcValue number_value;
char string_value[RZ_NUMCALC_STRSZ];
int errors;
char oc;
@ -51,56 +51,56 @@ typedef struct rz_num_calc_t {
const char *calc_buf;
int calc_len;
bool under_calc;
} RNumCalc;
} RzNumCalc;
typedef struct rz_num_t {
ut64 (*callback)(struct rz_num_t *userptr, const char *str, int *ok);
const char *(*cb_from_value)(struct rz_num_t *userptr, ut64 value, int *ok);
// RNumCallback callback;
// RzNumCallback callback;
ut64 value;
double fvalue;
void *userptr;
int dbz; /// division by zero happened
RNumCalc nc;
} RNum;
RzNumCalc nc;
} RzNum;
typedef ut64 (*RNumCallback)(struct rz_num_t *self, const char *str, int *ok);
typedef const char *(*RNumCallback2)(struct rz_num_t *self, ut64, int *ok);
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);
RZ_API RNum *rz_num_new(RNumCallback cb, RNumCallback2 cb2, void *ptr);
RZ_API void rz_num_free(RNum *num);
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(RNum *num, const char *str);
RZ_API ut64 rz_num_calc(RNum *num, const char *str, const char **err);
RZ_API const char *rz_num_calc_index(RNum *num, const char *p);
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(RNum *num, const char *input_value);
RZ_API ut64 rz_num_get_input_value(RNum *num, const char *input_value);
RZ_API const char *rz_num_get_name(RNum *num, ut64 n);
RZ_API char *rz_num_as_string(RNum *___, ut64 n, bool printable_only);
RZ_API ut64 rz_num_tail(RNum *num, ut64 addr, const char *hex);
RZ_API ut64 rz_num_tail_base(RNum *num, ut64 addr, ut64 off);
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); // XXX this can be a cpp macro :??
RZ_API ut64 rz_num_math(RNum *num, const char *str);
RZ_API ut64 rz_num_get(RNum *num, const char *str);
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); //Rename this please
RZ_API int rz_num_rand(int max);
RZ_API void rz_num_irand(void);
RZ_API ut16 rz_num_ntohs(ut16 foo);
RZ_API ut64 rz_get_input_num_value(RNum *num, const char *input_value);
RZ_API bool rz_is_valid_input_num_value(RNum *num, const char *input_value);
RZ_API int rz_num_between(RNum *num, const char *input_value);
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(RNum *num, RZ_NONNULL const char *str);
RZ_API size_t rz_num_base_of_string(RzNum *num, RZ_NONNULL const char *str);
RZ_API double rz_num_cos(double a);
RZ_API double rz_num_sin(double a);
RZ_API double rz_num_get_float(RNum *num, const char *str);
RZ_API double rz_num_get_float(RzNum *num, const char *str);
static inline st64 rz_num_abs(st64 num) {
return num < 0 ? -num : num;

2
librz/include/rz_util/rz_print.h
View file

@ -97,7 +97,7 @@ typedef struct rz_print_t {
Sdb *sdb_types;
RzCons *cons;
RzConsBind consbind;
RNum *num;
RzNum *num;
RzReg *reg;
RzRegItem *(*get_register)(RzReg *reg, const char *name, int type);
ut64 (*get_register_value)(RzReg *reg, RzRegItem *item);

14
librz/main/rz-ax.c
View file

@ -7,9 +7,9 @@
// don't use fixed sized buffers
#define STDIN_BUFFER_SIZE 354096
static int rax(RNum *num, char *str, int len, int last, ut64 *flags, int *fm);
static int rax(RzNum *num, char *str, int len, int last, ut64 *flags, int *fm);
static int use_stdin(RNum *num, ut64 *flags, int *fm) {
static int use_stdin(RzNum *num, ut64 *flags, int *fm) {
if (!flags) {
return 0;
}
@ -48,7 +48,7 @@ static int use_stdin(RNum *num, ut64 *flags, int *fm) {
return 0;
}
static int format_output(RNum *num, char mode, const char *s, int force_mode, ut64 flags) {
static int format_output(RzNum *num, char mode, const char *s, int force_mode, ut64 flags) {
ut64 n = rz_num_math(num, s);
char strbits[65];
if (force_mode) {
@ -159,7 +159,7 @@ static int help(void) {
return true;
}
static int rax(RNum *num, char *str, int len, int last, ut64 *_flags, int *fm) {
static int rax(RzNum *num, char *str, int len, int last, ut64 *_flags, int *fm) {
ut64 flags = *_flags;
const char *nl = "";
ut8 *buf;
@ -467,7 +467,7 @@ dotherax:
ut64 n = rz_num_math(num, str);
if (num->dbz) {
eprintf("RNum ERROR: Division by Zero\n");
eprintf("RzNum ERROR: Division by Zero\n");
return false;
}
n32 = (ut32)(n & UT32_MAX);
@ -562,7 +562,7 @@ dotherax:
ut64 n = rz_num_math(num, modified_str);
free(modified_str);
if (num->dbz) {
eprintf("RNum ERROR: Division by Zero\n");
eprintf("RzNum ERROR: Division by Zero\n");
return false;
}
@ -633,7 +633,7 @@ dotherax:
RZ_API int rz_main_rz_ax(int argc, const char **argv) {
int i, fm = 0;
RNum *num = rz_num_new(NULL, NULL, NULL);
RzNum *num = rz_num_new(NULL, NULL, NULL);
if (argc == 1) {
use_stdin(num, 0, &fm);
} else {

2
librz/type/format.c
View file

@ -55,7 +55,7 @@ static float updateAddr(const ut8 *buf, int len, int endian, ut64 *addr, ut64 *a
return f;
}
static int rz_get_size(RNum *num, ut8 *buf, int endian, const char *s) {
static int rz_get_size(RzNum *num, ut8 *buf, int endian, const char *s) {
int len = strlen(s);
if (s[0] == '*' && len >= 4) { // value pointed by the address
ut64 addr;

58
librz/util/big-gmp.c
View file

@ -4,36 +4,36 @@
#include <rz_util.h>
RZ_API RNumBig *rz_big_new(void) {
RNumBig *n = RZ_NEW(RNumBig);
RZ_API RzNumBig *rz_big_new(void) {
RzNumBig *n = RZ_NEW(RzNumBig);
if (n) {
mpz_init(*n);
}
return n;
}
RZ_API void rz_big_free(RNumBig *b) {
RZ_API void rz_big_free(RzNumBig *b) {
mpz_clear(*b);
free(b);
}
RZ_API void rz_big_init(RNumBig *b) {
RZ_API void rz_big_init(RzNumBig *b) {
mpz_init(*b);
}
RZ_API void rz_big_fini(RNumBig *b) {
RZ_API void rz_big_fini(RzNumBig *b) {
mpz_clear(*b);
}
RZ_API void rz_big_from_int(RNumBig *b, st64 v) {
RZ_API void rz_big_from_int(RzNumBig *b, st64 v) {
mpz_set_si(*b, v);
}
RZ_API st64 rz_big_to_int(RNumBig *b) {
RZ_API st64 rz_big_to_int(RzNumBig *b) {
return mpz_get_si(*b);
}
RZ_API void rz_big_from_hexstr(RNumBig *b, const char *str) {
RZ_API void rz_big_from_hexstr(RzNumBig *b, const char *str) {
if (rz_str_startswith(str, "0x")) {
str += 2;
mpz_set_str(*b, str, 16);
@ -44,7 +44,7 @@ RZ_API void rz_big_from_hexstr(RNumBig *b, const char *str) {
}
}
RZ_API char *rz_big_to_hexstr(RNumBig *b) {
RZ_API char *rz_big_to_hexstr(RzNumBig *b) {
char *tmp = mpz_get_str(NULL, 16, *b);
char *res;
if (tmp[0] == '-') {
@ -56,55 +56,55 @@ RZ_API char *rz_big_to_hexstr(RNumBig *b) {
return res;
}
RZ_API void rz_big_assign(RNumBig *dst, RNumBig *src) {
RZ_API void rz_big_assign(RzNumBig *dst, RzNumBig *src) {
mpz_set(*dst, *src);
}
RZ_API void rz_big_add(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_add(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
mpz_add(*c, *a, *b);
}
RZ_API void rz_big_sub(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_sub(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
mpz_sub(*c, *a, *b);
}
RZ_API void rz_big_mul(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_mul(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
mpz_mul(*c, *a, *b);
}
RZ_API void rz_big_div(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_div(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
mpz_tdiv_q(*c, *a, *b);
}
RZ_API void rz_big_mod(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_mod(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
mpz_mod(*c, *a, *b);
}
RZ_API void rz_big_divmod(RNumBig *c, RNumBig *d, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_divmod(RzNumBig *c, RzNumBig *d, RzNumBig *a, RzNumBig *b) {
mpz_tdiv_qr(*c, *d, *a, *b);
}
RZ_API void rz_big_and(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_and(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
mpz_and(*c, *a, *b);
}
RZ_API void rz_big_or(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_or(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
mpz_ior(*c, *a, *b);
}
RZ_API void rz_big_xor(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_xor(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
mpz_xor(*c, *a, *b);
}
RZ_API void rz_big_lshift(RNumBig *c, RNumBig *a, size_t nbits) {
RZ_API void rz_big_lshift(RzNumBig *c, RzNumBig *a, size_t nbits) {
mpz_mul_2exp(*c, *a, nbits);
}
RZ_API void rz_big_rshift(RNumBig *c, RNumBig *a, size_t nbits) {
RZ_API void rz_big_rshift(RzNumBig *c, RzNumBig *a, size_t nbits) {
mpz_tdiv_q_2exp(*c, *a, nbits);
}
RZ_API int rz_big_cmp(RNumBig *a, RNumBig *b) {
RZ_API int rz_big_cmp(RzNumBig *a, RzNumBig *b) {
int res = mpz_cmp(*a, *b);
if (res > 0) {
return 1;
@ -115,26 +115,26 @@ RZ_API int rz_big_cmp(RNumBig *a, RNumBig *b) {
}
}
RZ_API int rz_big_is_zero(RNumBig *a) {
RZ_API int rz_big_is_zero(RzNumBig *a) {
return mpz_cmp_ui(*a, 0) == 0;
}
RZ_API void rz_big_inc(RNumBig *a) {
RNumBig tmp;
RZ_API void rz_big_inc(RzNumBig *a) {
RzNumBig tmp;
mpz_init_set_si(tmp, 1);
mpz_add(*a, *a, tmp);
}
RZ_API void rz_big_dec(RNumBig *a) {
RNumBig tmp;
RZ_API void rz_big_dec(RzNumBig *a) {
RzNumBig tmp;
mpz_init_set_si(tmp, 1);
mpz_sub(*a, *a, tmp);
}
RZ_API void rz_big_powm(RNumBig *c, RNumBig *a, RNumBig *b, RNumBig *m) {
RZ_API void rz_big_powm(RzNumBig *c, RzNumBig *a, RzNumBig *b, RzNumBig *m) {
mpz_powm(*c, *a, *b, *m);
}
RZ_API void rz_big_isqrt(RNumBig *c, RNumBig *a) {
RZ_API void rz_big_isqrt(RzNumBig *c, RzNumBig *a) {
mpz_sqrt(*c, *a);
}

86
librz/util/big-ssl.c
View file

@ -4,23 +4,23 @@
#include <rz_util.h>
RZ_API RNumBig *rz_big_new(void) {
RZ_API RzNumBig *rz_big_new(void) {
return BN_new();
}
RZ_API void rz_big_free(RNumBig *b) {
RZ_API void rz_big_free(RzNumBig *b) {
BN_free(b);
}
RZ_API void rz_big_init(RNumBig *b) {
RZ_API void rz_big_init(RzNumBig *b) {
BN_zero(b);
}
RZ_API void rz_big_fini(RNumBig *b) {
RZ_API void rz_big_fini(RzNumBig *b) {
BN_clear(b);
}
RZ_API void rz_big_from_int(RNumBig *b, st64 v) {
RZ_API void rz_big_from_int(RzNumBig *b, st64 v) {
if (v < 0) {
BN_set_word(b, -v);
BN_set_negative(b, v);
@ -29,12 +29,12 @@ RZ_API void rz_big_from_int(RNumBig *b, st64 v) {
}
}
RZ_API st64 rz_big_to_int(RNumBig *b) {
RZ_API st64 rz_big_to_int(RzNumBig *b) {
BN_ULONG maxx = 0;
maxx = ~maxx;
BN_ULONG res = BN_get_word(b);
if (res == maxx) {
RNumBig *B = rz_big_new();
RzNumBig *B = rz_big_new();
rz_big_assign(B, b);
BN_mask_bits(B, BN_BYTES * 8 - 1);
res = BN_get_word(B);
@ -44,7 +44,7 @@ RZ_API st64 rz_big_to_int(RNumBig *b) {
return res;
}
RZ_API void rz_big_from_hexstr(RNumBig *b, const char *str) {
RZ_API void rz_big_from_hexstr(RzNumBig *b, const char *str) {
if (rz_str_startswith(str, "0x")) {
str += 2;
BN_hex2bn(&b, str);
@ -55,7 +55,7 @@ RZ_API void rz_big_from_hexstr(RNumBig *b, const char *str) {
}
}
RZ_API char *rz_big_to_hexstr(RNumBig *b) {
RZ_API char *rz_big_to_hexstr(RzNumBig *b) {
char *tmp = BN_bn2hex(b);
char *res;
if (tmp[0] == '-') {
@ -70,47 +70,47 @@ RZ_API char *rz_big_to_hexstr(RNumBig *b) {
return res;
}
RZ_API void rz_big_assign(RNumBig *dst, RNumBig *src) {
RZ_API void rz_big_assign(RzNumBig *dst, RzNumBig *src) {
BN_copy(dst, src);
}
RZ_API void rz_big_add(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_add(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
BN_add(c, a, b);
}
RZ_API void rz_big_sub(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_sub(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
BN_sub(c, a, b);
}
RZ_API void rz_big_mul(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_mul(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
BN_CTX *bn_ctx = BN_CTX_new();
BN_mul(c, a, b, bn_ctx);
BN_CTX_free(bn_ctx);
}
RZ_API void rz_big_div(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_div(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
BN_CTX *bn_ctx = BN_CTX_new();
BN_div(c, NULL, a, b, bn_ctx);
BN_CTX_free(bn_ctx);
}
RZ_API void rz_big_mod(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_mod(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
BN_CTX *bn_ctx = BN_CTX_new();
BN_mod(c, a, b, bn_ctx);
BN_CTX_free(bn_ctx);
}
RZ_API void rz_big_divmod(RNumBig *c, RNumBig *d, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_divmod(RzNumBig *c, RzNumBig *d, RzNumBig *a, RzNumBig *b) {
BN_CTX *bn_ctx = BN_CTX_new();
BN_div(c, d, a, b, bn_ctx);
BN_CTX_free(bn_ctx);
}
RZ_API void rz_big_and(RNumBig *c, RNumBig *a, RNumBig *b) {
RNumBig *A = rz_big_new();
RNumBig *B = rz_big_new();
RNumBig *C = rz_big_new();
RNumBig *addition = rz_big_new();
RZ_API void rz_big_and(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
RzNumBig *A = rz_big_new();
RzNumBig *B = rz_big_new();
RzNumBig *C = rz_big_new();
RzNumBig *addition = rz_big_new();
size_t step = 4 * 8, move = 0;
ut32 tmp = 0;
@ -137,11 +137,11 @@ RZ_API void rz_big_and(RNumBig *c, RNumBig *a, RNumBig *b) {
rz_big_free(addition);
}
RZ_API void rz_big_or(RNumBig *c, RNumBig *a, RNumBig *b) {
RNumBig *A = rz_big_new();
RNumBig *B = rz_big_new();
RNumBig *C = rz_big_new();
RNumBig *addition = rz_big_new();
RZ_API void rz_big_or(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
RzNumBig *A = rz_big_new();
RzNumBig *B = rz_big_new();
RzNumBig *C = rz_big_new();
RzNumBig *addition = rz_big_new();
size_t step = 4 * 8, move = 0;
ut32 tmp = 0;
@ -168,11 +168,11 @@ RZ_API void rz_big_or(RNumBig *c, RNumBig *a, RNumBig *b) {
rz_big_free(addition);
}
RZ_API void rz_big_xor(RNumBig *c, RNumBig *a, RNumBig *b) {
RNumBig *A = rz_big_new();
RNumBig *B = rz_big_new();
RNumBig *C = rz_big_new();
RNumBig *addition = rz_big_new();
RZ_API void rz_big_xor(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
RzNumBig *A = rz_big_new();
RzNumBig *B = rz_big_new();
RzNumBig *C = rz_big_new();
RzNumBig *addition = rz_big_new();
size_t step = 4 * 8, move = 0;
ut32 tmp = 0;
@ -199,41 +199,41 @@ RZ_API void rz_big_xor(RNumBig *c, RNumBig *a, RNumBig *b) {
rz_big_free(addition);
}
RZ_API void rz_big_lshift(RNumBig *c, RNumBig *a, size_t nbits) {
RZ_API void rz_big_lshift(RzNumBig *c, RzNumBig *a, size_t nbits) {
BN_lshift(c, a, nbits);
}
RZ_API void rz_big_rshift(RNumBig *c, RNumBig *a, size_t nbits) {
RZ_API void rz_big_rshift(RzNumBig *c, RzNumBig *a, size_t nbits) {
BN_rshift(c, a, nbits);
}
RZ_API int rz_big_cmp(RNumBig *a, RNumBig *b) {
RZ_API int rz_big_cmp(RzNumBig *a, RzNumBig *b) {
return BN_cmp(a, b);
}
RZ_API int rz_big_is_zero(RNumBig *a) {
RZ_API int rz_big_is_zero(RzNumBig *a) {
return BN_is_zero(a);
}
RZ_API void rz_big_inc(RNumBig *a) {
RZ_API void rz_big_inc(RzNumBig *a) {
BN_add_word(a, 1);
}
RZ_API void rz_big_dec(RNumBig *a) {
RZ_API void rz_big_dec(RzNumBig *a) {
BN_sub_word(a, 1);
}
RZ_API void rz_big_powm(RNumBig *c, RNumBig *a, RNumBig *b, RNumBig *m) {
RZ_API void rz_big_powm(RzNumBig *c, RzNumBig *a, RzNumBig *b, RzNumBig *m) {
BN_CTX *bn_ctx = BN_CTX_new();
BN_mod_exp(c, a, b, m, bn_ctx);
BN_CTX_free(bn_ctx);
}
RZ_API void rz_big_isqrt(RNumBig *b, RNumBig *a) {
RNumBig *tmp = rz_big_new();
RNumBig *low = rz_big_new();
RNumBig *high = rz_big_new();
RNumBig *mid = rz_big_new();
RZ_API void rz_big_isqrt(RzNumBig *b, RzNumBig *a) {
RzNumBig *tmp = rz_big_new();
RzNumBig *low = rz_big_new();
RzNumBig *high = rz_big_new();
RzNumBig *mid = rz_big_new();
rz_big_assign(high, a);
rz_big_rshift(mid, high, 1);

116
librz/util/big.c
View file

@ -8,33 +8,33 @@
#include <rz_util.h>
/* Functions for shifting number in-place. */
static void _lshift_one_bit(RNumBig *a);
static void _rshift_one_bit(RNumBig *a);
static void _lshift_word(RNumBig *a, int nwords);
static void _rshift_word(RNumBig *a, int nwords);
static void _r_big_zero_out(RNumBig *n);
static void _lshift_one_bit(RzNumBig *a);
static void _rshift_one_bit(RzNumBig *a);
static void _lshift_word(RzNumBig *a, int nwords);
static void _rshift_word(RzNumBig *a, int nwords);
static void _r_big_zero_out(RzNumBig *n);
RZ_API RNumBig *rz_big_new(void) {
RNumBig *n = RZ_NEW(RNumBig);
RZ_API RzNumBig *rz_big_new(void) {
RzNumBig *n = RZ_NEW(RzNumBig);
if (n) {
_r_big_zero_out(n);
}
return n;
}
RZ_API void rz_big_free(RNumBig *b) {
RZ_API void rz_big_free(RzNumBig *b) {
free(b);
}
RZ_API void rz_big_init(RNumBig *b) {
RZ_API void rz_big_init(RzNumBig *b) {
_r_big_zero_out(b);
}
RZ_API void rz_big_fini(RNumBig *b) {
RZ_API void rz_big_fini(RzNumBig *b) {
_r_big_zero_out(b);
}
RZ_API void rz_big_from_int(RNumBig *b, st64 n) {
RZ_API void rz_big_from_int(RzNumBig *b, st64 n) {
rz_return_if_fail(b);
_r_big_zero_out(b);
@ -60,7 +60,7 @@ RZ_API void rz_big_from_int(RNumBig *b, st64 n) {
#endif
}
static void rz_big_from_unsigned(RNumBig *b, ut64 v) {
static void rz_big_from_unsigned(RzNumBig *b, ut64 v) {
rz_return_if_fail(b);
_r_big_zero_out(b);
@ -84,7 +84,7 @@ static void rz_big_from_unsigned(RNumBig *b, ut64 v) {
#endif
}
RZ_API st64 rz_big_to_int(RNumBig *b) {
RZ_API st64 rz_big_to_int(RzNumBig *b) {
rz_return_val_if_fail(b, 0);
RZ_BIG_DTYPE_TMP ret = 0;
@ -110,7 +110,7 @@ RZ_API st64 rz_big_to_int(RNumBig *b) {
return ret;
}
RZ_API void rz_big_from_hexstr(RNumBig *n, const char *str) {
RZ_API void rz_big_from_hexstr(RzNumBig *n, const char *str) {
rz_return_if_fail(n);
rz_return_if_fail(str);
int nbytes = strlen(str);
@ -154,7 +154,7 @@ RZ_API void rz_big_from_hexstr(RNumBig *n, const char *str) {
}
}
RZ_API char *rz_big_to_hexstr(RNumBig *b) {
RZ_API char *rz_big_to_hexstr(RzNumBig *b) {
rz_return_val_if_fail(b, NULL);
int j = RZ_BIG_ARRAY_SIZE - 1; /* index into array - reading "MSB" first -> big-endian */
@ -197,14 +197,14 @@ RZ_API char *rz_big_to_hexstr(RNumBig *b) {
return ret_str;
}
RZ_API void rz_big_assign(RNumBig *dst, RNumBig *src) {
RZ_API void rz_big_assign(RzNumBig *dst, RzNumBig *src) {
rz_return_if_fail(dst);
rz_return_if_fail(src);
memcpy(dst, src, sizeof(RNumBig));
memcpy(dst, src, sizeof(RzNumBig));
}
static void rz_big_add_inner(RNumBig *c, RNumBig *a, RNumBig *b) {
static void rz_big_add_inner(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
RZ_BIG_DTYPE_TMP tmp;
int carry = 0;
int i;
@ -215,9 +215,9 @@ static void rz_big_add_inner(RNumBig *c, RNumBig *a, RNumBig *b) {
}
}
static void rz_big_sub_inner(RNumBig *c, RNumBig *a, RNumBig *b) {
static void rz_big_sub_inner(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
RZ_BIG_DTYPE_TMP res;
RNumBig *tmp;
RzNumBig *tmp;
RZ_BIG_DTYPE_TMP tmp1;
RZ_BIG_DTYPE_TMP tmp2;
int borrow = 0;
@ -239,7 +239,7 @@ static void rz_big_sub_inner(RNumBig *c, RNumBig *a, RNumBig *b) {
}
}
RZ_API void rz_big_add(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_add(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
rz_return_if_fail(a);
rz_return_if_fail(b);
rz_return_if_fail(c);
@ -264,7 +264,7 @@ RZ_API void rz_big_add(RNumBig *c, RNumBig *a, RNumBig *b) {
}
}
RZ_API void rz_big_sub(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_sub(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
rz_return_if_fail(a);
rz_return_if_fail(b);
rz_return_if_fail(c);
@ -289,14 +289,14 @@ RZ_API void rz_big_sub(RNumBig *c, RNumBig *a, RNumBig *b) {
}
}
RZ_API void rz_big_mul(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_mul(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
rz_return_if_fail(a);
rz_return_if_fail(b);
rz_return_if_fail(c);
RNumBig *row = rz_big_new();
RNumBig *tmp = rz_big_new();
RNumBig *res = rz_big_new();
RzNumBig *row = rz_big_new();
RzNumBig *tmp = rz_big_new();
RzNumBig *res = rz_big_new();
int i, j;
for (i = 0; i < RZ_BIG_ARRAY_SIZE; i++) {
@ -325,16 +325,16 @@ RZ_API void rz_big_mul(RNumBig *c, RNumBig *a, RNumBig *b) {
rz_big_free(res);
}
RZ_API void rz_big_div(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_div(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
rz_return_if_fail(a);
rz_return_if_fail(b);
rz_return_if_fail(c);
rz_return_if_fail(!rz_big_is_zero(b));
RNumBig *current = rz_big_new();
RNumBig *denom = rz_big_new();
RzNumBig *current = rz_big_new();
RzNumBig *denom = rz_big_new();
;
RNumBig *tmp = rz_big_new();
RzNumBig *tmp = rz_big_new();
int sign = a->sign * b->sign;
rz_big_from_int(current, 1); // int current = 1;
@ -376,7 +376,7 @@ RZ_API void rz_big_div(RNumBig *c, RNumBig *a, RNumBig *b) {
rz_big_free(tmp);
}
RZ_API void rz_big_mod(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_mod(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
/*
Take divmod and throw away div part
*/
@ -385,14 +385,14 @@ RZ_API void rz_big_mod(RNumBig *c, RNumBig *a, RNumBig *b) {
rz_return_if_fail(c);
rz_return_if_fail(!rz_big_is_zero(b));
RNumBig *tmp = rz_big_new();
RzNumBig *tmp = rz_big_new();
rz_big_divmod(tmp, c, a, b);
rz_big_free(tmp);
}
RZ_API void rz_big_divmod(RNumBig *c, RNumBig *d, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_divmod(RzNumBig *c, RzNumBig *d, RzNumBig *a, RzNumBig *b) {
/*
Puts a%b in d
and a/b in c
@ -407,7 +407,7 @@ RZ_API void rz_big_divmod(RNumBig *c, RNumBig *d, RNumBig *a, RNumBig *b) {
rz_return_if_fail(c);
rz_return_if_fail(!rz_big_is_zero(b));
RNumBig *tmp = rz_big_new();
RzNumBig *tmp = rz_big_new();
/* c = (a / b) */
rz_big_div(c, a, b);
@ -421,7 +421,7 @@ RZ_API void rz_big_divmod(RNumBig *c, RNumBig *d, RNumBig *a, RNumBig *b) {
rz_big_free(tmp);
}
RZ_API void rz_big_and(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_and(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
rz_return_if_fail(a);
rz_return_if_fail(b);
rz_return_if_fail(c);
@ -434,7 +434,7 @@ RZ_API void rz_big_and(RNumBig *c, RNumBig *a, RNumBig *b) {
}
}
RZ_API void rz_big_or(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_or(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
rz_return_if_fail(a);
rz_return_if_fail(b);
rz_return_if_fail(c);
@ -447,7 +447,7 @@ RZ_API void rz_big_or(RNumBig *c, RNumBig *a, RNumBig *b) {
}
}
RZ_API void rz_big_xor(RNumBig *c, RNumBig *a, RNumBig *b) {
RZ_API void rz_big_xor(RzNumBig *c, RzNumBig *a, RzNumBig *b) {
rz_return_if_fail(a);
rz_return_if_fail(b);
rz_return_if_fail(c);
@ -460,7 +460,7 @@ RZ_API void rz_big_xor(RNumBig *c, RNumBig *a, RNumBig *b) {
}
}
RZ_API void rz_big_lshift(RNumBig *b, RNumBig *a, size_t nbits) {
RZ_API void rz_big_lshift(RzNumBig *b, RzNumBig *a, size_t nbits) {
rz_return_if_fail(a);
rz_return_if_fail(b);
rz_return_if_fail(a->sign > 0);
@ -484,7 +484,7 @@ RZ_API void rz_big_lshift(RNumBig *b, RNumBig *a, size_t nbits) {
}
}
RZ_API void rz_big_rshift(RNumBig *b, RNumBig *a, size_t nbits) {
RZ_API void rz_big_rshift(RzNumBig *b, RzNumBig *a, size_t nbits) {
rz_return_if_fail(a);
rz_return_if_fail(b);
rz_return_if_fail(a->sign > 0);
@ -508,7 +508,7 @@ RZ_API void rz_big_rshift(RNumBig *b, RNumBig *a, size_t nbits) {
}
}
RZ_API int rz_big_cmp(RNumBig *a, RNumBig *b) {
RZ_API int rz_big_cmp(RzNumBig *a, RzNumBig *b) {
rz_return_val_if_fail(a, 0);
rz_return_val_if_fail(b, 0);
@ -529,7 +529,7 @@ RZ_API int rz_big_cmp(RNumBig *a, RNumBig *b) {
return 0;
}
RZ_API int rz_big_is_zero(RNumBig *a) {
RZ_API int rz_big_is_zero(RzNumBig *a) {
rz_return_val_if_fail(a, -1);
int i;
@ -542,9 +542,9 @@ RZ_API int rz_big_is_zero(RNumBig *a) {
return 1;
}
RZ_API void rz_big_inc(RNumBig *a) {
RZ_API void rz_big_inc(RzNumBig *a) {
rz_return_if_fail(a);
RNumBig *tmp = rz_big_new();
RzNumBig *tmp = rz_big_new();
rz_big_from_int(tmp, 1);
rz_big_add(a, a, tmp);
@ -552,9 +552,9 @@ RZ_API void rz_big_inc(RNumBig *a) {
rz_big_free(tmp);
}
RZ_API void rz_big_dec(RNumBig *a) {
RZ_API void rz_big_dec(RzNumBig *a) {
rz_return_if_fail(a);
RNumBig *tmp = rz_big_new();
RzNumBig *tmp = rz_big_new();
rz_big_from_int(tmp, 1);
rz_big_sub(a, a, tmp);
@ -562,14 +562,14 @@ RZ_API void rz_big_dec(RNumBig *a) {
rz_big_free(tmp);
}
RZ_API void rz_big_powm(RNumBig *c, RNumBig *a, RNumBig *b, RNumBig *m) {
RZ_API void rz_big_powm(RzNumBig *c, RzNumBig *a, RzNumBig *b, RzNumBig *m) {
rz_return_if_fail(a);
rz_return_if_fail(b);
rz_return_if_fail(c);
rz_return_if_fail(m);
RNumBig *bcopy = rz_big_new();
RNumBig *acopy = rz_big_new();
RzNumBig *bcopy = rz_big_new();
RzNumBig *acopy = rz_big_new();
rz_big_assign(bcopy, b);
rz_big_assign(acopy, a);
@ -590,14 +590,14 @@ RZ_API void rz_big_powm(RNumBig *c, RNumBig *a, RNumBig *b, RNumBig *m) {
rz_big_free(acopy);
}
RZ_API void rz_big_isqrt(RNumBig *b, RNumBig *a) {
RZ_API void rz_big_isqrt(RzNumBig *b, RzNumBig *a) {
rz_return_if_fail(a);
rz_return_if_fail(b);
RNumBig *tmp = rz_big_new();
RNumBig *low = rz_big_new();
RNumBig *high = rz_big_new();
RNumBig *mid = rz_big_new();
RzNumBig *tmp = rz_big_new();
RzNumBig *low = rz_big_new();
RzNumBig *high = rz_big_new();
RzNumBig *mid = rz_big_new();
rz_big_assign(high, a);
rz_big_rshift(mid, high, 1);
@ -625,7 +625,7 @@ RZ_API void rz_big_isqrt(RNumBig *b, RNumBig *a) {
}
/* Private / Static functions. */
static void _rshift_word(RNumBig *a, int nwords) {
static void _rshift_word(RzNumBig *a, int nwords) {
/* Naive method: */
rz_return_if_fail(a);
rz_return_if_fail(nwords >= 0);
@ -646,7 +646,7 @@ static void _rshift_word(RNumBig *a, int nwords) {
}
}
static void _lshift_word(RNumBig *a, int nwords) {
static void _lshift_word(RzNumBig *a, int nwords) {
rz_return_if_fail(a);
rz_return_if_fail(nwords >= 0);
@ -661,7 +661,7 @@ static void _lshift_word(RNumBig *a, int nwords) {
}
}
static void _lshift_one_bit(RNumBig *a) {
static void _lshift_one_bit(RzNumBig *a) {
rz_return_if_fail(a);
int i;
@ -671,7 +671,7 @@ static void _lshift_one_bit(RNumBig *a) {
a->array[0] <<= 1;
}
static void _rshift_one_bit(RNumBig *a) {
static void _rshift_one_bit(RzNumBig *a) {
rz_return_if_fail(a);
int i;
@ -681,7 +681,7 @@ static void _rshift_one_bit(RNumBig *a) {
a->array[RZ_BIG_ARRAY_SIZE - 1] >>= 1;
}
static void _r_big_zero_out(RNumBig *a) {
static void _r_big_zero_out(RzNumBig *a) {
rz_return_if_fail(a);
size_t i;

98
librz/util/calc.c
View file

@ -17,95 +17,95 @@
#include <stdio.h>
/* accessors */
static inline RNumCalcValue Nset(ut64 v) {
RNumCalcValue n;
static inline RzNumCalcValue Nset(ut64 v) {
RzNumCalcValue n;
n.d = (double)v;
n.n = v;
return n;
}
static inline RNumCalcValue Nsetf(double v) {
RNumCalcValue n;
static inline RzNumCalcValue Nsetf(double v) {
RzNumCalcValue n;
n.d = v;
n.n = (ut64)v;
return n;
}
//UNUSED static inline RNumCalcValue Naddf(RNumCalcValue n, double v) { n.d += v; n.n += (ut64)v; return n; }
static inline RNumCalcValue Naddi(RNumCalcValue n, ut64 v) {
//UNUSED static inline RzNumCalcValue Naddf(RzNumCalcValue n, double v) { n.d += v; n.n += (ut64)v; return n; }
static inline RzNumCalcValue Naddi(RzNumCalcValue n, ut64 v) {
n.d += (double)v;
n.n += v;
return n;
}
static inline RNumCalcValue Nsubi(RNumCalcValue n, ut64 v) {
static inline RzNumCalcValue Nsubi(RzNumCalcValue n, ut64 v) {
n.d -= (double)v;
n.n -= v;
return n;
}
static inline RNumCalcValue Nneg(RNumCalcValue n) {
static inline RzNumCalcValue Nneg(RzNumCalcValue n) {
n.n = ~n.n;
return n;
}
static inline RNumCalcValue Norr(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Norr(RzNumCalcValue n, RzNumCalcValue v) {
n.d = v.d;
n.n |= v.n;
return n;
}
static inline RNumCalcValue Nxor(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nxor(RzNumCalcValue n, RzNumCalcValue v) {
n.d = v.d;
n.n ^= v.n;
return n;
}
static inline RNumCalcValue Nlt(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nlt(RzNumCalcValue n, RzNumCalcValue v) {
n.d = v.d;
n.n = n.n < v.n;
return n;
}
static inline RNumCalcValue Ngt(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Ngt(RzNumCalcValue n, RzNumCalcValue v) {
n.d = v.d;
n.n = n.n > v.n;
return n;
}
static inline RNumCalcValue Nand(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nand(RzNumCalcValue n, RzNumCalcValue v) {
n.d = v.d;
n.n &= v.n;
return n;
}
static inline RNumCalcValue Nadd(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nadd(RzNumCalcValue n, RzNumCalcValue v) {
n.d += v.d;
n.n += v.n;
return n;
}
static inline RNumCalcValue Nsub(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nsub(RzNumCalcValue n, RzNumCalcValue v) {
n.d -= v.d;
n.n -= v.n;
return n;
}
static inline RNumCalcValue Nmul(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nmul(RzNumCalcValue n, RzNumCalcValue v) {
n.d *= v.d;
n.n *= v.n;
return n;
}
static inline RNumCalcValue Nshl(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nshl(RzNumCalcValue n, RzNumCalcValue v) {
n.d += v.d;
n.n <<= v.n;
return n;
}
static inline RNumCalcValue Nshr(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nshr(RzNumCalcValue n, RzNumCalcValue v) {
n.d += v.d;
n.n >>= v.n;
return n;
}
static inline RNumCalcValue Nrol(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nrol(RzNumCalcValue n, RzNumCalcValue v) {
n.d += v.d;
n.n = (n.n << v.n) | (n.n >> (sizeof(n.n) * 8 - v.n));
return n;
}
static inline RNumCalcValue Nror(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nror(RzNumCalcValue n, RzNumCalcValue v) {
n.d += v.d;
n.n = (n.n >> v.n) | (n.n << (sizeof(n.n) * 8 - v.n));
return n;
}
static inline RNumCalcValue Nmod(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Nmod(RzNumCalcValue n, RzNumCalcValue v) {
if (v.d) {
n.d = (n.d - (n.d / v.d));
} else {
@ -119,7 +119,7 @@ static inline RNumCalcValue Nmod(RNumCalcValue n, RNumCalcValue v) {
return n;
}
static inline RNumCalcValue Ndiv(RNumCalcValue n, RNumCalcValue v) {
static inline RzNumCalcValue Ndiv(RzNumCalcValue n, RzNumCalcValue v) {
if (v.d) {
n.d /= v.d;
} else {
@ -133,20 +133,20 @@ static inline RNumCalcValue Ndiv(RNumCalcValue n, RNumCalcValue v) {
return n;
}
static RNumCalcValue expr(RNum *, RNumCalc *, int);
static RNumCalcValue term(RNum *, RNumCalc *, int);
static void error(RNum *, RNumCalc *, const char *);
static RNumCalcValue prim(RNum *, RNumCalc *, int);
static RNumCalcToken get_token(RNum *, RNumCalc *);
static RzNumCalcValue expr(RzNum *, RzNumCalc *, int);
static RzNumCalcValue term(RzNum *, RzNumCalc *, int);
static void error(RzNum *, RzNumCalc *, const char *);
static RzNumCalcValue prim(RzNum *, RzNumCalc *, int);
static RzNumCalcToken get_token(RzNum *, RzNumCalc *);
static void error(RNum *num, RNumCalc *nc, const char *s) {
static void error(RzNum *num, RzNumCalc *nc, const char *s) {
nc->errors++;
nc->calc_err = s;
//fprintf (stderr, "error: %s\n", s);
}
static RNumCalcValue expr(RNum *num, RNumCalc *nc, int get) {
RNumCalcValue left = term(num, nc, get);
static RzNumCalcValue expr(RzNum *num, RzNumCalc *nc, int get) {
RzNumCalcValue left = term(num, nc, get);
for (;;) {
switch (nc->curr_tok) {
case RNCSHL: left = Nshl(left, term(num, nc, 1)); break;
@ -167,20 +167,20 @@ static RNumCalcValue expr(RNum *num, RNumCalc *nc, int get) {
return left;
}
static RNumCalcValue term(RNum *num, RNumCalc *nc, int get) {
RNumCalcValue left = prim(num, nc, get);
static RzNumCalcValue term(RzNum *num, RzNumCalc *nc, int get) {
RzNumCalcValue left = prim(num, nc, get);
for (;;) {
if (nc->curr_tok == RNCMUL) {
left = Nmul(left, prim(num, nc, 1));
} else if (nc->curr_tok == RNCMOD) {
RNumCalcValue d = prim(num, nc, 1);
RzNumCalcValue d = prim(num, nc, 1);
if (!d.d) {
//error (num, nc, "divide by 0");
return d;
}
left = Nmod(left, d);
} else if (nc->curr_tok == RNCDIV) {
RNumCalcValue d = prim(num, nc, 1);
RzNumCalcValue d = prim(num, nc, 1);
if (num != NULL && (!d.d || !d.n)) {
num->dbz = 1;
return d;
@ -192,8 +192,8 @@ static RNumCalcValue term(RNum *num, RNumCalc *nc, int get) {
}
}
static RNumCalcValue prim(RNum *num, RNumCalc *nc, int get) {
RNumCalcValue v = { 0 };
static RzNumCalcValue prim(RzNum *num, RzNumCalc *nc, int get) {
RzNumCalcValue v = { 0 };
if (get) {
get_token(num, nc);
}
@ -258,11 +258,11 @@ static RNumCalcValue prim(RNum *num, RNumCalc *nc, int get) {
return v;
}
static void cin_putback(RNum *num, RNumCalc *nc, char c) {
static void cin_putback(RzNum *num, RzNumCalc *nc, char c) {
nc->oc = c;
}
RZ_API const char *rz_num_calc_index(RNum *num, const char *p) {
RZ_API const char *rz_num_calc_index(RzNum *num, const char *p) {
if (!num) {
return NULL;
}
@ -274,7 +274,7 @@ RZ_API const char *rz_num_calc_index(RNum *num, const char *p) {
return num->nc.calc_buf + num->nc.calc_i;
}
static int cin_get(RNum *num, RNumCalc *nc, char *c) {
static int cin_get(RzNum *num, RzNumCalc *nc, char *c) {
if (nc->oc) {
*c = nc->oc;
nc->oc = 0;
@ -292,7 +292,7 @@ static int cin_get(RNum *num, RNumCalc *nc, char *c) {
return 1;
}
static int cin_get_num(RNum *num, RNumCalc *nc, RNumCalcValue *n) {
static int cin_get_num(RzNum *num, RzNumCalc *nc, RzNumCalcValue *n) {
double d;
char str[RZ_NUMCALC_STRSZ + 1]; // TODO: move into the heap?
int i = 0;
@ -321,7 +321,7 @@ static int cin_get_num(RNum *num, RNumCalc *nc, RNumCalcValue *n) {
return 1;
}
static RNumCalcToken get_token(RNum *num, RNumCalc *nc) {
static RzNumCalcToken get_token(RzNum *num, RzNumCalc *nc) {
char ch = 0, c = 0;
do {
@ -340,21 +340,21 @@ static RNumCalcToken get_token(RNum *num, RNumCalc *nc) {
return nc->curr_tok = RNCINC;
}
cin_putback(num, nc, c);
return nc->curr_tok = (RNumCalcToken)ch;
return nc->curr_tok = (RzNumCalcToken)ch;
// negate hack
case '~':
if (cin_get(num, nc, &c) && c == '-') {
return nc->curr_tok = RNCNEG;
}
cin_putback(num, nc, c);
return nc->curr_tok = (RNumCalcToken)ch;
return nc->curr_tok = (RzNumCalcToken)ch;
// negative number
case '-':
if (cin_get(num, nc, &c) && c == '-') {
return nc->curr_tok = RNCDEC;
}
cin_putback(num, nc, c);
return nc->curr_tok = (RNumCalcToken)ch;
return nc->curr_tok = (RzNumCalcToken)ch;
case '<':
if (cin_get(num, nc, &c) && c == '<') { // "<<" = shift left
if (cin_get(num, nc, &c) && c == '<') { // "<<<" = rotate left
@ -384,7 +384,7 @@ static RNumCalcToken get_token(RNum *num, RNumCalc *nc) {
case '(':
case ')':
case '=':
return nc->curr_tok = (RNumCalcToken)ch;
return nc->curr_tok = (RzNumCalcToken)ch;
case '0':
case '1':
case '2':
@ -444,16 +444,16 @@ static RNumCalcToken get_token(RNum *num, RNumCalc *nc) {
}
}
static void load_token(RNum *num, RNumCalc *nc, const char *s) {
static void load_token(RzNum *num, RzNumCalc *nc, const char *s) {
nc->calc_i = 0;
nc->calc_len = strlen(s);
nc->calc_buf = s;
nc->calc_err = NULL;
}
RZ_API ut64 rz_num_calc(RNum *num, const char *str, const char **err) {
RNumCalcValue n;
RNumCalc *nc, nc_local;
RZ_API ut64 rz_num_calc(RzNum *num, const char *str, const char **err) {
RzNumCalcValue n;
RzNumCalc *nc, nc_local;
if (!str || !*str) {
return 0LL;
}

46
librz/util/unum.c
View file

@ -10,7 +10,7 @@
#include <rz_util.h>
#define RZ_NUM_USE_CALC 1
static ut64 rz_num_tailff(RNum *num, const char *hex);
static ut64 rz_num_tailff(RzNum *num, const char *hex);
// TODO: rename to rz_num_srand()
static void rz_srand(int seed) {
@ -62,8 +62,8 @@ RZ_API void rz_num_minmax_swap_i(int *a, int *b) {
}
}
RZ_API RNum *rz_num_new(RNumCallback cb, RNumCallback2 cb2, void *ptr) {
RNum *num = RZ_NEW0(RNum);
RZ_API RzNum *rz_num_new(RzNumCallback cb, RzNumCallback2 cb2, void *ptr) {
RzNum *num = RZ_NEW0(RzNum);
if (!num) {
return NULL;
}
@ -74,7 +74,7 @@ RZ_API RNum *rz_num_new(RNumCallback cb, RNumCallback2 cb2, void *ptr) {
return num;
}
RZ_API void rz_num_free(RNum *num) {
RZ_API void rz_num_free(RzNum *num) {
free(num);
}
@ -134,7 +134,7 @@ RZ_API char *rz_num_units(char *buf, size_t len, ut64 num) {
return buf;
}
RZ_API const char *rz_num_get_name(RNum *num, ut64 n) {
RZ_API const char *rz_num_get_name(RzNum *num, ut64 n) {
if (num->cb_from_value) {
int ok = 0;
const char *msg = num->cb_from_value(num, n, &ok);
@ -148,7 +148,7 @@ RZ_API const char *rz_num_get_name(RNum *num, ut64 n) {
return NULL;
}
static void error(RNum *num, const char *err_str) {
static void error(RzNum *num, const char *err_str) {
if (num) {
num->nc.errors++;
#if 0
@ -159,7 +159,7 @@ static void error(RNum *num, const char *err_str) {
// TODO: try to avoid the use of sscanf
/* old get_offset */
RZ_API ut64 rz_num_get(RNum *num, const char *str) {
RZ_API ut64 rz_num_get(RzNum *num, const char *str) {
int i, j, ok;
char lch, len;
ut64 ret = 0LL;
@ -404,7 +404,7 @@ RZ_API ut64 rz_num_get(RNum *num, const char *str) {
}
#if !RZ_NUM_USE_CALC
static ut64 rz_num_op(RNum *num, char op, ut64 a, ut64 b) {
static ut64 rz_num_op(RzNum *num, char op, ut64 a, ut64 b) {
switch (op) {
case '+': return a + b;
case '-': return a - b;
@ -420,7 +420,7 @@ static ut64 rz_num_op(RNum *num, char op, ut64 a, ut64 b) {
return b;
}
RZ_API static ut64 rz_num_math_internal(RNum *num, char *s) {
RZ_API static ut64 rz_num_math_internal(RzNum *num, char *s) {
ut64 ret = 0LL;
char *p = s;
int i, nop, op = 0;
@ -438,7 +438,7 @@ RZ_API static ut64 rz_num_math_internal(RNum *num, char *s) {
}
#endif /* !RZ_NUM_USE_CALC */
RZ_API ut64 rz_num_math(RNum *num, const char *str) {
RZ_API ut64 rz_num_math(RzNum *num, const char *str) {
#if RZ_NUM_USE_CALC
ut64 ret;
const char *err = NULL;
@ -514,11 +514,11 @@ RZ_API ut64 rz_num_math(RNum *num, const char *str) {
#endif
}
RZ_API int rz_num_is_float(RNum *num, const char *str) {
RZ_API int rz_num_is_float(RzNum *num, const char *str) {
return (IS_DIGIT(*str) && (strchr(str, '.') || str[strlen(str) - 1] == 'f'));
}
RZ_API double rz_num_get_float(RNum *num, const char *str) {
RZ_API double rz_num_get_float(RzNum *num, const char *str) {
double d = 0.0f;
(void)sscanf(str, "%lf", &d);
return d;
@ -585,7 +585,7 @@ RZ_API ut64 rz_num_chs(int cylinder, int head, int sector, int sectorsize) {
return (ut64)cylinder * (ut64)head * (ut64)sector * (ut64)sectorsize;
}
RZ_API int rz_num_conditional(RNum *num, const char *str) {
RZ_API int rz_num_conditional(RzNum *num, const char *str) {
char *lgt, *t, *p, *s = strdup(str);
int res = 0;
ut64 n, a, b;
@ -658,12 +658,12 @@ fail:
return res;
}
RZ_API int rz_num_is_valid_input(RNum *num, const char *input_value) {
RZ_API int rz_num_is_valid_input(RzNum *num, const char *input_value) {
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 != '@');
}
RZ_API ut64 rz_num_get_input_value(RNum *num, const char *input_value) {
RZ_API ut64 rz_num_get_input_value(RzNum *num, const char *input_value) {
ut64 value = input_value ? rz_num_math(num, input_value) : 0;
return value;
}
@ -687,7 +687,7 @@ static int escape_char(char *dst, char byte) {
return 0;
}
RZ_API char *rz_num_as_string(RNum *___, ut64 n, bool printable_only) {
RZ_API char *rz_num_as_string(RzNum *___, ut64 n, bool printable_only) {
char str[34]; // 8 byte * 4 chars in \x?? format
int stri, ret = 0, off = 0;
int len = sizeof(ut64);
@ -717,7 +717,7 @@ RZ_API char *rz_num_as_string(RNum *___, ut64 n, bool printable_only) {
return NULL;
}
RZ_API bool rz_is_valid_input_num_value(RNum *num, const char *input_value) {
RZ_API bool rz_is_valid_input_num_value(RzNum *num, const char *input_value) {
if (!input_value) {
return false;
}
@ -725,7 +725,7 @@ RZ_API bool rz_is_valid_input_num_value(RNum *num, const char *input_value) {
return !(value == 0 && *input_value != '0');
}
RZ_API ut64 rz_get_input_num_value(RNum *num, const char *str) {
RZ_API ut64 rz_get_input_num_value(RzNum *num, const char *str) {
return (str && *str) ? rz_num_math(num, str) : 0;
}
@ -735,7 +735,7 @@ static inline ut64 __nth_nibble(ut64 n, ut32 i) {
return (n >> s) & 0xf;
}
RZ_API ut64 rz_num_tail_base(RNum *num, ut64 addr, ut64 off) {
RZ_API ut64 rz_num_tail_base(RzNum *num, ut64 addr, ut64 off) {
int i;
bool ready = false;
ut64 res = 0;
@ -757,7 +757,7 @@ RZ_API ut64 rz_num_tail_base(RNum *num, ut64 addr, ut64 off) {
return res;
}
RZ_API ut64 rz_num_tail(RNum *num, ut64 addr, const char *hex) {
RZ_API ut64 rz_num_tail(RzNum *num, ut64 addr, const char *hex) {
ut64 mask = 0LL;
ut64 n = 0;
char *p;
@ -784,7 +784,7 @@ RZ_API ut64 rz_num_tail(RNum *num, ut64 addr, const char *hex) {
return (addr & mask) | n;
}
static ut64 rz_num_tailff(RNum *num, const char *hex) {
static ut64 rz_num_tailff(RzNum *num, const char *hex) {
ut64 n = 0;
while (*hex && (*hex == ' ' || *hex == '.')) {
@ -808,7 +808,7 @@ static ut64 rz_num_tailff(RNum *num, const char *hex) {
return left | n;
}
RZ_API int rz_num_between(RNum *num, const char *input_value) {
RZ_API int rz_num_between(RzNum *num, const char *input_value) {
int i;
ut64 ns[3];
char *const str = strdup(input_value);
@ -917,7 +917,7 @@ RZ_API double rz_num_sin(double a) {
/**
* \brief Convert the base suffix to the numeric value
*/
RZ_API size_t rz_num_base_of_string(RNum *num, RZ_NONNULL const char *str) {
RZ_API size_t rz_num_base_of_string(RzNum *num, RZ_NONNULL const char *str) {
rz_return_val_if_fail(num && str, 10);
size_t base = 10;
if (rz_str_startswith(str, "10u") || rz_str_startswith(str, "du")) {

2
test/unit/legacy_unit/util/big.c
View file

@ -6,7 +6,7 @@
void main() {
int a, b;
RNumBig n1, n2, n3, zero;
RzNumBig n1, n2, n3, zero;
rz_big_set_st(&n2, -2);
rz_big_set_str(&n3, "-3");

94
test/unit/test_big.c
View file

@ -5,7 +5,7 @@
#include "minunit.h"
static bool test_rz_big_from_to_int(void) {
RNumBig *a = rz_big_new();
RzNumBig *a = rz_big_new();
mu_assert_eq(0, rz_big_to_int(a), "Failed rz_big_to_int");
@ -20,7 +20,7 @@ static bool test_rz_big_from_to_int(void) {
}
static bool test_rz_big_from_to_hexstr(void) {
RNumBig *a = rz_big_new();
RzNumBig *a = rz_big_new();
char *str;
rz_big_from_hexstr(a, "0xffff");
@ -40,8 +40,8 @@ static bool test_rz_big_from_to_hexstr(void) {
}
static bool test_rz_big_assign(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
rz_big_from_int(a, 0xffff);
rz_big_assign(b, a);
@ -57,8 +57,8 @@ static bool test_rz_big_assign(void) {
}
static bool test_rz_big_cmp(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
rz_big_from_int(b, 0);
rz_big_from_int(a, 1);
@ -97,9 +97,9 @@ static bool test_rz_big_cmp(void) {
}
static bool test_rz_big_add(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_int(a, 1);
rz_big_from_int(b, -1);
@ -134,9 +134,9 @@ static bool test_rz_big_add(void) {
}
static bool test_rz_big_sub(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_int(a, 1);
rz_big_from_int(b, 1);
@ -190,9 +190,9 @@ static bool test_rz_big_sub(void) {
}
static bool test_rz_big_mul(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_int(a, 2);
rz_big_from_int(b, -2);
@ -252,9 +252,9 @@ static bool test_rz_big_mul(void) {
}
static bool test_rz_big_div(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_int(a, 2);
rz_big_from_int(b, -2);
@ -296,10 +296,10 @@ static bool test_rz_big_div(void) {
}
static bool test_rz_big_divmod(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RNumBig *c = rz_big_new();
RNumBig *d = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
RzNumBig *c = rz_big_new();
RzNumBig *d = rz_big_new();
rz_big_from_hexstr(a, "0x73204217f728a2fb7dc798618f23c5796675eee1ccd60a3a7be9cddf7d0eb30e9b004b0246051fcbc26ce99b67e23f07d3f2a493b1194af2777ffdfd5d66c61ba4fa2cd14536010ee00e695863039829c315c594c84170559822fcceb20afdc56a81ab7105e17efb0afd8f090bce2e5330e1c78e2e3ab26a1f49610b49b0fafa75b342b5c1a79322be4a92fac102958ed43aee787c221ea5c23e9485321c6b901cdb5c584bebcbea644a8f2c40bfbaf2dee40102e660e37d41b1f2ccee933a57693ee8ee2473bec98911ccd4b853704c7ed73b86da962845efe5399561fb3b0c37f5f0e730ddebcea7144351064f1ee04c1348125807a760186ac33316633d09");
rz_big_from_hexstr(b, "0x10001");
@ -316,9 +316,9 @@ static bool test_rz_big_divmod(void) {
}
static bool test_rz_big_mod(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_hexstr(a, "0x73204217f728a2fb7dc798618f23c5796675eee1ccd60a3a7be9cddf7d0eb30e9b004b0246051fcbc26ce99b67e23f07d3f2a493b1194af2777ffdfd5d66c61ba4fa2cd14536010ee00e695863039829c315c594c84170559822fcceb20afdc56a81ab7105e17efb0afd8f090bce2e5330e1c78e2e3ab26a1f49610b49b0fafa75b342b5c1a79322be4a92fac102958ed43aee787c221ea5c23e9485321c6b901cdb5c584bebcbea644a8f2c40bfbaf2dee40102e660e37d41b1f2ccee933a57693ee8ee2473bec98911ccd4b853704c7ed73b86da962845efe5399561fb3b0c37f5f0e730ddebcea7144351064f1ee04c1348125807a760186ac33316633d09");
rz_big_from_hexstr(b, "0x10001");
@ -332,9 +332,9 @@ static bool test_rz_big_mod(void) {
}
static bool test_rz_big_and(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_hexstr(a, "0x73204217f728a2fb7dc798618f23c5796675eee1ccd60a3a7be9cddf7d0eb30e9b004b0246051fcbc26ce99b67e23f07d3f2a493b1194af2777ffdfd5d66c61ba4fa2cd14536010ee00e695863039829c315c594c84170559822fcceb20afdc56a81ab7105e17efb0afd8f090bce2e5330e1c78e2e3ab26a1f49610b49b0fafa75b342b5c1a79322be4a92fac102958ed43aee787c221ea5c23e9485321c6b901cdb5c584bebcbea644a8f2c40bfbaf2dee40102e660e37d41b1f2ccee933a57693ee8ee2473bec98911ccd4b853704c7ed73b86da962845efe5399561fb3b0c37f5f0e730ddebcea7144351064f1ee04c1348125807a760186ac33316633d09");
rz_big_from_hexstr(b, "0x8a1712798b2575df7ae8419ad4b43e0df66c4d2af6a327fc78ffe78b9a15dc2b9630167bfc6ca4f7958ba5073a31c0e06da3d7d0db3fac9a33546f3a62a3a2d20992da45141ed267e91e86308ab14ec027580eaa29719592b9e3a354f2135d87cebf6bfe9acf3b85deb9bb098804ce681a979b68a84594b08dd699afc7511f6790e61365f7de17df954b9a865ec840eca9cabf849b5df4d14adb31eabfb27b8f6144f18907026d41a61b59f72a5f689f8aeca79d0e5272cd2f7ba12620826fa36e3eb8d0b2c90dd76a7dda85dfd3ccad1193f50354e6e74fdbc62c1a765fe6515b2142ad1e16d9b0c914d7e345b2b40ef91f7f10b60806a850c1bccafdd080ac");
@ -349,9 +349,9 @@ static bool test_rz_big_and(void) {
}
static bool test_rz_big_or(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_hexstr(a, "0x73204217f728a2fb7dc798618f23c5796675eee1ccd60a3a7be9cddf7d0eb30e9b004b0246051fcbc26ce99b67e23f07d3f2a493b1194af2777ffdfd5d66c61ba4fa2cd14536010ee00e695863039829c315c594c84170559822fcceb20afdc56a81ab7105e17efb0afd8f090bce2e5330e1c78e2e3ab26a1f49610b49b0fafa75b342b5c1a79322be4a92fac102958ed43aee787c221ea5c23e9485321c6b901cdb5c584bebcbea644a8f2c40bfbaf2dee40102e660e37d41b1f2ccee933a57693ee8ee2473bec98911ccd4b853704c7ed73b86da962845efe5399561fb3b0c37f5f0e730ddebcea7144351064f1ee04c1348125807a760186ac33316633d09");
rz_big_from_hexstr(b, "0x8a1712798b2575df7ae8419ad4b43e0df66c4d2af6a327fc78ffe78b9a15dc2b9630167bfc6ca4f7958ba5073a31c0e06da3d7d0db3fac9a33546f3a62a3a2d20992da45141ed267e91e86308ab14ec027580eaa29719592b9e3a354f2135d87cebf6bfe9acf3b85deb9bb098804ce681a979b68a84594b08dd699afc7511f6790e61365f7de17df954b9a865ec840eca9cabf849b5df4d14adb31eabfb27b8f6144f18907026d41a61b59f72a5f689f8aeca79d0e5272cd2f7ba12620826fa36e3eb8d0b2c90dd76a7dda85dfd3ccad1193f50354e6e74fdbc62c1a765fe6515b2142ad1e16d9b0c914d7e345b2b40ef91f7f10b60806a850c1bccafdd080ac");
@ -366,9 +366,9 @@ static bool test_rz_big_or(void) {
}
static bool test_rz_big_xor(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_hexstr(a, "0x73204217f728a2fb7dc798618f23c5796675eee1ccd60a3a7be9cddf7d0eb30e9b004b0246051fcbc26ce99b67e23f07d3f2a493b1194af2777ffdfd5d66c61ba4fa2cd14536010ee00e695863039829c315c594c84170559822fcceb20afdc56a81ab7105e17efb0afd8f090bce2e5330e1c78e2e3ab26a1f49610b49b0fafa75b342b5c1a79322be4a92fac102958ed43aee787c221ea5c23e9485321c6b901cdb5c584bebcbea644a8f2c40bfbaf2dee40102e660e37d41b1f2ccee933a57693ee8ee2473bec98911ccd4b853704c7ed73b86da962845efe5399561fb3b0c37f5f0e730ddebcea7144351064f1ee04c1348125807a760186ac33316633d09");
rz_big_from_hexstr(b, "0x8a1712798b2575df7ae8419ad4b43e0df66c4d2af6a327fc78ffe78b9a15dc2b9630167bfc6ca4f7958ba5073a31c0e06da3d7d0db3fac9a33546f3a62a3a2d20992da45141ed267e91e86308ab14ec027580eaa29719592b9e3a354f2135d87cebf6bfe9acf3b85deb9bb098804ce681a979b68a84594b08dd699afc7511f6790e61365f7de17df954b9a865ec840eca9cabf849b5df4d14adb31eabfb27b8f6144f18907026d41a61b59f72a5f689f8aeca79d0e5272cd2f7ba12620826fa36e3eb8d0b2c90dd76a7dda85dfd3ccad1193f50354e6e74fdbc62c1a765fe6515b2142ad1e16d9b0c914d7e345b2b40ef91f7f10b60806a850c1bccafdd080ac");
@ -383,7 +383,7 @@ static bool test_rz_big_xor(void) {
}
static bool test_rz_big_inc(void) {
RNumBig *a = rz_big_new();
RzNumBig *a = rz_big_new();
rz_big_from_int(a, -1);
rz_big_inc(a);
@ -396,7 +396,7 @@ static bool test_rz_big_inc(void) {
}
static bool test_rz_big_dec(void) {
RNumBig *a = rz_big_new();
RzNumBig *a = rz_big_new();
rz_big_from_int(a, 1);
rz_big_dec(a);
@ -409,7 +409,7 @@ static bool test_rz_big_dec(void) {
}
static bool test_rz_big_is_zero(void) {
RNumBig *a = rz_big_new();
RzNumBig *a = rz_big_new();
rz_big_from_int(a, 1);
rz_big_dec(a);
@ -422,8 +422,8 @@ static bool test_rz_big_is_zero(void) {
}
static bool test_rz_big_lshift(void) {
RNumBig *a = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_hexstr(a, "0x73204217f728a2fb7dc798618f23c5796675eee1ccd60a3a7be9cddf7d0eb30e9b004b0246051fcbc26ce99b67e23f07d3f2a493b1194af2777ffdfd5d66c61ba4fa2cd14536010ee00e695863039829c315c594c84170559822fcceb20afdc56a81ab7105e17efb0afd8f090bce2e5330e1c78e2e3ab26a1f49610b49b0fafa75b342b5c1a79322be4a92fac102958ed43aee787c221ea5c23e9485321c6b901cdb5c584bebcbea644a8f2c40bfbaf2dee40102e660e37d41b1f2ccee933a57693ee8ee2473bec98911ccd4b853704c7ed73b86da962845efe5399561fb3b0c37f5f0e730ddebcea7144351064f1ee04c1348125807a760186ac33316633d09");
rz_big_lshift(c, a, 1023);
@ -436,8 +436,8 @@ static bool test_rz_big_lshift(void) {
}
static bool test_rz_big_rshift(void) {
RNumBig *a = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_hexstr(a, "0x73204217f728a2fb7dc798618f23c5796675eee1ccd60a3a7be9cddf7d0eb30e9b004b0246051fcbc26ce99b67e23f07d3f2a493b1194af2777ffdfd5d66c61ba4fa2cd14536010ee00e695863039829c315c594c84170559822fcceb20afdc56a81ab7105e17efb0afd8f090bce2e5330e1c78e2e3ab26a1f49610b49b0fafa75b342b5c1a79322be4a92fac102958ed43aee787c221ea5c23e9485321c6b901cdb5c584bebcbea644a8f2c40bfbaf2dee40102e660e37d41b1f2ccee933a57693ee8ee2473bec98911ccd4b853704c7ed73b86da962845efe5399561fb3b0c37f5f0e730ddebcea7144351064f1ee04c1348125807a760186ac33316633d09");
rz_big_rshift(c, a, 1023);
@ -450,10 +450,10 @@ static bool test_rz_big_rshift(void) {
}
static bool test_rz_big_powm(void) {
RNumBig *a = rz_big_new();
RNumBig *b = rz_big_new();
RNumBig *c = rz_big_new();
RNumBig *m = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *b = rz_big_new();
RzNumBig *c = rz_big_new();
RzNumBig *m = rz_big_new();
rz_big_from_int(a, 3);
rz_big_from_int(b, 4);
@ -469,8 +469,8 @@ static bool test_rz_big_powm(void) {
}
static bool test_rz_big_isqrt(void) {
RNumBig *a = rz_big_new();
RNumBig *c = rz_big_new();
RzNumBig *a = rz_big_new();
RzNumBig *c = rz_big_new();
rz_big_from_int(a, 4);
rz_big_isqrt(c, a);

2
test/unit/test_unum.c
View file

@ -4,7 +4,7 @@
#include <rz_util.h>
#include "minunit.h"
static RNum *num;
static RzNum *num;
bool test_rz_num_units() {
char humansz[8];