Rizin
unix-like reverse engineering framework and cli tools
Macros | Functions
data.c File Reference
#include <rz_analysis.h>

Go to the source code of this file.

Macros

#define MINLEN   1
 
#define USE_IS_VALID_OFFSET   1
 

Functions

static int is_string (const ut8 *buf, int size, int *len)
 
static int is_number (const ut8 *buf, int size)
 
static int is_null (const ut8 *buf, int size)
 
static int is_invalid (const ut8 *buf, int size)
 
static ut64 is_pointer (RzAnalysis *analysis, const ut8 *buf, int size)
 
static bool is_bin (const ut8 *buf, int size)
 
RZ_API char * rz_analysis_data_to_string (RzAnalysisData *d, RzConsPrintablePalette *pal)
 
RZ_API RzAnalysisData * rz_analysis_data_new_string (ut64 addr, const char *p, int len, int type)
 
RZ_API RzAnalysisData * rz_analysis_data_new (ut64 addr, int type, ut64 n, const ut8 *buf, int len)
 
RZ_API void rz_analysis_data_free (RzAnalysisData *d)
 
RZ_API RzAnalysisData * rz_analysis_data (RzAnalysis *analysis, ut64 addr, const ut8 *buf, int size, int wordsize)
 
RZ_API const char * rz_analysis_data_kind (RzAnalysis *a, ut64 addr, const ut8 *buf, int len)
 
RZ_API const char * rz_analysis_datatype_to_string (RzAnalysisDataType t)
 

Macro Definition Documentation

◆ MINLEN

#define MINLEN   1

Definition at line 6 of file data.c.

◆ USE_IS_VALID_OFFSET

#define USE_IS_VALID_OFFSET   1

Definition at line 57 of file data.c.

Function Documentation

◆ is_bin()

static bool is_bin ( const ut8 *  buf,
int  size 
)
static

Definition at line 88 of file data.c.

88  {
89  // TODO: add more magic signatures heres
90  if ((size >= 4 && !memcmp(buf, "\xcf\xfa\xed\xfe", 4))) {
91  return true;
92  }
93  if ((size >= 4 && !memcmp(buf, "\x7f\x45\x4c\x46", 4))) { // \x7fELF
94  return true;
95  }
96  if ((size >= 2 && !memcmp(buf, "MZ", 2))) {
97  return true;
98  }
99  return false;
100 }
size
voidpf void uLong size
Definition: ioapi.h:138
buf
voidpf void * buf
Definition: ioapi.h:138

Referenced by rz_analysis_data().

◆ is_invalid()

static int is_invalid ( const ut8 *  buf,
int  size 
)
static

Definition at line 47 of file data.c.

47  {
48  if (size < 1) {
49  return 1;
50  }
51  if (size > 8) {
52  size = 8;
53  }
54  return (!memcmp(buf, "\xff\xff\xff\xff\xff\xff\xff\xff", size)) ? 1 : 0;
55 }

Referenced by is_pointer(), and rz_analysis_data().

◆ is_null()

static int is_null ( const ut8 *  buf,
int  size 
)
static

Definition at line 42 of file data.c.

42  {
43  const char zero[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
44  return (!memcmp(buf, &zero, size)) ? 1 : 0;
45 }

Referenced by rz_analysis_data().

◆ is_number()

static int is_number ( const ut8 *  buf,
int  size 
)
static

Definition at line 37 of file data.c.

37  {
38  ut64 n = rz_mem_get_num(buf, size);
39  return (n < UT32_MAX) ? (int)n : 0;
40 }
n
int n
Definition: mipsasm.c:19
rz_mem_get_num
RZ_API ut64 rz_mem_get_num(const ut8 *b, int size)
Definition: mem.c:152
UT32_MAX
#define UT32_MAX
Definition: rz_types_base.h:99
int
static int
Definition: sfsocketcall.h:114
ut64
ut64(WINAPI *w32_GetEnabledXStateFeatures)()

References int, n, rz_mem_get_num(), UT32_MAX, and ut64().

Referenced by rz_analysis_data(), and tokenize_asm_generic().

◆ is_pointer()

static ut64 is_pointer ( RzAnalysis *  analysis,
const ut8 *  buf,
int  size 
)
static

Definition at line 58 of file data.c.

58  {
59  ut64 n;
60  ut8 buf2[32];
61  RzIOBind *iob = &analysis->iob;
62  if (size > sizeof(buf2)) {
63  size = sizeof(buf2);
64  }
65  n = rz_mem_get_num(buf, size);
66  if (!n) {
67  return 1; // null pointer
68  }
69 #if USE_IS_VALID_OFFSET
70  int r = iob->is_valid_offset(iob->io, n, 0);
71  return r ? n : 0LL;
72 #else
73  // optimization to ignore very low and very high pointers
74  // this makes disasm 5x faster, but can result in some false positives
75  // we should compare with current offset, to avoid
76  // short/long references. and discard invalid ones
77  if (n < 0x1000)
78  return 0; // probably wrong
79  if (n > 0xffffffffffffLL)
80  return 0; // probably wrong
81 
82  if (iob->read_at(iob->io, n, buf2, size) != size)
83  return 0;
84  return is_invalid(buf2, size) ? 0 : n;
85 #endif
86 }
r
#define r
Definition: crypto_rc6.c:12
is_invalid
static int is_invalid(const ut8 *buf, int size)
Definition: data.c:47
ut8
uint8_t ut8
Definition: lh5801.h:11
buf2
static uint32_t const uint8_t * buf2
Definition: memcmplen.h:43
rz_analysis_t::iob
RzIOBind iob
Definition: rz_analysis.h:574
rz_io_bind_t
Definition: rz_io.h:230
rz_io_bind_t::read_at
RzIOReadAt read_at
Definition: rz_io.h:240
rz_io_bind_t::is_valid_offset
RzIOIsValidOff is_valid_offset
Definition: rz_io.h:257
rz_io_bind_t::io
RzIO * io
Definition: rz_io.h:232

References buf2, rz_io_bind_t::io, rz_analysis_t::iob, is_invalid(), rz_io_bind_t::is_valid_offset, n, r, rz_io_bind_t::read_at, rz_mem_get_num(), and ut64().

Referenced by rz_analysis_data().

◆ is_string()

static int is_string ( const ut8 *  buf,
int  size,
int *  len 
)
static

Definition at line 7 of file data.c.

7  {
8  int i;
9  if (size < 1) {
10  return 0;
11  }
12  if (size > 3 && buf[0] && !buf[1] && buf[2] && !buf[3]) {
13  *len = 1; // XXX: TODO: Measure wide string length
14  return 2; // is wide
15  }
16  for (i = 0; i < size; i++) {
17  if (!buf[i] && i > MINLEN) {
18  *len = i;
19  return 1;
20  }
21  if (buf[i] == 10 || buf[i] == 13 || buf[i] == 9) {
22  continue;
23  }
24  if (buf[i] < 32 || buf[i] > 127) {
25  // not ascii text
26  return 0;
27  }
28  if (!IS_PRINTABLE(buf[i])) {
29  *len = i;
30  return 0;
31  }
32  }
33  *len = i;
34  return 1;
35 }
len
size_t len
Definition: 6502dis.c:15
i
lzma_index ** i
Definition: index.h:629
MINLEN
#define MINLEN
Definition: data.c:6
IS_PRINTABLE
#define IS_PRINTABLE(x)
Definition: rz_str_util.h:10

References i, IS_PRINTABLE, len, and MINLEN.

Referenced by hash_context_create_desc_io_string(), and rz_analysis_data().

◆ rz_analysis_data()

RZ_API RzAnalysisData* rz_analysis_data ( RzAnalysis *  analysis,
ut64  addr,
const ut8 *  buf,
int  size,
int  wordsize 
)

Definition at line 283 of file data.c.

283  {
284  ut64 dst = 0;
285  int n, nsize = 0;
286  int bits = analysis->bits;
287  int word = wordsize ? wordsize : RZ_MIN(8, bits / 8);
288 
289  if (size < 4) {
290  return NULL;
291  }
292  if (size >= word && is_invalid(buf, word)) {
293  return rz_analysis_data_new(addr, RZ_ANALYSIS_DATA_TYPE_INVALID, -1, buf, word);
294  }
295  {
296  int i, len = RZ_MIN(size, 64);
297  int is_pattern = 0;
298  int is_sequence = 0;
299  char ch = buf[0];
300  char ch2 = ch + 1;
301  for (i = 1; i < len; i++) {
302  if (ch2 == buf[i]) {
303  ch2++;
304  is_sequence++;
305  } else {
306  is_sequence = 0;
307  }
308  if (ch == buf[i]) {
309  is_pattern++;
310  }
311  }
312  if (is_sequence > len - 2) {
313  return rz_analysis_data_new(addr, RZ_ANALYSIS_DATA_TYPE_SEQUENCE, -1,
314  buf, is_sequence);
315  }
316  if (is_pattern > len - 2) {
317  return rz_analysis_data_new(addr, RZ_ANALYSIS_DATA_TYPE_PATTERN, -1,
318  buf, is_pattern);
319  }
320  }
321  if (size >= word && is_null(buf, word)) {
322  return rz_analysis_data_new(addr, RZ_ANALYSIS_DATA_TYPE_NULL, -1, buf, word);
323  }
324  if (is_bin(buf, size)) {
325  return rz_analysis_data_new(addr, RZ_ANALYSIS_DATA_TYPE_HEADER, -1, buf, word);
326  }
327  if (size >= word) {
328  dst = is_pointer(analysis, buf, word);
329  if (dst) {
330  return rz_analysis_data_new(addr, RZ_ANALYSIS_DATA_TYPE_POINTER, dst, buf, word);
331  }
332  }
333  switch (is_string(buf, size, &nsize)) {
334  case 1: return rz_analysis_data_new_string(addr, (const char *)buf, nsize, RZ_ANALYSIS_DATA_TYPE_STRING);
335  case 2: return rz_analysis_data_new_string(addr, (const char *)buf, nsize, RZ_ANALYSIS_DATA_TYPE_WIDE_STRING);
336  }
337  if (size >= word) {
338  n = is_number(buf, word);
339  if (n) {
340  return rz_analysis_data_new(addr, RZ_ANALYSIS_DATA_TYPE_NUMBER, n, buf, word);
341  }
342  }
343  return rz_analysis_data_new(addr, RZ_ANALYSIS_DATA_TYPE_UNKNOWN, dst, buf, RZ_MIN(word, size));
344 }
bits
int bits(struct state *s, int need)
Definition: blast.c:72
NULL
#define NULL
Definition: cris-opc.c:27
rz_analysis_data_new
RZ_API RzAnalysisData * rz_analysis_data_new(ut64 addr, int type, ut64 n, const ut8 *buf, int len)
Definition: data.c:243
is_null
static int is_null(const ut8 *buf, int size)
Definition: data.c:42
is_pointer
static ut64 is_pointer(RzAnalysis *analysis, const ut8 *buf, int size)
Definition: data.c:58
rz_analysis_data_new_string
RZ_API RzAnalysisData * rz_analysis_data_new_string(ut64 addr, const char *p, int len, int type)
Definition: data.c:208
is_number
static int is_number(const ut8 *buf, int size)
Definition: data.c:37
is_string
static int is_string(const ut8 *buf, int size, int *len)
Definition: data.c:7
is_bin
static bool is_bin(const ut8 *buf, int size)
Definition: data.c:88
dst
char * dst
Definition: lz4.h:724
RZ_ANALYSIS_DATA_TYPE_INVALID
@ RZ_ANALYSIS_DATA_TYPE_INVALID
Definition: rz_analysis.h:78
RZ_ANALYSIS_DATA_TYPE_PATTERN
@ RZ_ANALYSIS_DATA_TYPE_PATTERN
Definition: rz_analysis.h:81
RZ_ANALYSIS_DATA_TYPE_UNKNOWN
@ RZ_ANALYSIS_DATA_TYPE_UNKNOWN
Definition: rz_analysis.h:73
RZ_ANALYSIS_DATA_TYPE_NUMBER
@ RZ_ANALYSIS_DATA_TYPE_NUMBER
Definition: rz_analysis.h:77
RZ_ANALYSIS_DATA_TYPE_STRING
@ RZ_ANALYSIS_DATA_TYPE_STRING
Definition: rz_analysis.h:74
RZ_ANALYSIS_DATA_TYPE_WIDE_STRING
@ RZ_ANALYSIS_DATA_TYPE_WIDE_STRING
Definition: rz_analysis.h:75
RZ_ANALYSIS_DATA_TYPE_HEADER
@ RZ_ANALYSIS_DATA_TYPE_HEADER
Definition: rz_analysis.h:79
RZ_ANALYSIS_DATA_TYPE_POINTER
@ RZ_ANALYSIS_DATA_TYPE_POINTER
Definition: rz_analysis.h:76
RZ_ANALYSIS_DATA_TYPE_SEQUENCE
@ RZ_ANALYSIS_DATA_TYPE_SEQUENCE
Definition: rz_analysis.h:80
RZ_ANALYSIS_DATA_TYPE_NULL
@ RZ_ANALYSIS_DATA_TYPE_NULL
Definition: rz_analysis.h:72
RZ_MIN
#define RZ_MIN(x, y)
Definition: rz_types_base.h:140
rz_analysis_t::bits
int bits
Definition: rz_analysis.h:556
addr
static int addr
Definition: z80asm.c:58

References addr, rz_analysis_t::bits, bits(), dst, i, is_bin(), is_invalid(), is_null(), is_number(), is_pointer(), is_string(), len, n, NULL, rz_analysis_data_new(), rz_analysis_data_new_string(), RZ_ANALYSIS_DATA_TYPE_HEADER, RZ_ANALYSIS_DATA_TYPE_INVALID, RZ_ANALYSIS_DATA_TYPE_NULL, RZ_ANALYSIS_DATA_TYPE_NUMBER, RZ_ANALYSIS_DATA_TYPE_PATTERN, RZ_ANALYSIS_DATA_TYPE_POINTER, RZ_ANALYSIS_DATA_TYPE_SEQUENCE, RZ_ANALYSIS_DATA_TYPE_STRING, RZ_ANALYSIS_DATA_TYPE_UNKNOWN, RZ_ANALYSIS_DATA_TYPE_WIDE_STRING, RZ_MIN, and ut64().

Referenced by rz_analysis_data_kind(), and rz_core_analysis_data().

◆ rz_analysis_data_free()

RZ_API void rz_analysis_data_free ( RzAnalysisData *  d)

Definition at line 273 of file data.c.

273  {
274  if (d) {
275  if (d->buf != (ut8 *)&(d->sbuf)) {
276  free(d->buf);
277  }
278  free(d->str);
279  free(d);
280  }
281 }
free
RZ_API void Ht_() free(HtName_(Ht) *ht)
Definition: ht_inc.c:130
d
#define d(i)
Definition: sha256.c:44

References d, and free().

Referenced by rz_analysis_data_kind(), rz_analysis_data_new(), rz_analysis_data_new_string(), and rz_core_analysis_data().

◆ rz_analysis_data_kind()

RZ_API const char* rz_analysis_data_kind ( RzAnalysis *  a,
ut64  addr,
const ut8 *  buf,
int  len 
)

Definition at line 346 of file data.c.

346  {
347  int inv = 0;
348  int unk = 0;
349  int str = 0;
350  int num = 0;
351  int i, j;
352  RzAnalysisData *data;
353  int word = a->bits / 8;
354  for (i = j = 0; i < len; j++) {
355  if (str && !buf[i]) {
356  str++;
357  }
358  data = rz_analysis_data(a, addr + i, buf + i, len - i, 0);
359  if (!data) {
360  i += word;
361  continue;
362  }
363  switch (data->type) {
364  case RZ_ANALYSIS_DATA_TYPE_INVALID:
365  inv++;
366  i += word;
367  break;
368  case RZ_ANALYSIS_DATA_TYPE_NUMBER:
369  if (data->ptr > 1000) {
370  num++;
371  }
372  i += word;
373  break;
374  case RZ_ANALYSIS_DATA_TYPE_UNKNOWN:
375  unk++;
376  i += word;
377  break;
378  case RZ_ANALYSIS_DATA_TYPE_STRING:
379  if (data->len > 0) {
380  i += data->len;
381  } else {
382  i += word;
383  }
384  str++;
385  break;
386  default:
387  i += word;
388  }
389  rz_analysis_data_free(data);
390  }
391  if (j < 1) {
392  return "unknown";
393  }
394  if ((inv * 100 / j) > 60) {
395  return "invalid";
396  }
397  if ((unk * 100 / j) > 60) {
398  return "code";
399  }
400  if ((num * 100 / j) > 60) {
401  return "code";
402  }
403  if ((str * 100 / j) > 40) {
404  return "text";
405  }
406  return "data";
407 }
rz_analysis_data
RZ_API RzAnalysisData * rz_analysis_data(RzAnalysis *analysis, ut64 addr, const ut8 *buf, int size, int wordsize)
Definition: data.c:283
rz_analysis_data_free
RZ_API void rz_analysis_data_free(RzAnalysisData *d)
Definition: data.c:273
num
static static fork const void static count static fd const char const char static newpath char char char static envp time_t static t const char static mode static whence const char static dir time_t static t unsigned static seconds const char struct utimbuf static buf static inc static sig const char static mode static oldfd struct tms static buf static getgid static geteuid const char static filename static arg static mask struct ustat static ubuf static getppid static setsid static egid sigset_t static set struct timeval struct timezone static tz fd_set fd_set fd_set struct timeval static timeout const char char static bufsiz const char static swapflags void static offset const char static length static mode static who const char struct statfs static buf unsigned unsigned num
Definition: sflib.h:126
cmd_descs_generate.str
str
Definition: cmd_descs_generate.py:785
a
#define a(i)
Definition: sha256.c:41

References a, addr, i, len, num, rz_analysis_data(), rz_analysis_data_free(), RZ_ANALYSIS_DATA_TYPE_INVALID, RZ_ANALYSIS_DATA_TYPE_NUMBER, RZ_ANALYSIS_DATA_TYPE_STRING, RZ_ANALYSIS_DATA_TYPE_UNKNOWN, and cmd_descs_generate::str.

Referenced by ds_print_ptr(), and rz_cmd_analysis().

◆ rz_analysis_data_new()

RZ_API RzAnalysisData* rz_analysis_data_new ( ut64  addr,
int  type,
ut64  n,
const ut8 *  buf,
int  len 
)

Definition at line 243 of file data.c.

243  {
244  RzAnalysisData *ad = RZ_NEW0(RzAnalysisData);
245  int l = RZ_MIN(len, 8);
246  if (!ad) {
247  return NULL;
248  }
249  ad->buf = (ut8 *)&(ad->sbuf);
250  memset(ad->buf, 0, 8);
251  if (l < 1) {
252  rz_analysis_data_free(ad);
253  return NULL;
254  }
255  if (buf) {
256  memcpy(ad->buf, buf, l);
257  }
258  ad->addr = addr;
259  ad->type = type;
260  ad->str = NULL;
261  switch (type) {
262  case RZ_ANALYSIS_DATA_TYPE_PATTERN:
263  case RZ_ANALYSIS_DATA_TYPE_SEQUENCE:
264  ad->len = len;
265  break;
266  default:
267  ad->len = l;
268  }
269  ad->ptr = n;
270  return ad;
271 }
memset
return memset(p, 0, total)
memcpy
memcpy(mem, inblock.get(), min(CONTAINING_RECORD(inblock.get(), MEMBLOCK, data) ->size, size))
type
int type
Definition: mipsasm.c:17
RZ_NEW0
#define RZ_NEW0(x)
Definition: rz_types.h:284

References addr, len, memcpy(), memset(), n, NULL, rz_analysis_data_free(), RZ_ANALYSIS_DATA_TYPE_PATTERN, RZ_ANALYSIS_DATA_TYPE_SEQUENCE, RZ_MIN, RZ_NEW0, and type.

Referenced by rz_analysis_data().

◆ rz_analysis_data_new_string()

RZ_API RzAnalysisData* rz_analysis_data_new_string ( ut64  addr,
const char *  p,
int  len,
int  type 
)

Definition at line 208 of file data.c.

208  {
209  RzAnalysisData *ad = RZ_NEW0(RzAnalysisData);
210  if (!ad) {
211  return NULL;
212  }
213  ad->str = NULL;
214  ad->addr = addr;
215  ad->type = type;
216  if (len == 0) {
217  len = strlen(p);
218  }
219 
220  if (type == RZ_ANALYSIS_DATA_TYPE_WIDE_STRING) {
221  /* TODO: add support for wide strings */
222  } else {
223  ad->str = malloc(len + 1);
224  if (!ad->str) {
225  rz_analysis_data_free(ad);
226  return NULL;
227  }
228  memcpy(ad->str, p, len);
229  ad->str[len] = 0;
230  ad->buf = malloc(len + 1);
231  if (!ad->buf) {
232  rz_analysis_data_free(ad);
233  RZ_LOG_ERROR("Cannot allocate %d byte(s)\n", len + 1);
234  return NULL;
235  }
236  memcpy(ad->buf, ad->str, len + 1);
237  ad->len = len + 1; // string length + \x00
238  }
239  ad->ptr = 0L;
240  return ad;
241 }
p
void * p
Definition: libc.cpp:67
malloc
void * malloc(size_t size)
Definition: malloc.c:123
RZ_LOG_ERROR
#define RZ_LOG_ERROR(fmtstr,...)
Definition: rz_log.h:58
L
#define L
Definition: zip_err_str.c:7

References addr, L, len, malloc(), memcpy(), NULL, p, rz_analysis_data_free(), RZ_ANALYSIS_DATA_TYPE_WIDE_STRING, RZ_LOG_ERROR, RZ_NEW0, and type.

Referenced by rz_analysis_data().

◆ rz_analysis_data_to_string()

RZ_API char* rz_analysis_data_to_string ( RzAnalysisData *  d,
RzConsPrintablePalette *  pal 
)

Definition at line 104 of file data.c.

104  {
105  int i, len, mallocsz = 1024;
106  ut32 n32;
107 
108  if (!d) {
109  return NULL;
110  }
111 
112  RzStrBuf *sb = rz_strbuf_new(NULL);
113  if (!sb) {
114  return NULL;
115  }
116  if (!rz_strbuf_reserve(sb, mallocsz)) {
117  RZ_LOG_ERROR("Cannot allocate %d byte(s)\n", mallocsz);
118  rz_strbuf_free(sb);
119  return NULL;
120  }
121  if (pal) {
122  const char *k = pal->offset;
123  rz_strbuf_appendf(sb, "%s0x%08" PFMT64x Color_RESET " ", k, d->addr);
124  } else {
125  rz_strbuf_appendf(sb, "0x%08" PFMT64x " ", d->addr);
126  }
127  n32 = (ut32)d->ptr;
128  len = RZ_MIN(d->len, 8);
129  for (i = 0; i < len; i++) {
130  rz_strbuf_appendf(sb, "%02x", d->buf[i]);
131  }
132  if (i > 0 && d->len > len) {
133  rz_strbuf_append(sb, "..");
134  }
135  rz_strbuf_append(sb, " ");
136  switch (d->type) {
137  case RZ_ANALYSIS_DATA_TYPE_STRING:
138  if (pal) {
139  rz_strbuf_appendf(sb, "%sstring \"%s\"" Color_RESET, pal->comment, d->str);
140  } else {
141  rz_strbuf_appendf(sb, "string \"%s\"", d->str);
142  }
143  break;
144  case RZ_ANALYSIS_DATA_TYPE_WIDE_STRING:
145  rz_strbuf_append(sb, "wide string");
146  break;
147  case RZ_ANALYSIS_DATA_TYPE_NUMBER:
148  if (pal) {
149  const char *k = pal->num;
150  if (n32 == d->ptr) {
151  rz_strbuf_appendf(sb, "%snumber %d (0x%x)" Color_RESET, k, n32, n32);
152  } else {
153  rz_strbuf_appendf(sb, "%snumber %" PFMT64d " (0x%" PFMT64x ")" Color_RESET,
154  k, d->ptr, d->ptr);
155  }
156  } else {
157  if (n32 == d->ptr) {
158  rz_strbuf_appendf(sb, "number %d 0x%x", n32, n32);
159  } else {
160  rz_strbuf_appendf(sb, "number %" PFMT64d " 0x%" PFMT64x,
161  d->ptr, d->ptr);
162  }
163  }
164  break;
165  case RZ_ANALYSIS_DATA_TYPE_POINTER:
166  rz_strbuf_append(sb, "pointer ");
167  if (pal) {
168  const char *k = pal->offset;
169  rz_strbuf_appendf(sb, " %s0x%08" PFMT64x, k, d->ptr);
170  } else {
171  rz_strbuf_appendf(sb, " 0x%08" PFMT64x, d->ptr);
172  }
173  break;
174  case RZ_ANALYSIS_DATA_TYPE_INVALID:
175  if (pal) {
176  rz_strbuf_appendf(sb, "%sinvalid" Color_RESET, pal->invalid);
177  } else {
178  rz_strbuf_append(sb, "invalid");
179  }
180  break;
181  case RZ_ANALYSIS_DATA_TYPE_HEADER:
182  rz_strbuf_append(sb, "header");
183  break;
184  case RZ_ANALYSIS_DATA_TYPE_SEQUENCE:
185  rz_strbuf_append(sb, "sequence");
186  break;
187  case RZ_ANALYSIS_DATA_TYPE_PATTERN:
188  rz_strbuf_append(sb, "pattern");
189  break;
190  case RZ_ANALYSIS_DATA_TYPE_UNKNOWN:
191  if (pal) {
192  rz_strbuf_appendf(sb, "%sunknown" Color_RESET, pal->invalid);
193  } else {
194  rz_strbuf_append(sb, "unknown");
195  }
196  break;
197  default:
198  if (pal) {
199  rz_strbuf_appendf(sb, "%s(null)" Color_RESET, pal->b0x00);
200  } else {
201  rz_strbuf_append(sb, "(null)");
202  }
203  break;
204  }
205  return rz_strbuf_drain(sb);
206 }
sb
static SblHeader sb
Definition: bin_mbn.c:26
ut32
uint32_t ut32
Definition: demangler_util.h:31
k
const char * k
Definition: dsignal.c:11
Color_RESET
#define Color_RESET
Definition: rz_cons.h:617
rz_strbuf_drain
RZ_API RZ_OWN char * rz_strbuf_drain(RzStrBuf *sb)
Definition: strbuf.c:342
rz_strbuf_reserve
RZ_API bool rz_strbuf_reserve(RzStrBuf *sb, size_t len)
Definition: strbuf.c:67
rz_strbuf_append
RZ_API bool rz_strbuf_append(RzStrBuf *sb, const char *s)
Definition: strbuf.c:222
rz_strbuf_new
RZ_API RzStrBuf * rz_strbuf_new(const char *s)
Definition: strbuf.c:8
rz_strbuf_free
RZ_API void rz_strbuf_free(RzStrBuf *sb)
Definition: strbuf.c:358
rz_strbuf_appendf
RZ_API bool rz_strbuf_appendf(RzStrBuf *sb, const char *fmt,...) RZ_PRINTF_CHECK(2
PFMT64d
#define PFMT64d
Definition: rz_types.h:394
PFMT64x
#define PFMT64x
Definition: rz_types.h:393
rz_cons_printable_palette_t::offset
char * offset
Definition: rz_cons.h:295
rz_cons_printable_palette_t::b0x00
char * b0x00
Definition: rz_cons.h:268
rz_cons_printable_palette_t::num
char * num
Definition: rz_cons.h:294
rz_cons_printable_palette_t::invalid
char * invalid
Definition: rz_cons.h:288
rz_cons_printable_palette_t::comment
char * comment
Definition: rz_cons.h:277

References rz_cons_printable_palette_t::b0x00, Color_RESET, rz_cons_printable_palette_t::comment, d, i, rz_cons_printable_palette_t::invalid, k, len, NULL, rz_cons_printable_palette_t::num, rz_cons_printable_palette_t::offset, PFMT64d, PFMT64x, RZ_ANALYSIS_DATA_TYPE_HEADER, RZ_ANALYSIS_DATA_TYPE_INVALID, RZ_ANALYSIS_DATA_TYPE_NUMBER, RZ_ANALYSIS_DATA_TYPE_PATTERN, RZ_ANALYSIS_DATA_TYPE_POINTER, RZ_ANALYSIS_DATA_TYPE_SEQUENCE, RZ_ANALYSIS_DATA_TYPE_STRING, RZ_ANALYSIS_DATA_TYPE_UNKNOWN, RZ_ANALYSIS_DATA_TYPE_WIDE_STRING, RZ_LOG_ERROR, RZ_MIN, rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_free(), rz_strbuf_new(), rz_strbuf_reserve(), and sb.

Referenced by rz_core_analysis_data().

◆ rz_analysis_datatype_to_string()

RZ_API const char* rz_analysis_datatype_to_string ( RzAnalysisDataType  t)

Definition at line 409 of file data.c.

409  {
410  switch (t) {
411  case RZ_ANALYSIS_DATATYPE_NULL:
412  return NULL;
413  case RZ_ANALYSIS_DATATYPE_ARRAY:
414  return "array";
415  case RZ_ANALYSIS_DATATYPE_OBJECT: // instance
416  return "object";
417  case RZ_ANALYSIS_DATATYPE_STRING:
418  return "string";
419  case RZ_ANALYSIS_DATATYPE_CLASS:
420  return "class";
421  case RZ_ANALYSIS_DATATYPE_BOOLEAN:
422  return "boolean";
423  case RZ_ANALYSIS_DATATYPE_INT16:
424  return "int16";
425  case RZ_ANALYSIS_DATATYPE_INT32:
426  return "int32";
427  case RZ_ANALYSIS_DATATYPE_INT64:
428  return "int64";
429  case RZ_ANALYSIS_DATATYPE_FLOAT:
430  return "float";
431  }
432  return NULL;
433 }
RZ_ANALYSIS_DATATYPE_FLOAT
@ RZ_ANALYSIS_DATATYPE_FLOAT
Definition: rz_analysis.h:806
RZ_ANALYSIS_DATATYPE_INT64
@ RZ_ANALYSIS_DATATYPE_INT64
Definition: rz_analysis.h:805
RZ_ANALYSIS_DATATYPE_STRING
@ RZ_ANALYSIS_DATATYPE_STRING
Definition: rz_analysis.h:800
RZ_ANALYSIS_DATATYPE_NULL
@ RZ_ANALYSIS_DATATYPE_NULL
Definition: rz_analysis.h:797
RZ_ANALYSIS_DATATYPE_INT32
@ RZ_ANALYSIS_DATATYPE_INT32
Definition: rz_analysis.h:804
RZ_ANALYSIS_DATATYPE_ARRAY
@ RZ_ANALYSIS_DATATYPE_ARRAY
Definition: rz_analysis.h:798
RZ_ANALYSIS_DATATYPE_CLASS
@ RZ_ANALYSIS_DATATYPE_CLASS
Definition: rz_analysis.h:801
RZ_ANALYSIS_DATATYPE_BOOLEAN
@ RZ_ANALYSIS_DATATYPE_BOOLEAN
Definition: rz_analysis.h:802
RZ_ANALYSIS_DATATYPE_OBJECT
@ RZ_ANALYSIS_DATATYPE_OBJECT
Definition: rz_analysis.h:799
RZ_ANALYSIS_DATATYPE_INT16
@ RZ_ANALYSIS_DATATYPE_INT16
Definition: rz_analysis.h:803

References NULL, RZ_ANALYSIS_DATATYPE_ARRAY, RZ_ANALYSIS_DATATYPE_BOOLEAN, RZ_ANALYSIS_DATATYPE_CLASS, RZ_ANALYSIS_DATATYPE_FLOAT, RZ_ANALYSIS_DATATYPE_INT16, RZ_ANALYSIS_DATATYPE_INT32, RZ_ANALYSIS_DATATYPE_INT64, RZ_ANALYSIS_DATATYPE_NULL, RZ_ANALYSIS_DATATYPE_OBJECT, and RZ_ANALYSIS_DATATYPE_STRING.

Referenced by core_analysis_bytes_json(), and core_analysis_bytes_standard().