static int assemble(RAsm *a, RAsmOp *op, const char *buf) {
char *ipath, *opath;
int ifd, ofd;
const char *syntaxstr = "";
char asm_buf[R_ASM_BUFSIZE];
int len = 0;
ifd = r_file_mkstemp ("r_as", &ipath);
ofd = r_file_mkstemp ("r_as", &opath);
syntaxstr = ".intel_syntax noprefix\n"; // if intel syntax
len = snprintf (asm_buf, sizeof (asm_buf),
"%s.code%i\n" //.org 0x%"PFMT64x"\n"
".ascii \"BEGINMARK\"\n"
"%s\n"
".ascii \"ENDMARK\"\n",
syntaxstr, a->bits, buf); // a->pc ??
write (ifd, asm_buf, len);
//write (1, asm_buf, len);
close (ifd);
if (!r_sys_cmdf ("as %s -o %s", ipath, opath)) {
const ut8 *begin, *end;
close (ofd);
ofd = open (opath, O_BINARY|O_RDONLY);
len = read (ofd, op->buf, R_ASM_BUFSIZE);
begin = r_mem_mem (op->buf, len, (const ut8*)"BEGINMARK", 9);
end = r_mem_mem (op->buf, len, (const ut8*)"ENDMARK", 7);
if (!begin || !end) {
eprintf ("Cannot find water marks\n");
len = 0;
} else {
len = (int)(size_t)(end-begin-9);
if (len>0) memcpy (op->buf, begin+9, len);
else len = 0;
}
} else {
eprintf ("Error running: as %s -o %s", ipath, opath);
len = 0;
}
close (ofd);
unlink (ipath);
unlink (opath);
free (ipath);
free (opath);
op->inst_len = len;
return len;
}
// TODO: integrate in '/' command with search.inblock ?
static void visual_search (RCore *core) {
const ut8 *p;
int len, d = cursor;
char str[128], buf[258];
r_line_set_prompt ("search byte/string in block: ");
r_cons_fgets (str, sizeof (str), 0, NULL);
len = r_hex_str2bin (str, (ut8*)buf);
if (*str=='"') {
char *e = strncpy (buf, str+1, sizeof (buf)-1);
if (e) { --e; if (*e=='"') *e=0; }
len = strlen (buf);
} else
if (len<1) {
strncpy (buf, str, sizeof (buf)-1);
len = strlen (str);
}
p = r_mem_mem (core->block+d, core->blocksize-d,
(const ut8*)buf, len);
if (p) {
cursor = (int)(size_t)(p-core->block);
if (len>1) {
ocursor = cursor+len-1;
} else ocursor = -1;
showcursor (core, true);
eprintf ("FOUND IN %d\n", cursor);
r_cons_any_key (NULL);
} else {
eprintf ("Cannot find bytes\n");
r_cons_any_key (NULL);
r_cons_clear00 ();
}
}
R_API int r_str_glob (const char *str, const char *glob) {
const char *p;
int slen, glen;
if (!*str) return R_TRUE;
glen = strlen (glob);
slen = strlen (str);
if (*glob == '*') {
if (glob[1] == '\0')
return R_TRUE;
if (glob[glen-1] == '*') {
return r_mem_mem ((const ut8*)str, slen, (const ut8*)glob+1, glen-2) != 0;
}
if (slen<glen-2)
return R_FALSE;
p = str + slen - (glen-1);
return memcmp (p, glob+1, glen-1) == 0;
} else {
if (glob[glen-1] == '*') {
if (slen<glen-1)
return R_FALSE;
return memcmp (str, glob, glen-1) == 0;
} else {
char *p = strchr (glob, '*');
if (p) {
int a = (int)(size_t)(p-glob);
return ((!memcmp (str, glob, a)) && ( !memcmp (str+slen-a, glob+a+1, glen-a-1)))? 1: 0;
} else {
return !strcmp (str, glob);
}
}
}
return R_FALSE; // statement never reached
}
R_API char* r_str_replace(char *str, const char *key, const char *val, int g) {
int off;
int klen = strlen (key);
int vlen = strlen (val);
int slen = strlen (str);
char *old, *p = str;
for (;;) {
p = (char *)r_mem_mem (
(const ut8*)str, slen,
(const ut8*)key, klen);
if (p) {
old = strdup (p+klen);
slen += (vlen-klen)+1;
off = (int)(size_t)(p-str);
str = realloc (str, slen);
p = str+off;
memcpy (p, val, vlen);
memcpy (p+vlen, old, strlen (old));
p[vlen] = 0;
free (old);
if (g) continue;
else break;
} else break;
}
return str;
}
R_API void r_cons_visual_write (char *buffer) {
char white[1024];
int cols = I.columns;
int alen, plen, lines = I.rows;
const char *endptr;
char *nl, *ptr = buffer, *pptr;
if (I.null) return;
memset (&white, ' ', sizeof (white));
while ((nl = strchr (ptr, '\n'))) {
int len = ((int)(size_t)(nl-ptr))+1;
*nl = 0;
alen = real_strlen (ptr, len);
*nl = '\n';
pptr = ptr > buffer ? ptr - 1 : ptr;
plen = ptr > buffer ? len : len - 1;
if (alen > cols) {
int olen = len;
endptr = r_str_ansi_chrn (ptr, cols);
endptr++;
len = endptr - ptr;
plen = ptr > buffer ? len : len - 1;
if (lines > 0) {
r_cons_write (pptr, plen);
if (len != olen) {
r_cons_write (Color_RESET, strlen (Color_RESET));
}
}
} else {
if (lines > 0) {
int w = cols - alen;
r_cons_write (pptr, plen);
if (I.blankline && w>0) {
if (w > sizeof (white) - 1)
w = sizeof (white) - 1;
r_cons_write (white, w);
}
}
// TRICK to empty columns.. maybe buggy in w32
if (r_mem_mem ((const ut8*)ptr, len, (const ut8*)"\x1b[0;0H", 6)) {
lines = I.rows;
r_cons_write (pptr, plen);
}
}
lines--; // do not use last line
ptr = nl + 1;
}
/* fill the rest of screen */
if (lines > 0) {
if (cols > sizeof (white)) {
cols = sizeof (white);
}
while (--lines >= 0) {
r_cons_write (white, cols);
}
}
}
R_API void r_cons_visual_write (char *buffer) {
char white[1024];
int cols = I.columns;
int alen, lines = I.rows;
const char *endptr;
char *nl, *ptr = buffer;
memset (&white, ' ', sizeof (white));
while ((nl = strchr (ptr, '\n'))) {
int len = ((int)(size_t)(nl-ptr))+1;
*nl = 0;
//alen = r_str_ansi_len (ptr);
// handle ansi chars
{
int utf8len = r_str_len_utf8 (ptr);
int ansilen = r_str_ansi_len (ptr);
int diff = len-utf8len;
if (diff) diff--;
alen = ansilen - diff;
}
*nl = '\n';
if (alen>cols) {
endptr = r_str_ansi_chrn (ptr, cols);
endptr++;
len = (endptr-ptr);
if (lines>0) {
r_cons_write (ptr, len);
}
} else {
if (lines>0) {
int w = cols-alen;
if (ptr>buffer) r_cons_write (ptr-1, len);
else r_cons_write (ptr, len-1);
if (I.blankline && w>0) {
if (w>sizeof (white)-1)
w = sizeof (white)-1;
r_cons_write (white, w);
}
}
// TRICK to empty columns.. maybe buggy in w32
if (r_mem_mem ((const ut8*)ptr, len, (const ut8*)"\x1b[0;0H", 6)) {
lines = I.rows;
r_cons_write (ptr, len);
}
}
lines--; // do not use last line
ptr = nl+1;
}
/* fill the rest of screen */
if (lines>0) {
if (cols>sizeof (white))
cols = sizeof (white);
while (lines-->0)
r_cons_write (white, cols);
}
}
R_API char* r_str_replace_thunked(char *str, char *clean, int *thunk, int clen,
const char *key, const char *val, int g) {
int i, klen, vlen, slen, delta = 0, bias;
char *newstr, *scnd, *p = clean, *str_p;
if (!str || !key || !val || !clean || !thunk) return NULL;
klen = strlen (key);
vlen = strlen (val);
if (klen == vlen && !strcmp (key, val))
return str;
slen = strlen (str) + 1;
for (i = 0; i < clen; ) {
bias = 0;
p = (char *)r_mem_mem (
(const ut8*)clean + i, clen - i,
(const ut8*)key, klen);
if (!p) break;
i = (int)(size_t)(p - clean);
/* as the original string changes size during replacement
* we need delta to keep track of it*/
str_p = str + thunk[i] + delta;
if (r_str_ansi_chrn(str_p, klen) - str_p > klen) {
/* f**k, we're trying to highlight
* a string with a CSI in the middle
* avoid color breakage and disable this particular
* CSIs */
int newo = thunk[i + klen] - thunk[i];
r_str_ansi_filter(str_p, NULL, NULL, newo);
scnd = strdup (str_p + newo);
bias = vlen - newo;
} else {
scnd = strdup (str_p + klen);
bias = vlen - klen;
}
slen += bias;
// HACK: this 32 avoids overwrites wtf
newstr = realloc (str, slen + klen);
if (!newstr) {
eprintf ("realloc fail\n");
free (str);
free (scnd);
str = NULL;
break;
}
str = newstr;
str_p = str + thunk[i] + delta;
memcpy (str_p, val, vlen);
memcpy (str_p + vlen, scnd, strlen (scnd) + 1);
i += klen;
delta += bias;
free (scnd);
if (!g) break;
}
return str;
}
/* replace the key in str with val.
*
* str - input string
* clean - input string cleaned of ANSI chars
* thunk - array of integers that map each char of the clean string into the
* position in the str string
* clen - number of elements in thunk
* key - string to find in the clean string
* val - string that replaces key in the str string
* g - if true, replace all occurences of key
*
* It returns a pointer to the modified string */
R_API char* r_str_replace_thunked(char *str, char *clean, int *thunk, int clen,
const char *key, const char *val, int g) {
int i, klen, vlen, slen, delta = 0, bias;
char *newstr, *scnd, *p = clean, *str_p;
if (!str || !key || !val || !clean || !thunk) {
return NULL;
}
klen = strlen (key);
vlen = strlen (val);
if (klen == vlen && !strcmp (key, val)) {
return str;
}
slen = strlen (str) + 1;
for (i = 0; i < clen; ) {
int newo;
bias = 0;
p = (char *)r_mem_mem (
(const ut8*)clean + i, clen - i,
(const ut8*)key, klen);
if (!p) {
break;
}
i = (int)(size_t)(p - clean);
/* as the original string changes size during replacement
* we need delta to keep track of it*/
str_p = str + thunk[i] + delta;
newo = thunk[i + klen] - thunk[i];
r_str_ansi_filter(str_p, NULL, NULL, newo);
scnd = strdup (str_p + newo);
bias = vlen - newo;
slen += bias;
// HACK: this 32 avoids overwrites wtf
newstr = realloc (str, slen + klen);
if (!newstr) {
eprintf ("realloc fail\n");
free (str);
free (scnd);
str = NULL;
break;
}
str = newstr;
str_p = str + thunk[i] + delta;
memcpy (str_p, val, vlen);
memcpy (str_p + vlen, scnd, strlen (scnd) + 1);
i += klen;
delta += bias;
free (scnd);
if (!g) {
break;
}
}
return str;
}
static void findPair (RCore *core) {
ut8 buf[256];
int i, len, d = cursor+1;
int delta = 0;
const ut8 *p, *q = NULL;
const char *keys = "{}[]()<>";
ut8 ch = core->block[cursor];
p = (const ut8*)strchr (keys, ch);
if (p) {
delta = (size_t)(p-(const ut8*)keys);
ch = (delta%2)? p[-1]: p[1];
}
len = 1;
buf[0] = ch;
if (p && (delta%2)) {
for (i = d-1; i>=0; i--) {
if (core->block[i] == ch) {
q = core->block + i;
break;
}
}
} else {
q = r_mem_mem (core->block+d, core->blocksize-d,
(const ut8*)buf, len);
if (!q) {
q = r_mem_mem (core->block, R_MIN (core->blocksize, d),
(const ut8*)buf, len);
}
}
if (q) {
cursor = (int)(size_t)(q-core->block);
ocursor = -1;
showcursor (core, true);
}
}
R_API char* r_str_replace(char *str, const char *key, const char *val, int g) {
int off, i, klen, vlen, slen;
char *newstr, *scnd, *p = str;
if (!str || !key || !val) {
return NULL;
}
klen = strlen (key);
vlen = strlen (val);
if (klen == vlen && !strcmp (key, val)) {
return str;
}
slen = strlen (str);
for (i = 0; i < slen; ) {
p = (char *)r_mem_mem (
(const ut8*)str + i, slen - i,
(const ut8*)key, klen);
if (!p) {
break;
}
off = (int)(size_t)(p-str);
scnd = strdup (p+klen);
slen += vlen - klen;
// HACK: this 32 avoids overwrites wtf
newstr = realloc (str, slen + klen + 1);
if (!newstr) {
eprintf ("realloc fail\n");
free (str);
free (scnd);
str = NULL;
break;
}
str = newstr;
p = str + off;
memcpy (p, val, vlen);
memcpy (p + vlen, scnd, strlen (scnd) + 1);
i = off + vlen;
free (scnd);
if (!g) {
break;
}
}
return str;
}
/* final entrypoint for adding stuff in the buffer screen */
R_API int r_cons_memcat(const char *str, int len) {
if (len < 0 || (I.buffer_len + len) < 0) {
return -1;
}
if (I.echo) {
write (2, str, len);
}
if (str && len > 0 && !I.null) {
if (palloc (len + 1)) {
memcpy (I.buffer + I.buffer_len, str, len);
I.buffer_len += len;
I.buffer[I.buffer_len] = 0;
}
}
if (I.flush) {
r_cons_flush ();
}
if (I.break_word && str) {
if (r_mem_mem ((const ut8*)str, len, (const ut8*)I.break_word, I.break_word_len)) {
I.breaked = true;
}
}
return len;
}
