// afvn local_48 counter
R_API int r_anal_var_rename (RAnal *a, ut64 var_addr, int scope, char kind, const char *old_name, const char *new_name) {
char key[128];
char *stored_name;
int delta;
if (!r_anal_var_check_name (new_name))
return 0;
if (scope>0) { // local
SETKEY ("var.0x%"PFMT64x".%c.%d.%s", var_addr, kind, scope, old_name);
delta = sdb_num_get (DB, key, 0);
if (!delta) return 0;
sdb_unset (DB, key, 0);
SETKEY ("var.0x%"PFMT64x".%c.%d.%s", var_addr, kind, scope, new_name);
sdb_num_set (DB, key, delta, 0);
SETKEY ("var.0x%"PFMT64x".%c.%d.%d", var_addr, kind, scope, delta);
sdb_array_set (DB, key, R_ANAL_VAR_SDB_NAME, new_name, 0);
} else { // global
SETKEY ("var.0x%"PFMT64x, var_addr);
stored_name = sdb_array_get (DB, key, R_ANAL_VAR_SDB_NAME, 0);
if (!stored_name) return 0;
if (stored_name != old_name) return 0;
sdb_unset (DB, key, 0);
SETKEY ("var.0x%"PFMT64x, var_addr);
sdb_array_set (DB, key, R_ANAL_VAR_SDB_NAME, new_name, 0);
}
// var.sdb_hash(old_name)=var_addr.scope.delta
return 1;
}
// avr 1,4 counter @ var_addr
R_API int r_anal_var_rename (RAnal *a, ut64 var_addr, int scope, int delta, const char *new_name) {
ut32 hash;
char key[128], *old_name;
if (!r_anal_var_check_name (new_name))
return 0;
if (scope>0) { // local
SETKEY ("var.0x%"PFMT64x".%d.%d", var_addr, scope, delta);
old_name = sdb_array_get (DB, key, R_ANAL_VAR_SDB_NAME, 0);
if (!old_name) return 0;
SETKEY ("var.%s.%d", old_name, scope);
sdb_unset (DB, key, 0);
free (old_name);
SETKEY ("var.%s.%d", new_name, scope);
sdb_num_set (DB, key, var_addr, 0);
SETKEY ("var.0x%x.%d.%d", hash, scope, delta);
sdb_array_set (DB, key, R_ANAL_VAR_SDB_NAME, new_name, 0);
} else { // global
SETKEY ("var.0x%"PFMT64x, var_addr);
old_name = sdb_array_get (DB, key, R_ANAL_VAR_SDB_NAME, 0);
if (!old_name) return 0;
SETKEY ("var.%s", old_name);
sdb_unset (DB, key, 0);
free (old_name);
SETKEY ("var.%s.%d", new_name, scope);
sdb_num_set (DB, key, var_addr, 0);
SETKEY ("var.0x%x.%d.%d", hash, scope, delta);
sdb_array_set (DB, key, R_ANAL_VAR_SDB_NAME, new_name, 0);
}
// var.sdb_hash(old_name)=var_addr.scope.delta
return 1;
}
R_API int r_anal_fcn_label_del (RAnal *anal, RAnalFunction *fcn, const char *name, ut64 addr) {
if (!anal || !fcn || !name)
return R_FALSE;
sdb_array_remove (DB, LABELS, ADDRLABEL (addr, name), 0);
sdb_unset (DB, LABEL(name), 0);
sdb_unset (DB, ADDR(addr), 0);
return R_TRUE;
}
R_API void r_anal_var_access_clear (RAnal *a, ut64 var_addr, int scope, int delta) {
char key[128], key2[128];
if (scope>0) { // local arg or var
SETKEY ("var.0x%"PFMT64x".%d.%d.%s", var_addr, scope, delta, "writes");
SETKEY2 ("var.0x%"PFMT64x".%d.%d.%s", var_addr, scope, delta, "reads");
} else { // global
SETKEY ("var.0x%"PFMT64x".%s", var_addr, "writes");
SETKEY2 ("var.0x%"PFMT64x".%s", var_addr, "reads");
}
sdb_unset (DB, key, 0);
sdb_unset (DB, key2, 0);
}
R_API int r_meta_del(RAnal *a, int type, ut64 addr, ut64 size, const char *str) {
char key[100], *dtr, *s, *p, *next;
#if 0
char key2[100];
#endif
const char *ptr;
int i;
if (size == UT64_MAX) {
// FULL CLEANUP
// XXX: this thing ignores the type
if (type == R_META_TYPE_ANY) {
sdb_reset (DB);
} else {
snprintf (key, sizeof (key)-1, "meta.%c.count", type);
int last = (ut64)sdb_num_get (DB, key, NULL)/K;
for (i=0; i<last; i++) {
snprintf (key, sizeof (key)-1, "meta.%c.%d", type, i);
dtr = sdb_get (DB, key, 0);
for (p = dtr; p; p = next) {
s = sdb_anext (p, &next);
snprintf (key, sizeof (key)-1,
"meta.%c.0x%"PFMT64x,
type, sdb_atoi (s));
eprintf ("--> %s\n", key);
sdb_unset (DB, key, 0);
if (!next) break;
}
free (dtr);
}
}
return false;
}
meta_inrange_del (a, addr, size);
snprintf (key, sizeof (key)-1, type == R_META_TYPE_COMMENT ?
"meta.C.0x%"PFMT64x : "meta.0x%"PFMT64x, addr);
ptr = sdb_const_get (DB, key, 0);
if (ptr) {
sdb_unset (DB, key, 0);
#if 0
// This code is wrong, but i guess it's necessary in case type is ANY
for (i=0; ptr[i]; i++) {
if (ptr[i] != SDB_RS) {
snprintf (key2, sizeof (key2)-1,
"meta.%c.0x%"PFMT64x, ptr[i], addr);
printf ("UNSET (%s)\n", key2);
sdb_unset (DB, key2, 0);
}
}
#endif
}
sdb_unset (DB, key, 0);
return false;
}
SDB_API char *sdb_array_pop(Sdb *s, const char *key, ut32 *cas) {
ut32 kas;
char *end, *str = sdb_get (s, key, &kas);
if (!str || !*str) {
free (str);
return NULL;
}
if (cas && *cas != kas)
*cas = kas;
#if PUSH_PREPENDS
end = strchr (str, SDB_RS);
if (end) {
*end = 0;
sdb_set (s, key, end+1, 0);
} else {
sdb_unset (s, key, 0);
}
return str;
#else
for (end = str+strlen (str)-1;
end>str && *end!=SDB_RS; end--);
if (*end==SDB_RS) *end++ = 0;
sdb_set_owned (s, key, str, 0);
// XXX: probably wrong
return strdup (end);
#endif
}
static int remove_meta_fileline(RCore *core, const char *file_line) {
int ret;
ret = sdb_unset (core->bin->cur->sdb_addrinfo, file_line, 0);
return ret;
}
static int remove_meta_offset(RCore *core, ut64 offset) {
char aoffset[64];
char *aoffsetptr = sdb_itoa (offset, aoffset, 16);
if (!aoffsetptr) {
eprintf ("Failed to convert %"PFMT64x" to a key", offset);
return -1;
}
return sdb_unset (core->bin->cur->sdb_addrinfo, aoffsetptr, 0);
}
R_API void r_anal_hint_del (RAnal *a, ut64 addr, int size) {
char key[128];
if (size>1) {
eprintf ("TODO: r_anal_hint_del: in range\n");
} else {
setf (key, "hint.0x%08"PFMT64x, addr);
sdb_unset (a->sdb_hints, key, 0);
}
}
R_API int r_anal_var_delete (RAnal *a, ut64 addr, const char kind, int scope, int delta) {
if (delta<0)
delta = -delta;
RAnalVar *av = r_anal_var_get (a, addr, kind, scope, delta);
if (scope>0) {
char *fcn_key = sdb_fmt (1, "fcn.0x%"PFMT64x".%c", addr, kind);
char *var_key = sdb_fmt (2, "var.0x%"PFMT64x".%c.%d.%d", addr, kind, scope, delta);
char *name_key = sdb_fmt (3, "var.0x%"PFMT64x".%c.%d.%s", addr, kind, scope, av->name);
char *shortvar = sdb_fmt (4, "%d.%d", scope, delta);
sdb_array_remove (DB, fcn_key, shortvar, 0);
sdb_unset (DB, var_key, 0);
sdb_unset (DB, name_key, 0);
} else {
char *var_global = sdb_fmt (1, "var.0x%"PFMT64x, addr);
char *var_def = sdb_fmt (2,"%c.%s,%d,%s", kind, av->type, av->size, av->name);
sdb_array_remove (DB, var_global, var_def, 0);
}
r_anal_var_access_clear (a, addr, scope, delta);
return true;
}
R_API int r_meta_del(RAnal *a, int type, ut64 addr, ut64 size, const char *str) {
char key[100], key2[100], *dtr, *s, *p, *next;
const char *ptr;
int i;
if (size == UT64_MAX) {
// FULL CLEANUP
// XXX: this thing ignores the type
if (type == R_META_TYPE_ANY) {
sdb_reset (DB);
} else {
snprintf (key, sizeof (key)-1, "meta.%c", type);
dtr = sdb_get (DB, key, 0);
for (p = dtr; p; p = next) {
s = sdb_anext (p, &next);
snprintf (key, sizeof (key)-1,
"meta.%c.0x%"PFMT64x,
type, sdb_atoi (s));
eprintf ("--> %s\n", key);
sdb_unset (DB, key, 0);
if (!next) break;
}
free (dtr);
}
return R_FALSE;
}
meta_inrange_del (a, addr, size);
snprintf (key, sizeof (key)-1, type==R_META_TYPE_COMMENT ? "meta.C.0x%"PFMT64x : "meta.0x%"PFMT64x, addr);
ptr = sdb_const_get (DB, key, 0);
if (ptr) {
for (i=0; ptr[i]; i++) {
if (ptr[i] != SDB_RS) {
snprintf (key2, sizeof (key2)-1,
"meta.%c.0x%"PFMT64x, ptr[i], addr);
sdb_unset (DB, key2, 0);
}
}
}
sdb_unset (DB, key, 0);
return R_FALSE;
}
R_API int r_anal_fcn_label_set (RAnal *anal, RAnalFunction *fcn, const char *name, ut64 addr) {
if (!anal || !fcn)
return R_FALSE;
if (sdb_add (DB, ADDR(addr), name, 0)) {
if (sdb_num_add (DB, LABEL(name), addr, 0)) {
sdb_array_add (DB, LABELS, ADDRLABEL (addr, name), 0);
return R_TRUE;
} else {
sdb_unset (DB, ADDR(addr), 0);
}
}
return R_FALSE;
}
R_API void r_anal_type_del(RAnal *anal, const char *name) {
int n;
char *p, str[128], str2[128];
Sdb *DB = anal->sdb_types;
const char *kind = sdb_const_get (DB, name, 0);
snprintf (str, sizeof (str), "%s.%s", kind, name);
#define SDB_FOREACH(x,y,z) for (z = 0; (p = sdb_array_get (x, y, z, NULL)); z++)
#define SDB_FOREACH_NEXT() free(p)
SDB_FOREACH (DB, str, n) {
snprintf (str2, sizeof (str2), "%s.%s", str, p);
sdb_unset (DB, str2, 0);
SDB_FOREACH_NEXT ();
}
SDB_API char *sdb_array_pop_head(Sdb *s, const char *key, ut32 *cas) {
// remove last element in
ut32 kas;
char *end, *str = sdb_get (s, key, &kas);
if (!str || !*str) {
free (str);
return NULL;
}
if (cas && *cas != kas)
*cas = kas;
end = strchr (str, SDB_RS);
if (end) {
*end = 0;
sdb_set (s, key, end + 1, 0);
} else {
sdb_unset (s, key, 0);
}
return str;
}
R_API int r_meta_var_comment_del(RAnal *a, int type, ut64 idx, ut64 addr) {
char *key;
key = r_str_newf ("meta.%c.0x%"PFMT64x"0x%"PFMT64x, type, addr, idx);
sdb_unset (DB, key, 0);
return 0;
}
R_API int r_meta_del(RAnal *a, int type, ut64 addr, ut64 size) {
char key[100], *dtr, *s, *p, *next;
const char *val;
int i;
if (size == UT64_MAX) {
// FULL CLEANUP
// XXX: this thing ignores the type
if (type == R_META_TYPE_ANY) {
sdb_reset (DB);
} else {
snprintf (key, sizeof (key)-1, "meta.%c.count", type);
int last = (ut64)sdb_num_get (DB, key, NULL)/K;
for (i=0; i<last; i++) {
snprintf (key, sizeof (key)-1, "meta.%c.%d", type, i);
dtr = sdb_get (DB, key, 0);
for (p = dtr; p; p = next) {
s = sdb_anext (p, &next);
snprintf (key, sizeof (key)-1,
"meta.%c.0x%"PFMT64x,
type, sdb_atoi (s));
sdb_unset (DB, key, 0);
if (!next) break;
}
free (dtr);
}
}
return false;
}
if (type == R_META_TYPE_ANY) {
/* special case */
r_meta_del (a, R_META_TYPE_COMMENT, addr, size);
r_meta_del (a, R_META_TYPE_VARTYPE, addr, size);
}
if (type == R_META_TYPE_COMMENT || type == R_META_TYPE_VARTYPE) {
snprintf (key, sizeof (key)-1, "meta.%c.0x%"PFMT64x, type, addr);
} else {
snprintf (key, sizeof (key)-1, "meta.0x%"PFMT64x, addr);
}
meta_inrange_del (a, addr, size);
val = sdb_const_get (DB, key, 0);
if (val) {
if (type == R_META_TYPE_ANY) {
char item_key[100];
const char *ptr = val;
while (*ptr) {
snprintf (item_key, sizeof (item_key), "meta.%c.0x%" PFMT64x, *ptr, addr);
sdb_unset (DB, item_key, 0);
ptr++;
if (*ptr) {
ptr++;
}
}
sdb_unset (DB, key, 0);
return false;
}
if (strchr (val, ',')) {
char type_fld[] = "##";
if (val[0] == type) {
type_fld[0] = type;
type_fld[1] = ',';
} else {
type_fld[0] = ',';
type_fld[1] = type;
}
sdb_uncat (DB, key, type_fld, 0);
} else {
sdb_unset (DB, key, 0);
}
snprintf (key, sizeof (key), "meta.%c.0x%" PFMT64x, type, addr);
sdb_unset (DB, key, 0);
}
sdb_unset (DB, key, 0);
return false;
}
R_API void r_anal_pin_unset (RAnal *a, ut64 addr) {
char buf[64];
const char *key = sdb_itoa (addr, buf, 16);
sdb_unset (DB, key, 0);
}
