eval.cc

功能较全面的反汇编器：反汇编器ht-2.0.15.tar.gz

		case '*': r = a*b; break;
		case '/': {
		    if (!b) {
			    set_eval_error("division by zero");
			    return 0;
		    }
		    r = a/b;
		    break;
		}			    
		case '+': r = a+b; break;
		case '-': r = a-b; break;
		case EVAL_POW: r = pow(a,b); break;
		default: {
			uint64 ri;
			switch (op) {
				case EVAL_EQ: ri = a==b; break;
				case EVAL_NE: ri = a!=b; break;
				case EVAL_GT: ri = a>b; break;
				case EVAL_GE: ri = a>=b; break;
				case EVAL_LT: ri = a<b; break;
				case EVAL_LE: ri = a<=b; break;
				case EVAL_LAND: ri = a && b; break;
				case EVAL_LXOR: ri = !a != !b; break;
				case EVAL_LOR: ri = a || b ; break;
				default:
					set_eval_error("invalid operator");
					return 0;
			}
			xr->type = SCALAR_INT;
			xr->scalar.integer.value = ri;
			xr->scalar.integer.type = TYPE_UNKNOWN;
			return 1;
		}
	}
	xr->type = SCALAR_FLOAT;
	xr->scalar.floatnum.value = r;
	return 1;
}

int scalar_int_op(eval_scalar *xr, const eval_scalar *xa, const eval_scalar *xb, int op)
{
	eval_int ai, bi;
	uint64 a, b, r;
	scalar_context_int(xa, &ai);
	scalar_context_int(xb, &bi);

	a = ai.value;
	b = bi.value;
	switch (op) {
		case '*': r = a*b; break;
		case '/': {
		    if (!b) {
			    set_eval_error("division by zero");
			    return 0;
		    }
		    r = a/b;
		    break;
		}			    
		case '%': {
		    if (!b) {
			    set_eval_error("division by zero");
			    return 0;
		    }
		    r = a%b;
		    break;
		}			    
		case '+': r=a+b; break;
		case '-': r=a-b; break;
		case '&': r=a&b; break;
		case '|': r=a|b; break;
		case '^': r=a^b; break;
		// FIXME
		case EVAL_POW: r = ipow(a, b); break;
//		case EVAL_POW: r = to_qword((int)pow(QWORD_GET_INT(a),QWORD_GET_INT(b))); break;
		case EVAL_SHL: r = a << b; break;
		case EVAL_SHR: r = a >> b; break;
		case EVAL_EQ: r = a==b; break;
		case EVAL_NE: r = a!=b; break;
		case EVAL_GT: r = a>b; break;
		case EVAL_GE: r = a>=b; break;
		case EVAL_LT: r = a<b; break;
		case EVAL_LE: r = a<=b; break;
		case EVAL_LAND: r = a && b; break;
		case EVAL_LXOR: r = !a != !b; break;
		case EVAL_LOR: r = a || b; break;
		default: 
			set_eval_error("invalid operator");
			return 0;
	}
	xr->type = SCALAR_INT;
	xr->scalar.integer.value = r;
	xr->scalar.integer.type = TYPE_UNKNOWN;
	return 1;
}

int scalar_op(eval_scalar *xr, eval_scalar *xa, eval_scalar *xb, int op)
{
	int r;
	if ((xa->type==SCALAR_FLOAT) || (xb->type==SCALAR_FLOAT)) {
		r=scalar_float_op(xr, xa, xb, op);
	} else {
		r=scalar_int_op(xr, xa, xb, op);
	}
	scalar_destroy(xa);
	scalar_destroy(xb);
	return r;
}
	
void scalar_negset(eval_scalar *xr, eval_scalar *xa)
{
	if (xa->type==SCALAR_FLOAT) {
		eval_float a;
		a=xa->scalar.floatnum;
	
		xr->type=SCALAR_FLOAT;
		xr->scalar.floatnum.value=-a.value;
	} else {
		eval_int a;
		scalar_context_int(xa, &a);
	
		xr->type=SCALAR_INT;
		xr->scalar.integer.value=-a.value;
		xr->scalar.integer.type=TYPE_UNKNOWN;
	}
	scalar_destroy(xa);
}

void scalar_notset(eval_scalar *xr, eval_scalar *xa)
{
	eval_int a;
	scalar_context_int(xa, &a);

	xr->type=SCALAR_INT;
	xr->scalar.integer.value=~a.value;
	xr->scalar.integer.type=TYPE_UNKNOWN;

	scalar_destroy(xa);
}

void scalar_lnotset(eval_scalar *xr, eval_scalar *xa)
{
	eval_int a;
	scalar_context_int(xa, &a);

	xr->type = SCALAR_INT;
	xr->scalar.integer.value = !a.value;
	xr->scalar.integer.type = TYPE_UNKNOWN;

	scalar_destroy(xa);
}

void scalar_miniif(eval_scalar *xr, eval_scalar *xa, eval_scalar *xb, eval_scalar *xc)
{
	eval_int a;
	scalar_context_int(xa, &a);
	if (a.value != 0) {
		*xr = *xb;
	} else {
		*xr = *xc;
	}
	scalar_destroy(xa);
}

/*
 *	BUILTIN FUNCTIONS
 */

int func_typeof(eval_scalar *r, eval_scalar *s)
{
	switch (s->type) {
		case SCALAR_INT:
			scalar_create_str_c(r, "int");
			break;
		case SCALAR_STR:
			scalar_create_str_c(r, "string");
			break;
		case SCALAR_FLOAT:
			scalar_create_str_c(r, "float");
			break;
		default:
// FIXME: should never happen
			scalar_create_str_c(r, "unknown");
			break;
	}
	return 1;
}

int func_is_int(eval_scalar *r, eval_scalar *s)
{
	if (s->type == SCALAR_INT) {
		scalar_create_int_c(r, 1);
	} else {
		scalar_create_int_c(r, 0);
	}
	return 1;
}

int func_is_string(eval_scalar *r, eval_scalar *s)
{
	if (s->type == SCALAR_STR) {
		scalar_create_int_c(r, 1);
	} else {
		scalar_create_int_c(r, 0);
	}
	return 1;
}

int func_is_float(eval_scalar *r, eval_scalar *s)
{
	if (s->type == SCALAR_FLOAT) {
		scalar_create_int_c(r, 1);
	} else {
		scalar_create_int_c(r, 0);
	}
	return 1;
}

int func_char(eval_scalar *r, eval_int *i)
{
	eval_str s;
	char c = i->value;
	s.value = &c;
	s.len = 1;
	scalar_create_str(r, &s);
	return 1;
}

int func_byte(eval_scalar *r, eval_int *i)
{
	uint c = i->value;
	scalar_create_int_c(r, c & 0xff);
	return 1;
}

int func_word(eval_scalar *r, eval_int *i)
{
	uint c = i->value;
	scalar_create_int_c(r, c & 0xffff);
	return 1;
}

int func_dword(eval_scalar *r, eval_int *i)
{
	uint c = i->value;
	scalar_create_int_q(r, c & 0xffffffff);
	return 1;
}

int func_sbyte(eval_scalar *r, eval_int *i)
{
	uint c = i->value;
	scalar_create_int_c(r, (signed char)c);
	return 1;
}

int func_short(eval_scalar *r, eval_int *i)
{
	uint c = i->value;
	scalar_create_int_c(r, (short)c);
	return 1;
}

int func_long(eval_scalar *r, eval_int *i)
{
	int c = i->value;
	scalar_create_int_c(r, c);
	return 1;
}

int func_float(eval_scalar *r, eval_float *p)
{
	scalar_create_float(r, p);
	return 1;
}

int func_fmax(eval_scalar *r, eval_float *p1, eval_float *p2)
{
	r->type=SCALAR_FLOAT;
	r->scalar.floatnum.value=(p1->value>p2->value) ? p1->value : p2->value;
	return 1;
}

int func_fmin(eval_scalar *r, eval_float *p1, eval_float *p2)
{
	r->type=SCALAR_FLOAT;
	r->scalar.floatnum.value=(p1->value<p2->value) ? p1->value : p2->value;
	return 1;
}

int func_int(eval_scalar *r, eval_int *p)
{
	scalar_create_int(r, p);
	return 1;
}

int func_ord(eval_scalar *r, eval_str *s)
{
	if (s->len>=1) {
		scalar_create_int_c(r, s->value[0]);
		return 1;
	}
	set_eval_error("string must at least contain one character");
	return 0;		
}

int func_max(eval_scalar *r, eval_int *p1, eval_int *p2)
{
	scalar_create_int(r, (p1->value>p2->value) ? p1 : p2);
	return 1;
}

int func_min(eval_scalar *r, eval_int *p1, eval_int *p2)
{
	scalar_create_int(r, (p1->value<p2->value) ? p1 : p2);
	return 1;
}

int func_random(eval_scalar *r, eval_int *p1)
{
	uint64 d = rand();
	scalar_create_int_q(r, (p1->value != 0) ? (d % p1->value):0);
	return 1;
}

int func_rnd(eval_scalar *r)
{
	scalar_create_int_c(r, rand() % 2);
	return 1;
}

int func_round(eval_scalar *r, eval_float *p)
{
	r->type=SCALAR_INT;
	r->scalar.integer.value=f2i(p->value+0.5);
	r->scalar.integer.type=TYPE_UNKNOWN;
	return 1;
}

int func_strchr(eval_scalar *r, eval_str *p1, eval_str *p2)
{
	if (p2->len) {
		if (p1->len) {
			char *pos = (char *)memchr(p1->value, *p2->value, p1->len);
			if (pos) {
				scalar_create_int_c(r, pos-p1->value);
			} else {
				scalar_create_int_c(r, -1);
			}
		} else {
			scalar_create_int_c(r, -1);
		}
		return 1;
	} else {
		return 0;
	}
}

int func_strcmp(eval_scalar *r, eval_str *p1, eval_str *p2)
{
	int r2=memcmp(p1->value, p2->value, MIN(p1->len, p2->len));
	if (r2) {
		scalar_create_int_c(r, r2);
	} else {
		if (p1->len > p2->len) {
			scalar_create_int_c(r, 1);
		} else if (p1->len < p2->len) {
			scalar_create_int_c(r, -1);
		} else {
			scalar_create_int_c(r, 0);
		}
	}
	return 1;     
}

int func_string(eval_scalar *r, eval_str *p)
{
	scalar_create_str(r, p);
	return 1;
}

int func_strlen(eval_scalar *r, eval_str *p1)
{
	scalar_create_int_c(r, p1->len);
	return 1;
}

int func_strncmp(eval_scalar *r, eval_str *p1, eval_str *p2, eval_int *p3)
{
	return 1;
}

int func_strrchr(eval_scalar *r, eval_str *p1, eval_str *p2)
{
	return 1;
}

int func_strstr(eval_scalar *r, eval_str *p1, eval_str *p2)
{

	return 1;
}

int func_substr(eval_scalar *r, eval_str *p1, eval_int *p2, eval_int *p3)
{
	if (p2->value >= 0 && p3->value > 0) {
		if (p2->value < p1->len) {
			eval_str s;
			s.len = MIN(p3->value, p1->len - p2->value);
			s.value = &p1->value[p2->value];
			scalar_create_str(r, &s);
		} else {
			scalar_create_str_c(r, "");
		}
	} else {
		scalar_create_str_c(r, "");
	}
	return 1;
}

int func_trunc(eval_scalar *r, eval_float *p)
{
	r->type=SCALAR_INT;
	r->scalar.integer.value=f2i(p->value);
	r->scalar.integer.type=TYPE_UNKNOWN;
	return 1;
}

#define EVALFUNC_FMATH1(name) int func_##name(eval_scalar *r, eval_float *p)\
{\
	r->type=SCALAR_FLOAT;\
	r->scalar.floatnum.value=name(p->value);\
	return 1;\
}

#define EVALFUNC_FMATH1i(name) int func_##name(eval_scalar *r, eval_float *p)\
{\
	r->type=SCALAR_INT;\
	r->scalar.integer.value=f2i(name(p->value));\
	r->scalar.integer.type=TYPE_UNKNOWN;\
	return 1;\
}

#define EVALFUNC_FMATH2(name) int func_##name(eval_scalar *r, eval_float *p1, eval_float *p2)\
{\
	r->type=SCALAR_FLOAT;\
	r->scalar.floatnum.value=name(p1->value, p2->value);\
	return 1;\
}

EVALFUNC_FMATH2(pow)

EVALFUNC_FMATH1(sqrt)

EVALFUNC_FMATH1(exp)
EVALFUNC_FMATH1(log)

EVALFUNC_FMATH1i(ceil)
EVALFUNC_FMATH1i(floor)

EVALFUNC_FMATH1(sin)
EVALFUNC_FMATH1(cos)
EVALFUNC_FMATH1(tan)

EVALFUNC_FMATH1(asin)
EVALFUNC_FMATH1(acos)
EVALFUNC_FMATH1(atan)

EVALFUNC_FMATH1(sinh)
EVALFUNC_FMATH1(cosh)
EVALFUNC_FMATH1(tanh)

#ifdef HAVE_ASINH
EVALFUNC_FMATH1(asinh)
#endif

#ifdef HAVE_ACOSH
EVALFUNC_FMATH1(acosh)
#endif

#ifdef HAVE_ATANH
EVALFUNC_FMATH1(atanh)
#endif

void sprintf_puts(char **b, char *blimit, const char *buf)
{
	while (*b < blimit && *buf) {
		**b = *(buf++);
		(*b)++;
	}
}

int sprintf_percent(char **fmt, int *fmtl, char **b, char *blimit, eval_scalar *s)
{
	char cfmt[32];
	char buf[512];
	int ci=1;
	cfmt[0]='%';
	while (*fmtl && ci < 32-1) {
		cfmt[ci]=(*fmt)[0];
		cfmt[ci+1]=0;
		switch ((*fmt)[0]) {
			case 'd':
			case 'i':
			case 'o':
			case 'u':
			case 'x':
			case 'X':
			case 'c': {
				eval_int i;
				scalar_context_int(s, &i);
				
				ht_snprintf(buf, sizeof buf, cfmt, i.value);
				sprintf_puts(b, blimit, buf);
				
				return 1;
			}
			case 's': {
				char *q=cfmt+1;
				eval_str t;
				scalar_context_str(s, &t);
				
				while (*q!='s') {
					if ((*q>='0') && (*q<='9')) {
						unsigned int sl=strtol(q, NULL, 10);
						if (sl>sizeof buf-1) sl=sizeof buf-1;
						sprintf(q, "%ds", sl);
						break;