FAKE_API void fkpspushbool(fake * fk, bool ret)
{
bool err = false;
variant * v = 0;
PS_PUSH_AND_GET(fk->ps, v);
V_SET_REAL(v, ret);
CHECK_ERR(err);
}
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++;
}
}
bool compiler::compile_cmp_stmt(codegen & cg, cmp_stmt * cs)
{
FKLOG("[compiler] compile_cmp_stmt %p", cs);
int deps = m_cmp_deps;
m_cmp_deps++;
command oper = 0;
command left = 0;
command right = 0;
command dest = 0;
if (cs->cmp != "not")
{
// oper
if (cs->cmp == "&&")
{
oper = !deps ? MAKE_OPCODE(OPCODE_AND_JNE) : MAKE_OPCODE(OPCODE_AND);
}
else if (cs->cmp == "||")
{
oper = !deps ? MAKE_OPCODE(OPCODE_OR_JNE) : MAKE_OPCODE(OPCODE_OR);
}
else if (cs->cmp == "<")
{
oper = !deps ? MAKE_OPCODE(OPCODE_LESS_JNE) : MAKE_OPCODE(OPCODE_LESS);
}
else if (cs->cmp == ">")
{
oper = !deps ? MAKE_OPCODE(OPCODE_MORE_JNE) : MAKE_OPCODE(OPCODE_MORE);
}
else if (cs->cmp == "==")
{
oper = !deps ? MAKE_OPCODE(OPCODE_EQUAL_JNE) : MAKE_OPCODE(OPCODE_EQUAL);
}
else if (cs->cmp == ">=")
{
oper = !deps ? MAKE_OPCODE(OPCODE_MOREEQUAL_JNE) : MAKE_OPCODE(OPCODE_MOREEQUAL);
}
else if (cs->cmp == "<=")
{
oper = !deps ? MAKE_OPCODE(OPCODE_LESSEQUAL_JNE) : MAKE_OPCODE(OPCODE_LESSEQUAL);
}
else if (cs->cmp == "!=")
{
oper = !deps ? MAKE_OPCODE(OPCODE_NOTEQUAL_JNE) : MAKE_OPCODE(OPCODE_NOTEQUAL);
}
else if (cs->cmp == "true")
{
variant v;
V_SET_REAL((&v), 1);
int pos = cg.getconst(v);
m_cur_addr = MAKE_ADDR(ADDR_CONST, pos);
m_cmp_deps--;
m_cmp_jne = false;
return true;
}
else if (cs->cmp == "false")
{
variant v;
V_SET_REAL((&v), 0);
int pos = cg.getconst(v);
m_cur_addr = MAKE_ADDR(ADDR_CONST, pos);
m_cmp_deps--;
m_cmp_jne = false;
return true;
}
else if (cs->cmp == "is")
{
// left
if (!compile_node(cg, cs->left))
{
FKERR("[compiler] compile_cmp_stmt left fail");
return false;
}
m_cmp_deps--;
m_cmp_jne = false;
return true;
}
else
{
FKERR("[compiler] compile_cmp_stmt cmp error %s", cs->cmp.c_str());
compile_seterror(cs, m_fk, efk_compile_cmp_error, "cmp error %s", cs->cmp.c_str());
return false;
}
// left
if (!compile_node(cg, cs->left))
{
FKERR("[compiler] compile_cmp_stmt left fail");
return false;
}
left = m_cur_addr;
// right
if (!compile_node(cg, cs->right))
{
FKERR("[compiler] compile_cmp_stmt right fail");
return false;
}
right = m_cur_addr;
// result
int despos = cg.alloc_stack_identifier();
dest = MAKE_ADDR(ADDR_STACK, despos);
m_cur_addr = dest;
cg.push(oper, cs->lineno());
cg.push(left, cs->lineno());
cg.push(right, cs->lineno());
cg.push(dest, cs->lineno());
}
/* "not" */
else
{
oper = !deps ? MAKE_OPCODE(OPCODE_NOT_JNE) : MAKE_OPCODE(OPCODE_NOT);
// left
if (!compile_node(cg, cs->left))
{
FKERR("[compiler] compile_cmp_stmt left fail");
return false;
}
left = m_cur_addr;
int despos = cg.alloc_stack_identifier();
dest = MAKE_ADDR(ADDR_STACK, despos);
m_cur_addr = dest;
cg.push(oper, cs->lineno());
cg.push(left, cs->lineno());
cg.push(dest, cs->lineno());
}
m_cmp_deps--;
if (!deps)
{
m_cmp_jne = true;
}
FKLOG("[compiler] compile_cmp_stmt %p OK", cs);
return true;
}
bool compiler::compile_explicit_value_node_to_variant(explicit_value_node* ev, variant & v)
{
fake * fk = m_fk;
switch (ev->getvaluetype())
{
case explicit_value_node::EVT_TRUE:
V_SET_REAL((&v), 1);
break;
case explicit_value_node::EVT_FALSE:
V_SET_REAL((&v), 0);
break;
case explicit_value_node::EVT_NUM:
V_SET_REAL((&v), (fkatol(&ev->str)));
break;
case explicit_value_node::EVT_STR:
v = fk->sh.allocsysstr(ev->str.c_str());
break;
case explicit_value_node::EVT_FLOAT:
V_SET_REAL((&v), (fkatof(&ev->str)));
break;
case explicit_value_node::EVT_UUID:
V_SET_UUID((&v), (fkatol(&ev->str)));
break;
case explicit_value_node::EVT_MAP:
{
const_map_list_value_node * cml = dynamic_cast<const_map_list_value_node *>(ev->v);
assert(cml);
variant_map * vm = fk->con.newconstmap();
for (int i = 0; i < (int)cml->lists.size(); i++)
{
const_map_value_node * cmv = dynamic_cast<const_map_value_node *>(cml->lists[i]);
assert(cmv);
explicit_value_node * kn = dynamic_cast<explicit_value_node *>(cmv->k);
explicit_value_node * vn = dynamic_cast<explicit_value_node *>(cmv->v);
assert(kn);
assert(vn);
variant kv;
variant vv;
if (!compile_explicit_value_node_to_variant(kn, kv))
{
return false;
}
if (!compile_explicit_value_node_to_variant(vn, vv))
{
return false;
}
variant * des = con_map_get(fk, vm, &kv);
*des = vv;
}
V_SET_MAP(&v, vm);
}
break;
case explicit_value_node::EVT_ARRAY:
{
const_array_list_value_node * cal = dynamic_cast<const_array_list_value_node *>(ev->v);
assert(cal);
variant_array * va = fk->con.newconstarray();
for (int i = 0; i < (int)cal->lists.size(); i++)
{
explicit_value_node * vn = dynamic_cast<explicit_value_node *>(cal->lists[i]);
assert(vn);
variant kv;
V_SET_REAL((&kv), i);
variant vv;
if (!compile_explicit_value_node_to_variant(vn, vv))
{
return false;
}
variant * des = con_array_get(fk, va, &kv);
*des = vv;
}
V_SET_ARRAY(&v, va);
}
break;
default:
FKERR("[compiler] compile_explicit_value type error %d %s", ev->getvaluetype(), ev->gettypename());
compile_seterror(ev, m_fk, efk_compile_explicit_type_error, "compile explicit value type error %d", ev->getvaluetype());
return false;
}
return true;
}
