package fakescript;

import java.util.ArrayList;

class interpreter

{

public static final String MAP_FUNC_NAME = "map";

private fake m_f;

private boolean m_isend;

private ArrayList<variant> m_ret = new ArrayList<variant>();

private processor m_processor;

// [ret pos] .. [ret pos] [ret num] [old ip] [call time] [old fb] [old bp]

private static final int BP_SIZE = 5;

private int m_sp;

private int m_bp;

private int m_ip;

private func_binary m_fb;

private ArrayList<variant> m_stack = new ArrayList<variant>();

private long m_wakeuptime;

private int m_yieldtime;

private boolean m_sleeping;

public interpreter(fake f)

{

m_f = f;

}

public boolean is_end()

{

return m_isend;

}

public variant get_ret()

{

return m_ret.isEmpty() ? new variant() : m_ret.get(0);

}

public void set_processor(processor pro)

{

m_processor = pro;

}

public void call(variant func, ArrayList<Integer> retpos) throws Exception

{

funcunion f = m_f.fm.get_func(func);

if (f == null)

{

throw new Exception("run no func " + func + " fail");

}

if (f.m_havefb)

{

func_binary fb = f.m_fb;

variant v;

// 准备栈大小

int needsize = m_sp + BP_SIZE + retpos.size() + fb.m_maxstack;

if (needsize > m_stack.size())

{

int oldsize = m_stack.size();

for (int i = 0; i < needsize - oldsize; i++)

{

m_stack.add(new variant());

}

}

// 老的bp

int oldbp = m_bp;

m_bp = m_sp;

// 记录返回位置

for (int i = 0; i < retpos.size(); i++)

{

v = m_stack.get(m_bp);

v.m_type = variant_type.NIL;

v.m_data = retpos.get(i);

m_bp++;

}

// 记录返回值数目

v = m_stack.get(m_bp);

v.m_type = variant_type.NIL;

v.m_data = retpos.size();

m_bp++;

// 记录老的ip

v = m_stack.get(m_bp);

v.m_type = variant_type.NIL;

v.m_data = m_ip;

m_bp++;

// 记录profile

if (m_f.pf.isopen())

{

v = m_stack.get(m_bp);

v.m_data = System.currentTimeMillis();

}

v.m_type = variant_type.NIL;

m_bp++;

// 记录老的fb

v = m_stack.get(m_bp);

v.m_type = variant_type.NIL;

v.m_data = m_fb;

m_bp++;

// 记录老的bp

v = m_stack.get(m_bp);

v.m_type = variant_type.NIL;

v.m_data = oldbp;

m_bp++;

// 设置sp

m_sp = m_bp + fb.m_maxstack;

if (m_f.ps.size() != fb.m_paramnum)

{

m_isend = true;

throw new Exception(

"call func " + func + " param not match, need " + fb.m_paramnum + " give " + m_f.ps.size());

}

// 分配入参

for (int i = 0; i < fb.m_paramnum; i++)

{

v = m_stack.get(m_bp + i);

v.copy_from(m_f.ps.get(i));

}

m_f.ps.clear();

// 重置ret

if (m_ret.isEmpty())

{

m_ret.add(new variant());

}

else

{

m_ret.get(0).set_nil();

}

// 标记

fb.m_use++;

// 新函数

m_fb = fb;

m_ip = 0;

return;

}

// 记录profile

long s = 0;

if (m_f.pf.isopen())

{

s = System.currentTimeMillis();

}

// 绑定函数

if (f.m_haveff)

{

f.m_ff.call(m_f);

}

// 内置函数

else if (f.m_havebif)

{

f.m_bif.call(m_f, this);

}

else

{

m_isend = true;

throw new Exception("run no inter func " + func + " fail");

}

// 返回值

// 这种情况是直接跳过脚本调用了java函数

if (m_bp == 0)

{

variant cret = m_f.ps.pop_and_get();

m_isend = true;

// 直接塞返回值

if (m_ret.isEmpty())

{

m_ret.add(new variant());

}

m_ret.get(0).copy_from(cret);

}

// 否则塞到当前堆栈上

else

{

// 检查返回值数目对不对

if (m_f.ps.size() != retpos.size())

{

m_isend = true;

throw new Exception("native func " + func + " return num not match, give " + m_f.ps.size() + " need "

+ retpos.size());

}

// 塞返回值

for (int i = 0; i < retpos.size(); i++)

{

variant ret = GET_VARIANT(m_fb, m_bp, retpos.get(i));

variant cret = m_f.ps.get(i);

ret.copy_from(cret);

}

}

if (m_f.pf.isopen())

{

String name = func.get_string();

m_f.pf.add_func_sample(name, System.currentTimeMillis() - s);

}

}

public variant GET_VARIANT(func_binary fb, int bp, int pos) throws Exception

{

return GET_VARIANT_BY_CMD(fb, bp, fb.m_buff[pos]);

}

public variant GET_VARIANT_BY_CMD(func_binary fb, int bp, long cmd) throws Exception

{

long v_cmd = cmd;

int v_addrtype = command.ADDR_TYPE(command.COMMAND_CODE(v_cmd));

int v_addrpos = command.ADDR_POS(command.COMMAND_CODE(v_cmd));

if (v_addrtype == command.ADDR_STACK)

{

return m_stack.get(bp + v_addrpos);

}

else if (v_addrtype == command.ADDR_CONST)

{

return fb.m_const_list[v_addrpos];

}

else if (v_addrtype == command.ADDR_CONTAINER)

{

return get_container_variant(fb, v_addrpos);

}

else

{

throw new Exception("addrtype cannot be " + v_addrtype + " " + v_addrpos);

}

}

public variant get_container_variant(func_binary fb, int conpos) throws Exception

{

container_addr ca = fb.m_container_addr_list[conpos];

variant conv = GET_VARIANT_BY_CMD(fb, m_bp, ca.m_con);

variant keyv = GET_VARIANT_BY_CMD(fb, m_bp, ca.m_key);

if (m_isend)

{

return null;

}

if (conv.m_type != variant_type.ARRAY && conv.m_type != variant_type.MAP)

{

m_isend = true;

throw new Exception("interpreter get container variant fail, container type error, type " + conv.m_type);

}

if (conv.m_type == variant_type.MAP)

{

return conv.get_map().con_map_get(keyv);

}

else if (conv.m_type == variant_type.ARRAY)

{

return conv.get_array().con_array_get(keyv);

}

else

{

return null;

}

}

public long BP_GET_CALLTIME(int bp)

{

variant v = m_stack.get(bp - 3);

return (long) v.m_data;

}

public int BP_GET_RETNUM(int bp)

{

variant v = m_stack.get(bp - 5);

return (int) v.m_data;

}

public int BP_GET_BP(int bp)

{

variant v = m_stack.get(bp - 1);

return (int) v.m_data;

}

public func_binary BP_GET_FB(int bp)

{

variant v = m_stack.get(bp - 2);

return (func_binary) v.m_data;

}

public int BP_GET_IP(int bp)

{

variant v = m_stack.get(bp - 4);

return (int) v.m_data;

}

public int BP_GET_RETPOS(int bp, int retnum, int i)

{

variant v = m_stack.get(bp - 5 - retnum + i);

return (int) v.m_data;

}

public boolean CHECK_STACK_POS(func_binary fb, int ip)

{

return command.ADDR_TYPE(command.COMMAND_CODE(fb.m_buff[ip])) == command.ADDR_STACK;

}

public boolean CHECK_CONTAINER_POS(func_binary fb, int ip)

{

return command.ADDR_TYPE(command.COMMAND_CODE(fb.m_buff[ip])) == command.ADDR_CONTAINER;

}

public boolean CHECK_CONST_MAP_POS(variant v) throws Exception

{

return (v.m_type == variant_type.MAP && v.get_map().m_isconst);

}

public boolean CHECK_CONST_ARRAY_POS(variant v) throws Exception

{

return (v.m_type == variant_type.ARRAY && v.get_array().m_isconst);

}

public String POS_TYPE_NAME(func_binary fb, int ip)

{

int index = (int) command.ADDR_TYPE(command.COMMAND_CODE(fb.m_buff[ip]));

return variant_type.values()[index].name();

}

public int run(int cmdnum) throws Exception

{

int runcmdnum = 0;

// 栈溢出检查

if (m_stack.size() > m_f.cfg.stack_max)

{

m_isend = true;

throw new Exception("stack too big " + m_stack.size());

}

// 切换检查

if (m_sleeping)

{

if (m_yieldtime != 0)

{

m_yieldtime--;

return 0;

}

else if (System.currentTimeMillis() < m_wakeuptime)

{

return 0;

}

else

{

m_wakeuptime = 0;

}

}

if (m_isend)

{

return 0;

}

while (true)

{

try

{

// 当前函数走完

if (m_ip >= m_fb.m_buff.length)

{

// 记录profile

if (m_f.pf.isopen())

{

long calltime = BP_GET_CALLTIME(m_bp);

m_f.pf.add_func_sample(m_fb.m_name, System.currentTimeMillis() - calltime);

}

// 标记

m_fb.m_use--;

// 更新

if (m_fb.m_use == 0 && m_fb.m_backup != null)

{

m_fb.backup_move();

}

// 出栈

int oldretnum = BP_GET_RETNUM(m_bp);

int callbp = BP_GET_BP(m_bp);

m_fb = BP_GET_FB(m_bp);

m_ip = BP_GET_IP(m_bp);

int oldbp = m_bp;

m_sp = m_bp - BP_SIZE - oldretnum;

m_bp = callbp;

// 所有都完

if (m_bp == 0)

{

m_isend = true;

break;

}

// 塞返回值

else

{

for (int i = 0; i < oldretnum; i++)

{

int oldretpos = BP_GET_RETPOS(oldbp, oldretnum, i);

variant ret = GET_VARIANT(m_fb, m_bp, oldretpos);

ret.copy_from(m_ret.get(i));

}

}

continue;

}

int code = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

if (m_f.pf.isopen())

{

m_f.pf.add_code_sample(code);

}

// 执行对应命令，放一起switch效率更高，cpu有缓存

switch (code)

{

case command.OPCODE_ASSIGN:

{

// 赋值dest，必须为栈上或容器内

if (!(CHECK_STACK_POS(m_fb, m_ip) || CHECK_CONTAINER_POS(m_fb, m_ip)))

{

throw new Exception("interpreter assign error, dest is not stack or container, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant varv = GET_VARIANT(m_fb, m_bp, m_ip);

if ((CHECK_CONST_MAP_POS(varv) || CHECK_CONST_ARRAY_POS(varv)))

{

throw new Exception("interpreter assign error, dest is const container");

}

m_ip++;

// 赋值来源

variant valuev = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

// 赋值

varv.copy_from(valuev);

}

break;

case command.OPCODE_PLUS:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.plus(left, right);

}

break;

case command.OPCODE_MINUS:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.minus(left, right);

}

break;

case command.OPCODE_MULTIPLY:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.multiply(left, right);

}

break;

case command.OPCODE_DIVIDE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.divide(left, right);

}

break;

case command.OPCODE_DIVIDE_MOD:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.divide_mod(left, right);

}

break;

case command.OPCODE_STRING_CAT:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.string_cat(left, right);

}

break;

case command.OPCODE_AND:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.and(left, right);

}

break;

case command.OPCODE_OR:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.or(left, right);

}

break;

case command.OPCODE_LESS:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.less(left, right);

}

break;

case command.OPCODE_MORE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.more(left, right);

}

break;

case command.OPCODE_EQUAL:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.equal(left, right);

}

break;

case command.OPCODE_MOREEQUAL:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.more_equal(left, right);

}

break;

case command.OPCODE_LESSEQUAL:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.less_equal(left, right);

}

break;

case command.OPCODE_NOTEQUAL:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.not_equal(left, right);

}

break;

case command.OPCODE_NOT:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

;

if (!(CHECK_STACK_POS(m_fb, m_ip)))

{

throw new Exception("interpreter math oper error, dest is not stack, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant dest = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

dest.not(left);

}

break;

case command.OPCODE_AND_JNE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

/* dest */

m_ip++;

int destip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

boolean b = variant.and_jne(left, right);

if (!b)

{

m_ip = destip;

}

}

break;

case command.OPCODE_OR_JNE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

/* dest */

m_ip++;

int destip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

boolean b = variant.or_jne(left, right);

if (!b)

{

m_ip = destip;

}

}

break;

case command.OPCODE_LESS_JNE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

/* dest */

m_ip++;

int destip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

boolean b = variant.less_jne(left, right);

if (!b)

{

m_ip = destip;

}

}

break;

case command.OPCODE_MORE_JNE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

/* dest */

m_ip++;

int destip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

boolean b = variant.more_jne(left, right);

if (!b)

{

m_ip = destip;

}

}

break;

case command.OPCODE_EQUAL_JNE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

/* dest */

m_ip++;

int destip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

boolean b = variant.equal_jne(left, right);

if (!b)

{

m_ip = destip;

}

}

break;

case command.OPCODE_MOREEQUAL_JNE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

/* dest */

m_ip++;

int destip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

boolean b = variant.more_equal_jne(left, right);

if (!b)

{

m_ip = destip;

}

}

break;

case command.OPCODE_LESSEQUAL_JNE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

/* dest */

m_ip++;

int destip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

boolean b = variant.less_equal_jne(left, right);

if (!b)

{

m_ip = destip;

}

}

break;

case command.OPCODE_NOTEQUAL_JNE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

variant right = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

/* dest */

m_ip++;

int destip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

boolean b = variant.not_equal_jne(left, right);

if (!b)

{

m_ip = destip;

}

}

break;

case command.OPCODE_NOT_JNE:

{

variant left = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

/* dest */

m_ip++;

int destip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

boolean b = variant.not_jne(left);

if (!b)

{

m_ip = destip;

}

}

break;

case command.OPCODE_JNE:

{

variant cmp = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

int ip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

if (!cmp.bool())

{

m_ip = ip;

}

}

break;

case command.OPCODE_JMP:

{

int ip = command.COMMAND_CODE(m_fb.m_buff[m_ip]);

m_ip++;

m_ip = ip;

}

break;

case command.OPCODE_PLUS_ASSIGN:

{

if (!(CHECK_STACK_POS(m_fb, m_ip) || CHECK_CONTAINER_POS(m_fb, m_ip)))

{

throw new Exception(

"interpreter math assign oper error, dest is not stack or container, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant var = GET_VARIANT(m_fb, m_bp, m_ip);

if ((CHECK_CONST_MAP_POS(var) || CHECK_CONST_ARRAY_POS(var)))

{

throw new Exception("interpreter assign error, dest is const container");

}

m_ip++;

variant value = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

var.plus(var, value);

}

break;

case command.OPCODE_MINUS_ASSIGN:

{

if (!(CHECK_STACK_POS(m_fb, m_ip) || CHECK_CONTAINER_POS(m_fb, m_ip)))

{

throw new Exception(

"interpreter math assign oper error, dest is not stack or container, type "

+ POS_TYPE_NAME(m_fb, m_ip));

}

variant var = GET_VARIANT(m_fb, m_bp, m_ip);

if ((CHECK_CONST_MAP_POS(var) || CHECK_CONST_ARRAY_POS(var)))

{

throw new Exception("interpreter assign error, dest is const container");

}

m_ip++;

variant value = GET_VARIANT(m_fb, m_bp, m_ip);

m_ip++;

var.minus(var, value);

}

break;

case command.OPCODE_MULTIPLY_ASSIGN:

{

if (!(CHECK_STACK_POS(m_fb, m_ip) || CHECK_CONTAINER_POS(m_fb, m_ip)))

{

throw new Exception(

"interpreter math assign oper error, dest is not stack or container, type "