FAKE_API void fkpspushccharptr(fake * fk, const char * ret)
{
bool err = false;
variant * v = 0;
PS_PUSH_AND_GET(fk->ps, v);
V_SET_STRING(v, ret);
CHECK_ERR(err);
}
variant stringheap::allocsysstr(const char * str)
{
fake * fk = m_fk;
variant v;
V_SET_STRING(&v, str);
v.data.str->sysref++;
return v;
}
FAKE_API int fkgetfuncvariantnum(fake * fk, const char * func)
{
variant funcv;
V_SET_STRING(&funcv, func);
const funcunion * f = fk->fm.get_func(funcv);
if (f && f->havefb)
{
return f->fb.m_debug_stack_variant_info_num;
}
return 0;
}
FAKE_API int fkgetfuncstartline(fake * fk, const char * func)
{
variant funcv;
V_SET_STRING(&funcv, func);
const funcunion * f = fk->fm.get_func(funcv);
if (f && f->havefb)
{
return FUNC_BINARY_LINENO(f->fb, 0);
}
return 0;
}
FAKE_API const char * fkgetfuncfile(fake * fk, const char * func)
{
variant funcv;
V_SET_STRING(&funcv, func);
const funcunion * f = fk->fm.get_func(funcv);
if (f && f->havefb)
{
return FUNC_BINARY_FILENAME(f->fb);
}
return "";
}
FAKE_API int fkgetfuncvariantline(fake * fk, const char * func, int index)
{
variant funcv;
V_SET_STRING(&funcv, func);
const funcunion * f = fk->fm.get_func(funcv);
if (f && f->havefb && index >= 0 && index < f->fb.m_debug_stack_variant_info_num)
{
return f->fb.m_debug_stack_variant_info[index].line;
}
return 0;
}
// 调用函数
FAKE_API void fkrunps(fake * fk, const char * func)
{
FKLOG("fkrunps %p %s", fk, func);
fk->rn.rundeps++;
// 清空运行环境
fk->clearerr();
// 分配个
pool<processor>::node * n = 0;
if (UNLIKE(POOL_EMPTY(fk->pp)))
{
POOL_GROW(fk->pp, pool<processor>::node, n);
PROCESS_INI(n->t, fk);
}
POOL_POP(fk->pp, n);
assert(ARRAY_EMPTY(n->t.m_pl.l));
assert(n->t.m_routine_num == 0);
processor & pro = n->t;
PROCESS_CLEAR(pro);
variant funcv;
V_SET_STRING(&funcv, func);
routine * r = pro.start_routine(funcv, 0, 0);
PUSH_CUR_PROCESSOR(n, fk->rn);
// 单独执行，下次再跑run
if (UNLIKE(fk->rn.stepmod))
{
variant * ret = 0;
bool err = false;
PS_PUSH_AND_GET(fk->ps, ret);
*ret = NILV;
FKLOG("fkrunps %p %s yield", fk, func);
CHECK_ERR(err);
return;
}
pro.run();
POP_CUR_PROCESSOR(fk->rn);
variant * ret = 0;
bool err = false;
PS_PUSH_AND_GET(fk->ps, ret);
*ret = ROUTINE_GETRET(*r);
CHECK_ERR(err);
POOL_PUSH(fk->pp, n);
fk->rn.rundeps--;
FKLOG("fkrunps %p %s OK", fk, func);
}
variant * assembler_get_classmem_call(fake * fk, variant * classvar, variant * callpos)
{
bool err = false;
variant * n = fk->con.newvariant();
void * classptr = 0;
const char * classprefix = 0;
// prefix
V_GET_POINTER(classvar, classptr, classprefix);
if (UNLIKE(err))
{
return 0;
}
const char * funcname = 0;
V_GET_STRING(callpos, funcname);
if (UNLIKE(err))
{
return 0;
}
if (UNLIKE(!classptr))
{
err = true;
seterror(fk, efk_jit_error, fkgetcurfile(fk), fkgetcurline(fk), fkgetcurfunc(fk), "jit class mem call error, the class ptr is null, type %s", classprefix);
return 0;
}
// whole name
char wholename[MAX_FAKE_REG_FUNC_NAME_LEN];
if (UNLIKE(classvar->data.ponter->typesz + callpos->data.str->sz >= MAX_FAKE_REG_FUNC_NAME_LEN))
{
err = true;
seterror(fk, efk_jit_error, fkgetcurfile(fk), fkgetcurline(fk), fkgetcurfunc(fk), "jit class mem call error, the name is too long, func %s %s", classprefix, funcname);
return 0;
}
memcpy(wholename, classprefix, classvar->data.ponter->typesz);
memcpy(wholename + classvar->data.ponter->typesz, funcname, callpos->data.str->sz);
wholename[classvar->data.ponter->typesz + callpos->data.str->sz] = 0;
// call it
V_SET_STRING(n, wholename);
return n;
}
FAKE_API void fkrunpsjit(fake * fk, const char * func)
{
FKLOG("fkrun %p %s", fk, func);
#ifndef FK64
// 32位目前不支持
seterror(fk, efk_jit_error, fkgetcurfile(fk), fkgetcurline(fk), fkgetcurfunc(fk), "current platform not support jit");
return;
#endif
fk->rn.rundeps++;
fk->clearerr();
fk->mac.clear();
variant funcv;
V_SET_STRING(&funcv, func);
fk->mac.call(funcv);
fk->rn.rundeps--;
FKLOG("fkrun %p %s OK", fk, func);
}
void interpreter::set_running_vaiant(int frame, const char * name, int line, const char * value)
{
if (!m_fb)
{
return;
}
int deps = 0;
int ip = m_ip;
int bp = m_bp;
const func_binary * fb = m_fb;
while (!BP_END(bp))
{
if (deps >= frame)
{
for (int i = 0; i < fb->m_debug_stack_variant_info_num; i++)
{
const stack_variant_info & info = fb->m_debug_stack_variant_info[i];
if ((line != -1 && !strcmp(info.name, name) && info.line == line) ||
(line == -1 && !strcmp(info.name, name)))
{
fake * fk = m_fk;
variant * v = 0;
GET_STACK(bp, v, info.pos);
std::string valuestr = value;
if (valuestr.empty())
{
return;
}
if (valuestr[0] == '\"')
{
valuestr[valuestr.size() - 1] = 0;
V_SET_STRING(v, &valuestr[1]);
}
else
{
V_SET_REAL(v, atoi(value));
}
return;
}
}
break;
}
BP_GET_FB(bp, fb);
BP_GET_IP(bp, ip);
int callbp = 0;
BP_GET_BP(bp, callbp);
bp = callbp;
if (BP_END(bp))
{
break;
}
deps++;
}
}
FAKE_API bool fkisfunc(fake * fk, const char * func)
{
variant funcv;
V_SET_STRING(&funcv, func);
return fk->fm.get_func(funcv) != 0;
}
int interpreter::run(int cmdnum)
{
fake * fk = m_fk;
bool & err = m_isend;
int i = 0;
// 栈溢出检查
if (UNLIKE((int)ARRAY_MAX_SIZE(m_stack) > m_fk->cfg.stack_max))
{
m_isend = true;
seterror(fk, efk_run_inter_error, fkgetcurfile(fk), fkgetcurline(fk), fkgetcurfunc(fk), "stack too big %d", ARRAY_MAX_SIZE(m_stack));
return 0;
}
// 切换检查
if (UNLIKE(m_sleeping))
{
if (LIKE(m_yieldtime))
{
m_yieldtime--;
return 0;
}
else if (LIKE(fkgetmstick() < m_wakeuptime))
{
return 0;
}
else
{
m_wakeuptime = 0;
}
}
if (UNLIKE(m_isend))
{
return 0;
}
while (1)
{
// 当前函数走完
if (UNLIKE(m_ip >= (int)FUNC_BINARY_CMDSIZE(*m_fb)))
{
FKLOG("pop stack %s", FUNC_BINARY_NAME(*m_fb));
// 记录profile
if (UNLIKE(m_fk->pf.isopen()))
{
uint32_t calltime = 0;
BP_GET_CALLTIME(m_bp, calltime);
m_fk->pf.add_func_sample(FUNC_BINARY_NAME(*m_fb), fkgetmstick() - calltime);
}
// 标记
FUNC_BINARY_USE(*m_fb)--;
// 更新
if (UNLIKE(!FUNC_BINARY_USE(*m_fb) && FUNC_BINARY_BACKUP(*m_fb)))
{
FUNC_BINARY_BACKUP_MOVE(*m_fb);
}
// 出栈
int oldretnum = 0;
BP_GET_RETNUM(m_bp, oldretnum);
int callbp = 0;
BP_GET_BP(m_bp, callbp);
BP_GET_FB(m_bp, m_fb);
BP_GET_IP(m_bp, m_ip);
int oldbp = m_bp;
m_sp = m_bp - BP_SIZE - oldretnum;
m_bp = callbp;
// 所有都完
if (UNLIKE(BP_END(m_bp)))
{
FKLOG("stack empty end");
m_isend = true;
break;
}
// 塞返回值
else
{
for (int i = 0; i < oldretnum; i++)
{
int oldretpos = 0;
BP_GET_RETPOS(oldbp, oldretnum, oldretpos, i);
variant * ret;
GET_VARIANT(*m_fb, m_bp, ret, oldretpos);
*ret = m_ret[i];
}
}
continue;
}
int code = COMMAND_CODE(GET_CMD(*m_fb, m_ip));
FKLOG("next %d %d %s", COMMAND_TYPE(GET_CMD(*m_fb, m_ip)), code, OpCodeStr(code));
assert (COMMAND_TYPE(GET_CMD(*m_fb, m_ip)) == COMMAND_OPCODE);
m_ip++;
if (UNLIKE(m_fk->pf.isopen()))
{
m_fk->pf.add_code_sample(code);
}
// 执行对应命令，放一起switch效率更高，cpu有缓存
switch (code)
{
case OPCODE_ASSIGN:
{
// 赋值dest，必须为栈上或容器内
if (UNLIKE(!(CHECK_STACK_POS(*m_fb, m_ip) || CHECK_CONTAINER_POS(*m_fb, m_ip))))
{
err = true;
seterror(fk, efk_run_inter_error, fkgetcurfile(fk), fkgetcurline(fk), fkgetcurfunc(fk), "interpreter assign error, dest is not stack or container, type %s", POS_TYPE_NAME(*m_fb, m_ip));
break;
}
variant * varv = 0;
LOG_VARIANT(*m_fb, m_ip, "var");
GET_VARIANT(*m_fb, m_bp, varv, m_ip);
if (UNLIKE(CHECK_CONST_MAP_POS(varv) || CHECK_CONST_ARRAY_POS(varv)))
{
err = true;
seterror(fk, efk_run_inter_error, fkgetcurfile(fk), fkgetcurline(fk), fkgetcurfunc(fk), "interpreter assign error, dest is const container");
break;
}
m_ip++;
// 赋值来源
const variant * valuev = 0;
LOG_VARIANT(*m_fb, m_ip, "value");
GET_VARIANT(*m_fb, m_bp, valuev, m_ip);
m_ip++;
// 赋值
*varv = *valuev;
FKLOG("assign %s to %s", (vartostring(valuev)).c_str(), (vartostring(varv)).c_str());
}
break;
case OPCODE_PLUS:
{
MATH_OPER(*m_fb, m_bp, m_ip, PLUS);
}
break;
case OPCODE_MINUS:
{
MATH_OPER(*m_fb, m_bp, m_ip, MINUS);
}
break;
case OPCODE_MULTIPLY:
{
MATH_OPER(*m_fb, m_bp, m_ip, MULTIPLY);
}
break;
case OPCODE_DIVIDE:
{
MATH_OPER(*m_fb, m_bp, m_ip, DIVIDE);
}
break;
case OPCODE_DIVIDE_MOD:
{
MATH_OPER(*m_fb, m_bp, m_ip, DIVIDE_MOD);
}
break;
case OPCODE_STRING_CAT:
{
MATH_OPER(*m_fb, m_bp, m_ip, STRING_CAT);
}
break;
case OPCODE_AND:
{
MATH_OPER(*m_fb, m_bp, m_ip, AND);
}
break;
case OPCODE_OR:
{
MATH_OPER(*m_fb, m_bp, m_ip, OR);
}
break;
case OPCODE_LESS:
{
MATH_OPER(*m_fb, m_bp, m_ip, LESS);
}
break;
case OPCODE_MORE:
{
MATH_OPER(*m_fb, m_bp, m_ip, MORE);
}
break;
case OPCODE_EQUAL:
{
MATH_OPER(*m_fb, m_bp, m_ip, EQUAL);
}
break;
case OPCODE_MOREEQUAL:
{
MATH_OPER(*m_fb, m_bp, m_ip, MOREEQUAL);
}
break;
case OPCODE_LESSEQUAL:
{
MATH_OPER(*m_fb, m_bp, m_ip, LESSEQUAL);
}
break;
case OPCODE_NOTEQUAL:
{
MATH_OPER(*m_fb, m_bp, m_ip, NOTEQUAL);
}
break;
case OPCODE_NOT:
{
MATH_SINGLE_OPER(*m_fb, m_bp, m_ip, NOT);
}
break;
case OPCODE_AND_JNE:
{
MATH_OPER_JNE(*m_fb, m_bp, m_ip, AND_JNE);
}
break;
case OPCODE_OR_JNE:
{
MATH_OPER_JNE(*m_fb, m_bp, m_ip, OR_JNE);
}
break;
case OPCODE_LESS_JNE:
{
MATH_OPER_JNE(*m_fb, m_bp, m_ip, LESS_JNE);
}
break;
case OPCODE_MORE_JNE:
{
MATH_OPER_JNE(*m_fb, m_bp, m_ip, MORE_JNE);
}
break;
case OPCODE_EQUAL_JNE:
{
MATH_OPER_JNE(*m_fb, m_bp, m_ip, EQUAL_JNE);
}
break;
case OPCODE_MOREEQUAL_JNE:
{
MATH_OPER_JNE(*m_fb, m_bp, m_ip, MOREEQUAL_JNE);
}
break;
case OPCODE_LESSEQUAL_JNE:
{
MATH_OPER_JNE(*m_fb, m_bp, m_ip, LESSEQUAL_JNE);
}
break;
case OPCODE_NOTEQUAL_JNE:
{
MATH_OPER_JNE(*m_fb, m_bp, m_ip, NOTEQUAL_JNE);
}
break;
case OPCODE_NOT_JNE:
{
MATH_SINGLE_OPER_JNE(*m_fb, m_bp, m_ip, NOT_JNE);
}
break;
case OPCODE_JNE:
{
const variant * cmp = 0;
LOG_VARIANT(*m_fb, m_ip, "cmp");
GET_VARIANT(*m_fb, m_bp, cmp, m_ip);
m_ip++;
int ip = COMMAND_CODE(GET_CMD(*m_fb, m_ip));
m_ip++;
if (!(V_ISBOOL(cmp)))
{
FKLOG("jne %d", ip);
m_ip = ip;
}
else
{
FKLOG("not jne %d", ip);
}
}
break;
case OPCODE_JMP:
{
int ip = COMMAND_CODE(GET_CMD(*m_fb, m_ip));
m_ip++;
FKLOG("jmp %d", ip);
m_ip = ip;
}
break;
case OPCODE_PLUS_ASSIGN:
{
MATH_ASSIGN_OPER(*m_fb, m_bp, m_ip, PLUS);
}
break;
case OPCODE_MINUS_ASSIGN:
{
MATH_ASSIGN_OPER(*m_fb, m_bp, m_ip, MINUS);
}
break;
case OPCODE_MULTIPLY_ASSIGN:
{
MATH_ASSIGN_OPER(*m_fb, m_bp, m_ip, MULTIPLY);
}
break;
case OPCODE_DIVIDE_ASSIGN:
{
MATH_ASSIGN_OPER(*m_fb, m_bp, m_ip, DIVIDE);
}
break;
case OPCODE_DIVIDE_MOD_ASSIGN:
{
MATH_ASSIGN_OPER(*m_fb, m_bp, m_ip, DIVIDE_MOD);
}
break;
case OPCODE_CALL:
{
int calltype = COMMAND_CODE(GET_CMD(*m_fb, m_ip));
m_ip++;
const variant * callpos = 0;
LOG_VARIANT(*m_fb, m_ip, "callpos");
GET_VARIANT(*m_fb, m_bp, callpos, m_ip);
m_ip++;
int retnum = COMMAND_CODE(GET_CMD(*m_fb, m_ip));
m_ip++;
int retpos[MAX_FAKE_RETURN_NUM];
for (int i = 0; i < retnum; i++)
{
assert(CHECK_STACK_POS(*m_fb, m_ip) || CHECK_CONTAINER_POS(*m_fb, m_ip));
retpos[i] = m_ip;
m_ip++;
}
int argnum = COMMAND_CODE(GET_CMD(*m_fb, m_ip));
m_ip++;
paramstack & ps = *getps(m_fk);
PS_CLEAR(ps);
for (int i = 0; i < argnum; i++)
{
variant * arg = 0;
LOG_VARIANT(*m_fb, m_ip, "arg");
GET_VARIANT(*m_fb, m_bp, arg, m_ip);
m_ip++;
variant * argdest = 0;
PS_PUSH_AND_GET(ps, argdest);
*argdest = *arg;
}
if (LIKE(calltype == CALL_NORMAL))
{
call(*callpos, retnum, retpos);
}
else if (LIKE(calltype == CALL_CLASSMEM))
{
void * classptr = 0;
const char * classprefix = 0;
// prefix
variant * classvar;
PS_GET(ps, classvar, PS_SIZE(ps) - 1);
V_GET_POINTER(classvar, classptr, classprefix);
if (UNLIKE(err))
{
break;
}
// mem func name
const char * funcname = 0;
V_GET_STRING(callpos, funcname);
if (UNLIKE(err))
{
break;
}
if (UNLIKE(!classptr))
{
err = true;
seterror(fk, efk_run_inter_error, fkgetcurfile(fk), fkgetcurline(fk), fkgetcurfunc(fk), "interpreter class mem call error, the class ptr is null, type %s", classprefix);
break;
}
// whole name
char wholename[MAX_FAKE_REG_FUNC_NAME_LEN];
if (UNLIKE(classvar->data.ponter->typesz + callpos->data.str->sz >= MAX_FAKE_REG_FUNC_NAME_LEN))
{
err = true;
seterror(fk, efk_run_inter_error, fkgetcurfile(fk), fkgetcurline(fk), fkgetcurfunc(fk), "interpreter class mem call error, the name is too long, func %s %s", classprefix, funcname);
break;
}
memcpy(wholename, classprefix, classvar->data.ponter->typesz);
memcpy(wholename + classvar->data.ponter->typesz, funcname, callpos->data.str->sz);
wholename[classvar->data.ponter->typesz + callpos->data.str->sz] = 0;
// call it
variant tmp;
V_SET_STRING(&tmp, wholename);
call(tmp, retnum, retpos);
}
else
{
m_processor->start_routine(*callpos, retnum, retpos);
}
}
break;
case OPCODE_RETURN:
{
int returnnum = COMMAND_CODE(GET_CMD(*m_fb, m_ip));
if (UNLIKE(!returnnum))
{
FKLOG("return empty");
m_ip = (*m_fb).m_size;
break;
}
m_ip++;
// 塞给ret
for (int i = 0; i < returnnum; i++)
{
const variant * ret = 0;
LOG_VARIANT(*m_fb, m_ip, "ret");
GET_VARIANT(*m_fb, m_bp, ret, m_ip);
m_ip++;
m_ret[i] = *ret;
FKLOG("return %s", (vartostring(&m_ret[i])).c_str());
}
m_ip = (*m_fb).m_size;
}
break;
case OPCODE_SLEEP:
{
const variant * time = 0;
LOG_VARIANT(*m_fb, m_ip, "time");
GET_VARIANT(*m_fb, m_bp, time, m_ip);
m_ip++;
uint32_t sleeptime = 0;
V_GET_REAL(time, sleeptime);
m_wakeuptime = fkgetmstick() + sleeptime;
m_sleeping = true;
return i + 1;
}
break;
case OPCODE_YIELD:
{
const variant * time = 0;
LOG_VARIANT(*m_fb, m_ip, "time");
GET_VARIANT(*m_fb, m_bp, time, m_ip);
m_ip++;
V_GET_REAL(time, m_yieldtime);
m_sleeping = true;
return i + 1;
}
break;
default:
assert(0);
FKERR("next err code %d %s", code, OpCodeStr(code));
break;
}
if (UNLIKE(err))
{
// 发生错误
m_isend = true;
// 清除当前栈上函数的使用标记
{
int ip = m_ip;
int bp = m_bp;
const func_binary * fb = m_fb;
while (!BP_END(bp))
{
// 标记
FUNC_BINARY_USE(*fb)--;
// 更新
if (UNLIKE(!FUNC_BINARY_USE(*fb) && FUNC_BINARY_BACKUP(*fb)))
{
FUNC_BINARY_BACKUP_MOVE(*fb);
}
BP_GET_FB(bp, fb);
BP_GET_IP(bp, ip);
int callbp = 0;
BP_GET_BP(bp, callbp);
bp = callbp;
if (BP_END(bp))
{
break;
}
}
}
}
if (UNLIKE(m_isend))
{
break;
}
i++;
if (UNLIKE(i >= cmdnum))
{
break;
}
}
return i;
}