static Jsonnode* parsearray(const char *str,const char **endp){
#define FAILRETURN \
do { \
for(int i=0;i<length;i++)json_free(elems[i]); \
free(elems); \
return NULL; \
} while(0)
SKIPSPACESRETNULL(str);
if(str[0]!='[')return NULL;
const char *cursor=str+1;
SKIPSPACES(cursor);
if(*cursor==']'){
Jsonnode *node=malloc(sizeof(Jsonnode));
assert(node);
node->type=JSON_ARRAY;
node->arrval.capacity=1;
node->arrval.length=0;
node->arrval.elems=malloc(1);
assert(node->arrval.elems);
*endp=cursor+1;
return node;
}
int sz=16,length=0;
Jsonnode **elems=malloc(sz*sizeof(Jsonnode*));
assert(elems);
//fprintf(stderr,"ARR: start\n");
while(*cursor){
const char *elemend;
Jsonnode *elem=json_parse_endp(cursor,&elemend);
//fprintf(stderr,"ARR: elem %p, parsing from %s\n",elem,cursor);
if(!elem)FAILRETURN;
if(length==sz){
sz*=2;
elems=realloc(elems,sz*sizeof(Jsonnode*));
assert(elems);
}
elems[length++]=elem;
cursor=elemend;
SKIPSPACES(cursor);
if(*cursor==']')break;
if(*cursor!=',')FAILRETURN;
cursor++;
}
if(*cursor!=']')return NULL;
Jsonnode *node=malloc(sizeof(Jsonnode));
assert(node);
node->type=JSON_ARRAY;
node->arrval.length=length;
node->arrval.capacity=sz;
node->arrval.elems=elems;
*endp=cursor+1;
return node;
#undef FAILRETURN
}
static int cmd_search(const char *arg) {
ut8 *buf, *barg;
size_t len;
int i, hit = 0;
SKIPSPACES(arg);
if(*arg=='"') {
arg++;
barg = (ut8*)strdup(arg);
len = strlen((const char *)barg)-1;
// TODO: ensure last char is '"'
barg[len]='\0';
} else {
barg = (ut8*)strdup(arg);
len = hexstr2raw(barg);
}
if((buf = getcurblk("", &bsize)))
do {
for(i=0;i<bsize;i++) {
if(barg[hit++]!=buf[i]) hit = 0;
else if(hit == len)
printf("0x%"LLF"x\n", curseek+i-len+1);
}
curseek += bsize;
} while(io_read(buf, bsize)>0);
free(buf);
free(barg);
return 1;
}
static int cmd_write(const char *arg) {
ut8 *barg;
int len;
SKIPSPACES(arg);
if(*arg=='"') {
barg = (ut8*)strdup (arg+1);
len = strlen(++arg)-1;
// TODO: ensure last char is "
barg[len] = '\0';
} else {
barg = (ut8*)strdup (arg);
len = hexstr2raw(barg);
}
if (len<2) {
printf ("Invalid hexpair\n");
return 2;
}
io_seek(curseek, SEEK_SET);
if(len<1 || io_write(barg, len)<len) {
perror("io_write");
return -1;
}
//free ((void*)arg);
return 1;
}
static int red_prompt() {
char *at, *at2, line[BUFSZ];
if(verbose) {
printf("[0x%08"LLF"x]> ", curseek);
fflush(stdout);
}
if(fgets(line, sizeof(line), stdin) == NULL)
return 0;
line[strlen(line)-1] = '\0';
if(*line != '!') {
at = strchr(line, '@');
oldseek = curseek;
obsize = bsize;
if(at) {
*at = 0;
at2 = strchr(++at, ':');
if(at2) {
*at2 = 0;
at2++;
if(*at2) bsize = (int)str2ut64(at2);
}
if(*at) curseek = str2ut64(at);
}
}
at = line;
SKIPSPACES(at);
return red_cmd(at);
}
int rarvm_assemble (Bitbuf *b, const char *c) {
char* arg0 = NULL;
char* arg1 = NULL;
int opnum;
char *p, *str = strdup (skipspaces (c));
p = strchr (str, ' ');
if (p) {
*p = 0;
arg0 = p+1;
SKIPSPACES (arg0);
arg1 = strchr (arg0, ',');
if (arg1)
*arg1++ = 0;
}
opnum = opcode_num (str);
if (opnum>=0 && opnum<=7) {
bitadd (b, 0, 1);
bitadd (b, opnum, 3);
} else
if (opnum>=8 && opnum<=39) {
bitadd (b, 1, 1);
bitadd (b, opnum+24, 5);
} else {
free (str);
fprintf (stderr, "Oops. unsupported opcode\n");
return 0;
}
if (1 && opcodes[opnum].flags & T_BYTE) {
bitadd (b, 0, 1);
}
if (opcodes[opnum].flags & 1) {
SKIPSPACES (arg0);
if (!assemble_arg (b, arg0)) {
free (str);
return 0;
}
if (opcodes[opnum].flags & 2) {
SKIPSPACES (arg1);
if (!assemble_arg (b, arg1))
return 0;
}
}
free (str);
return b->bits;
}
static int red_cmd(char *cmd) {
char *arg = cmd+1;
SKIPSPACES(arg);
switch(*cmd) {
case 'q':
return 0;
case ';':
case '#':
break; // comment
case '>':
return cmd_dump(arg);
break;
case '<':
return cmd_load(arg);
break;
case '.':
return red_interpret(arg);
break;
case 's':
return cmd_seek(arg);
break;
case 'b':
return cmd_bsize(arg);
break;
case '/':
return cmd_search(arg);
break;
case 'd':
return cmd_system ("echo X | ired -n $BLOCK | rasm2 -o $OFFSET -D - |head -n $(($LINES-1))");
case 'p':
return cmd_print(arg);
break;
case 'r':
return cmd_resize(arg);
break;
case 'x':
return cmd_hexdump(arg);
break;
case 'X':
return cmd_bytedump(arg);
break;
case 'w':
return cmd_write(arg);
break;
case '!':
return cmd_system(arg);
break;
case 'V':
return cmd_system("vired $FILE");
break;
case '?':
return cmd_help(arg);
break;
default:
fprintf(stderr, "? %s\n", cmd);
}
return 1;
}
static Jsonnode* json_parse_endp(const char *str,const char **endp){
Jsonnode *node;
node=parsenumber(str,endp); if(node){SKIPSPACES(*endp); return node;}
node=parsestring(str,endp); if(node){SKIPSPACES(*endp); return node;}
node=parsebool (str,endp); if(node){SKIPSPACES(*endp); return node;}
node=parsenull (str,endp); if(node){SKIPSPACES(*endp); return node;}
node=parsearray (str,endp); if(node){SKIPSPACES(*endp); return node;}
node=parseobject(str,endp); if(node){SKIPSPACES(*endp); return node;}
return NULL;
}
void stringrgb(const char* color,int *r,int *g,int *b)
{
char* end;
static int unloaded=0;
DEBUG_PRINT(DEBUG_COLOR,("\n COLOR SPEC:\t'%s' (",color));
SKIPSPACES(color);
if (strcmp(color,"Black")==0) {
*r = *g = *b = 0;
} else if (strcmp(color,"White")==0) {
*r = *g = *b = 255;
} else if (strncmp(color,"gray ",5)==0) {
color+=5;
*r = *g = *b = NEXTFLOAT255(color);
} else if (strncmp(color,"rgb ",4)==0) {
color+=4;
*r = NEXTFLOAT255(color);
*g = NEXTFLOAT255(color);
*b = NEXTFLOAT255(color);
} else if (strncmp(color,"Gray ",5)==0) {
color+=5;
*r = *g = *b = NEXTINT(color);
} else if (strncmp(color,"RGB ",4)==0) {
color+=4;
*r = NEXTINT(color);
*g = NEXTINT(color);
*b = NEXTINT(color);
} else if (strncmp(color,"HTML ",5)==0) {
color+=5;
*b = NEXTHEX(color);
*r = *b/65536;
*g = *b/256;
*b -= *g*256;
*g -= *r*256;
} else if (strncmp(color,"cmy ",4)==0
|| strncmp(color,"cmyk ",5)==0) {
int c,m,y,k;
color+=3;
k=(*color=='k');
if (k)
color++;
c = NEXTFLOAT255(color);
m = NEXTFLOAT255(color);
y = NEXTFLOAT255(color);
if (k)
k = NEXTFLOAT255(color);
*r = c+k<255 ? 255-(c+k) : 0;
*g = m+k<255 ? 255-(m+k) : 0;
*b = y+k<255 ? 255-(y+k) : 0;
} else if (strncmp(color,"hsb ",4)==0
|| strncmp(color,"HSB ",4)==0) {
/* The hsb and HSB models really need more presicion.
Use double and convert back*/
double hu,sa,br,f,R,G,B;
int i;
if (*color=='h') {
color+=4;
hu = NEXTFLOAT(color);
sa = NEXTFLOAT(color);
br = NEXTFLOAT(color);
} else {
color+=4;
hu = (float)NEXTINT(color); hu /= 255;
sa = (float)NEXTINT(color); sa /= 255;
br = (float)NEXTINT(color); br /= 255;
}
i=6*hu;
f=6*hu-i;
switch(i) {
case 0:
R = br*(1-sa*0); G = br*(1-sa*(1-f)); B = br*(1-sa*1); break;
case 1:
R = br*(1-sa*f); G = br*(1-sa*0); B = br*(1-sa*1); break;
case 2:
R = br*(1-sa*1); G = br*(1-sa*0); B = br*(1-sa*(1-f)); break;
case 3:
R = br*(1-sa*1); G = br*(1-sa*f); B = br*(1-sa*0); break;
case 4:
R = br*(1-sa*(1-f)); G = br*(1-sa*1); B = br*(1-sa*0); break;
case 5:
R = br*(1-sa*0); G = br*(1-sa*1); B = br*(1-sa*f); break;
default:
R = br*(1-sa*0); G = br*(1-sa*1); B = br*(1-sa*1);
}
*r=FTO255(R);
*g=FTO255(G);
*b=FTO255(B);
} else {
/* Model not found, probably a color name */
struct colorname *tmp;
if (xcp==NULL && xcpname!=NULL)
xcp=LoadXColorPrologue();
tmp=xcp;
while(tmp!=NULL && strcmp(color,tmp->name)!=0)
tmp=tmp->next;
if (tmp==NULL) {
while (colornamep==NULL && colordef[unloaded]!=NULL)
colornamep=LoadColornameFile(colordef[unloaded++]);
tmp=colornamep;
while(tmp!=NULL && strcmp(color,tmp->name)!=0) {
while (tmp->next==NULL && colordef[unloaded]!=NULL)
tmp->next=LoadColornameFile(colordef[unloaded++]);
tmp=tmp->next;
}
}
if (strcmp(color,tmp->name)==0) {
/* Found: one-level recursion */
DEBUG_PRINT(DEBUG_COLOR,("\n ---RECURSION--- "))
stringrgb(tmp->color,r,g,b);
} else {
/* Not found, warn */
page_flags |= PAGE_GAVE_WARN;
Warning("unimplemented color specification '%s'",color);
}
}
DEBUG_PRINT(DEBUG_COLOR,("%d %d %d) ",*r,*g,*b))
}
static Jsonnode* parseobject(const char *str,const char **endp){
SKIPSPACESRETNULL(str);
if(*str!='{')return NULL;
str++;
SKIPSPACESRETNULL(str);
if(*str=='}'){
Jsonnode *node=malloc(sizeof(Jsonnode));
assert(node);
node->type=JSON_OBJECT;
node->objval.capacity=1;
node->objval.numkeys=0;
node->objval.keys=malloc(1);
assert(node->objval.keys);
node->objval.values=malloc(1);
assert(node->objval.values);
*endp=str+1;
return node;
}
int sz=16,numkeys=0;
char **keys=malloc(sz*sizeof(char*));
assert(keys);
Jsonnode **values=malloc(sz*sizeof(Jsonnode*));
assert(values);
#define FAILRETURN \
do { \
for(int i=0;i<numkeys;i++)free(keys[i]); \
for(int i=0;i<numkeys;i++)json_free(values[i]); \
free(keys); free(values); \
return NULL; \
} while(0)
const char *cursor=str;
while(*cursor){
const char *keyend,*valend;
Jsonnode *keynode=parsestring(cursor,&keyend);
if(!keynode)FAILRETURN;
SKIPSPACES(keyend);
if(*keyend!=':'){
json_free(keynode);
FAILRETURN;
}
cursor=keyend+1;
SKIPSPACES(cursor);
Jsonnode *valnode=json_parse_endp(cursor,&valend);
if(!valnode){
json_free(keynode);
FAILRETURN;
}
if(numkeys==sz){
sz*=2;
keys=realloc(keys,sz*sizeof(char*));
assert(keys);
values=realloc(values,sz*sizeof(Jsonnode*));
assert(values);
}
keys[numkeys]=keynode->strval;
free(keynode);
values[numkeys]=valnode;
numkeys++;
cursor=valend;
SKIPSPACES(cursor);
if(*cursor=='}')break;
if(*cursor!=',')FAILRETURN;
cursor++;
}
if(*cursor!='}')return NULL;
Jsonnode *node=malloc(sizeof(Jsonnode));
assert(node);
node->type=JSON_OBJECT;
node->objval.numkeys=numkeys;
node->objval.capacity=sz;
node->objval.keys=keys;
node->objval.values=values;
*endp=cursor+1;
return node;
#undef FAILRETURN
}
