void dDAGExpressionNodeAssigment::CompileCIL(dCIL& cil)
{
m_expression->CompileCIL(cil);
if (m_leftVariable->m_dimExpressions.GetCount()) {
dDAGDimensionNode* const dim = m_leftVariable->m_dimExpressions.GetFirst()->GetInfo();
dim->CompileCIL(cil);
dString result = dim->m_result.m_label;
for (dList<dDAGDimensionNode*>::dListNode* node = m_leftVariable->m_dimExpressions.GetFirst()->GetNext(); node; node = node->GetNext()) {
dAssert (0);
dDAGDimensionNode* const dim = node->GetInfo();
dim->CompileCIL(cil);
#if 0
dCILInstr& stmtMul = cil.NewStatement()->GetInfo();
stmtMul.m_instruction = dCILInstr::m_assigment;
stmtMul.m_operator = dCILInstr::m_mul;
stmtMul.m_arg0.m_label = cil.NewTemp();
stmtMul.m_arg1.m_label = result;
stmtMul.m_arg2.m_label = dim->m_arraySize;
DTRACE_INTRUCTION (&stmtMul);
dCILInstr& stmtAdd = cil.NewStatement()->GetInfo();
stmtAdd.m_instruction = dCILInstr::m_assigment;
stmtAdd.m_operator = dCILInstr::m_add;
stmtAdd.m_arg0.m_label = cil.NewTemp();
stmtAdd.m_arg1.m_label = stmtMul.m_arg0.m_label;
stmtAdd.m_arg2 = dim->m_result;
result = stmtAdd.m_arg0.m_label;
DTRACE_INTRUCTION (&stmtAdd);
#endif
}
dAssert (m_leftVariable->m_parent);
dTree<dCILInstr::dArg, dString>::dTreeNode* const variable = dDAG::FindLocalVariable(m_leftVariable->m_name);
dAssert (variable);
dCILInstr::dArg arg0 (LoadLocalVariable(cil, m_expression->m_result));
dCILInstr::dArg arg1 (LoadLocalVariable(cil, variable->GetInfo()));
int size = arg0.GetSizeInByte();
dCILInstrIntergerLogical* const mulOffset = new dCILInstrIntergerLogical(cil, dCILThreeArgInstr::m_mul,cil.NewTemp(), dCILInstr::dArgType(dCILInstr::m_int), result, dCILInstr::dArgType(dCILInstr::m_int), dString(size), dCILInstr::m_constInt);
mulOffset->Trace();
dCILInstrIntergerLogical* const address = new dCILInstrIntergerLogical(cil, dCILThreeArgInstr::m_add, cil.NewTemp(), arg1.GetType(), arg1.m_label, arg1.GetType(), mulOffset->GetArg0().m_label, mulOffset->GetArg0().GetType());
address->Trace();
dCILInstrStore* const store = new dCILInstrStore(cil, address->GetArg0().m_label, address->GetArg0().GetType(), arg0.m_label, arg0.GetType());
store->Trace();
m_result = arg0;
} else {
m_leftVariable->CompileCIL(cil);
dCILInstr::dArg arg1 (LoadLocalVariable(cil, m_expression->m_result));
dCILInstrMove* const move = new dCILInstrMove (cil, m_leftVariable->m_result.m_label, m_leftVariable->m_result.GetType(), arg1.m_label, arg1.GetType());
move->Trace();
}
}
WfRuntimeExecutionAction WfRuntimeThreadContext::ExecuteInternal(WfInstruction& ins, WfRuntimeStackFrame& stackFrame, IWfDebuggerCallback* callback)
{
switch (ins.code)
{
case WfInsCode::LoadValue:
PushValue(ins.valueParameter);
return WfRuntimeExecutionAction::ExecuteInstruction;
case WfInsCode::LoadClosure:
{
Ptr<WfRuntimeVariableContext> capturedVariables;
if (ins.countParameter > 0)
{
capturedVariables = new WfRuntimeVariableContext;
capturedVariables->variables.Resize(ins.countParameter);
Value operand;
for (vint i = 0; i < ins.countParameter; i++)
{
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
capturedVariables->variables[ins.countParameter - 1 - i] = operand;
}
}
auto lambda = MakePtr<WfRuntimeLambda>(globalContext, capturedVariables, ins.indexParameter);
PushValue(Value::From(lambda));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::LoadException:
{
PushValue(BoxValue(exceptionInfo));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::LoadLocalVar:
{
Value operand;
CONTEXT_ACTION(LoadLocalVariable(ins.indexParameter, operand), L"illegal local variable index.");
PushValue(operand);
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::LoadCapturedVar:
{
Value operand;
CONTEXT_ACTION(LoadCapturedVariable(ins.indexParameter, operand), L"illegal captured variable index.");
PushValue(operand);
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::LoadGlobalVar:
{
CALL_DEBUGGER(callback->BreakRead(globalContext->assembly.Obj(), ins.indexParameter));
Value operand;
CONTEXT_ACTION(LoadGlobalVariable(ins.indexParameter, operand), L"illegal global variable index.");
PushValue(operand);
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::StoreLocalVar:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
CONTEXT_ACTION(StoreLocalVariable(ins.indexParameter, operand), L"illegal local variable index.");
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::StoreGlobalVar:
{
CALL_DEBUGGER(callback->BreakWrite(globalContext->assembly.Obj(), ins.indexParameter));
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
CONTEXT_ACTION(StoreGlobalVariable(ins.indexParameter, operand), L"illegal global variable index.");
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::Duplicate:
{
vint index = stack.Count() - 1 - ins.countParameter;
Value operand;
CONTEXT_ACTION(LoadStackValue(index, operand), L"failed to duplicate a value from the stack.");
PushValue(operand);
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::Pop:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::Return:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop the function result.");
CONTEXT_ACTION(PopStackFrame(), L"failed to pop the stack frame.");
PushValue(operand);
if (stackFrames.Count() == 0)
{
status = WfRuntimeExecutionStatus::Finished;
}
return WfRuntimeExecutionAction::ExitStackFrame;
}
case WfInsCode::CreateArray:
{
auto list = IValueList::Create();
Value operand;
for (vint i = 0; i < ins.countParameter; i++)
{
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
list->Add(operand);
}
PushValue(Value::From(list));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::CreateMap:
{
auto map = IValueDictionary::Create();
Value key, value;
for (vint i = 0; i < ins.countParameter; i+=2)
{
CONTEXT_ACTION(PopValue(value), L"failed to pop a value from the stack.");
CONTEXT_ACTION(PopValue(key), L"failed to pop a value from the stack.");
map->Set(key, value);
}
PushValue(Value::From(map));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::CreateInterface:
{
auto proxy = MakePtr<WfRuntimeInterfaceInstance>();
Value key, value;
for (vint i = 0; i < ins.countParameter; i+=2)
{
CONTEXT_ACTION(PopValue(value), L"failed to pop a value from the stack.");
CONTEXT_ACTION(PopValue(key), L"failed to pop a value from the stack.");
auto name = UnboxValue<WString>(key);
auto func = UnboxValue<Ptr<IValueFunctionProxy>>(value);
proxy->functions.Add(name, func);
}
PushValue(Value::From(proxy));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::CreateRange:
BEGIN_TYPE
EXECUTE(OpCreateRange, I1)
EXECUTE(OpCreateRange, I2)
EXECUTE(OpCreateRange, I4)
EXECUTE(OpCreateRange, I8)
EXECUTE(OpCreateRange, U1)
EXECUTE(OpCreateRange, U2)
EXECUTE(OpCreateRange, U4)
EXECUTE(OpCreateRange, U8)
END_TYPE
case WfInsCode::ReverseEnumerable:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
Value reversedEnumerable = OPERATOR_OpReverseEnumerable(operand);
PushValue(reversedEnumerable);
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::DeleteRawPtr:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
operand.DeleteRawPtr();
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::ConvertToType:
{
Value result, converted;
CONTEXT_ACTION(PopValue(result), L"failed to pop a value from the stack.");
if (OPERATOR_OpConvertToType(result, converted, ins))
{
PushValue(converted);
return WfRuntimeExecutionAction::ExecuteInstruction;
}
else
{
WString from = result.IsNull() ? L"<null>" : L"<" + result.GetText() + L"> of " + result.GetTypeDescriptor()->GetTypeName();
WString to = ins.typeDescriptorParameter->GetTypeName();
RaiseException(L"Failed to convert from \"" + from + L"\" to \"" + to + L"\".", false);
return WfRuntimeExecutionAction::Nop;
}
}
case WfInsCode::TryConvertToType:
{
Value result, converted;
CONTEXT_ACTION(PopValue(result), L"failed to pop a value from the stack.");
if (OPERATOR_OpConvertToType(result, converted, ins))
{
PushValue(converted);
}
else
{
PushValue(Value());
}
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::TestType:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
if (operand.GetTypeDescriptor() && operand.GetValueType() == ins.flagParameter && operand.GetTypeDescriptor()->CanConvertTo(ins.typeDescriptorParameter))
{
PushValue(BoxValue(true));
}
else
{
PushValue(BoxValue(false));
}
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::GetType:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
PushValue(Value::From(operand.GetTypeDescriptor()));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::Jump:
{
stackFrame.nextInstructionIndex = ins.indexParameter;
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::JumpIf:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
if (UnboxValue<bool>(operand))
{
stackFrame.nextInstructionIndex = ins.indexParameter;
}
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::Invoke:
{
CONTEXT_ACTION(PushStackFrame(ins.indexParameter, ins.countParameter), L"failed to invoke a function.");
return WfRuntimeExecutionAction::EnterStackFrame;
}
case WfInsCode::GetProperty:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
CALL_DEBUGGER(callback->BreakGet(operand.GetRawPtr(), ins.propertyParameter));
Value result = ins.propertyParameter->GetValue(operand);
PushValue(result);
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::SetProperty:
{
Value operand, value;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
CONTEXT_ACTION(PopValue(value), L"failed to pop a value from the stack.");
CALL_DEBUGGER(callback->BreakSet(operand.GetRawPtr(), ins.propertyParameter));
ins.propertyParameter->SetValue(operand, value);
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::InvokeProxy:
{
Value thisValue;
CONTEXT_ACTION(PopValue(thisValue), L"failed to pop a value from the stack.");
auto proxy = UnboxValue<Ptr<IValueFunctionProxy>>(thisValue);
if (!proxy)
{
INTERNAL_ERROR(L"failed to invoke a null function proxy.");
return WfRuntimeExecutionAction::Nop;
}
if (auto lambda = proxy.Cast<WfRuntimeLambda>())
{
if (lambda->globalContext == globalContext)
{
CONTEXT_ACTION(PushStackFrame(lambda->functionIndex, ins.countParameter, lambda->capturedVariables), L"failed to invoke a function.");
return WfRuntimeExecutionAction::EnterStackFrame;
}
}
List<Value> arguments;
for (vint i = 0; i < ins.countParameter; i++)
{
Value argument;
CONTEXT_ACTION(PopValue(argument), L"failed to pop a value from the stack.");
arguments.Insert(0, argument);
}
Ptr<IValueList> list = new ValueListWrapper<List<Value>*>(&arguments);
Value result = proxy->Invoke(list);
PushValue(result);
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::InvokeMethod:
{
Value thisValue;
CONTEXT_ACTION(PopValue(thisValue), L"failed to pop a value from the stack.");
CALL_DEBUGGER(callback->BreakInvoke(thisValue.GetRawPtr(), ins.methodParameter));
if (auto staticMethod = dynamic_cast<WfStaticMethod*>(ins.methodParameter))
{
if (staticMethod->GetGlobalContext() == globalContext.Obj())
{
CONTEXT_ACTION(PushStackFrame(staticMethod->functionIndex, ins.countParameter, nullptr), L"failed to invoke a function.");
return WfRuntimeExecutionAction::EnterStackFrame;
}
}
Array<Value> arguments(ins.countParameter);
for (vint i = 0; i < ins.countParameter; i++)
{
Value argument;
CONTEXT_ACTION(PopValue(argument), L"failed to pop a value from the stack.");
arguments[ins.countParameter - i - 1] = argument;
}
Value result = ins.methodParameter->Invoke(thisValue, arguments);
PushValue(result);
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::AttachEvent:
{
Value thisValue, function;
CONTEXT_ACTION(PopValue(function), L"failed to pop a value from the stack.");
CONTEXT_ACTION(PopValue(thisValue), L"failed to pop a value from the stack.");
CALL_DEBUGGER(callback->BreakAttach(thisValue.GetRawPtr(), ins.eventParameter));
auto proxy = UnboxValue<Ptr<IValueFunctionProxy>>(function);
auto handler = ins.eventParameter->Attach(thisValue, proxy);
PushValue(Value::From(handler));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::DetachEvent:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
auto handler = UnboxValue<Ptr<IEventHandler>>(operand);
CALL_DEBUGGER(callback->BreakDetach(handler->GetOwnerObject().GetRawPtr(), handler->GetOwnerEvent()));
auto result = handler->Detach();
PushValue(BoxValue(result));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::InstallTry:
CONTEXT_ACTION(PushTrapFrame(ins.indexParameter), L"failed to push a trap frame");
return WfRuntimeExecutionAction::ExecuteInstruction;
case WfInsCode::UninstallTry:
{
if (trapFrames.Count() == 0)
{
INTERNAL_ERROR(L"failed to pop the trap frame.");
}
auto frame = GetCurrentTrapFrame();
CONTEXT_ACTION(PopTrapFrame(ins.countParameter), L"failed to pop the trap frame.");
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::RaiseException:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
if (operand.GetValueType() == Value::Text)
{
RaiseException(operand.GetText(), false);
}
else if (auto info = operand.GetSharedPtr().Cast<WfRuntimeExceptionInfo>())
{
RaiseException(info);
}
else
{
INTERNAL_ERROR(L"failed to raise an exception which is neither a string nor a WfRuntimeExceptionInfo.");
}
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::TestElementInSet:
{
Value element, set;
CONTEXT_ACTION(PopValue(set), L"failed to pop a value from the stack.");
CONTEXT_ACTION(PopValue(element), L"failed to pop a value from the stack.");
auto enumerable = UnboxValue<Ptr<IValueEnumerable>>(set);
auto enumerator = enumerable->CreateEnumerator();
while (enumerator->Next())
{
if (enumerator->GetCurrent() == element)
{
PushValue(BoxValue(true));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
}
PushValue(BoxValue(false));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::CompareLiteral:
BEGIN_TYPE
EXECUTE(OpCompare, Bool)
EXECUTE(OpCompare, I1)
EXECUTE(OpCompare, I2)
EXECUTE(OpCompare, I4)
EXECUTE(OpCompare, I8)
EXECUTE(OpCompare, U1)
EXECUTE(OpCompare, U2)
EXECUTE(OpCompare, U4)
EXECUTE(OpCompare, U8)
EXECUTE(OpCompare, F4)
EXECUTE(OpCompare, F8)
EXECUTE(OpCompare, String)
END_TYPE
case WfInsCode::CompareStruct:
{
Value first, second;
CONTEXT_ACTION(PopValue(second), L"failed to pop a value from the stack.");
CONTEXT_ACTION(PopValue(first), L"failed to pop a value from the stack.");
if (!first.IsNull() && !first.GetTypeDescriptor()->GetValueSerializer())
{
INTERNAL_ERROR(L"type" + first.GetTypeDescriptor()->GetTypeName() + L" is not a struct.");
}
if (!second.IsNull() && !second.GetTypeDescriptor()->GetValueSerializer())
{
INTERNAL_ERROR(L"type" + second.GetTypeDescriptor()->GetTypeName() + L" is not a struct.");
}
if (first.GetValueType() != second.GetValueType())
{
PushValue(BoxValue(false));
}
else if (first.IsNull())
{
PushValue(BoxValue(true));
}
else
{
PushValue(BoxValue(first.GetText() == second.GetText()));
}
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::CompareReference:
{
Value first, second;
CONTEXT_ACTION(PopValue(second), L"failed to pop a value from the stack.");
CONTEXT_ACTION(PopValue(first), L"failed to pop a value from the stack.");
bool result = first.GetValueType() != Value::Text && second.GetValueType() != Value::Text && first.GetRawPtr() == second.GetRawPtr();
PushValue(BoxValue(result));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::CompareValue:
{
Value first, second;
CONTEXT_ACTION(PopValue(second), L"failed to pop a value from the stack.");
CONTEXT_ACTION(PopValue(first), L"failed to pop a value from the stack.");
switch (first.GetValueType())
{
case Value::RawPtr:
case Value::SharedPtr:
switch (first.GetValueType())
{
case Value::RawPtr:
case Value::SharedPtr:
PushValue(BoxValue(first.GetRawPtr() == second.GetRawPtr()));
break;
default:
PushValue(BoxValue(false));
}
break;
case Value::Text:
switch (first.GetValueType())
{
case Value::Text:
PushValue(BoxValue(first.GetText() == second.GetText()));
default:
PushValue(BoxValue(false));
}
break;
default:
PushValue(BoxValue(second.IsNull()));
}
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::OpNot:
BEGIN_TYPE
EXECUTE(OpNot_Bool, Bool)
EXECUTE(OpNot, I1)
EXECUTE(OpNot, I2)
EXECUTE(OpNot, I4)
EXECUTE(OpNot, I8)
EXECUTE(OpNot, U1)
EXECUTE(OpNot, U2)
EXECUTE(OpNot, U4)
EXECUTE(OpNot, U8)
END_TYPE
case WfInsCode::OpPositive:
BEGIN_TYPE
EXECUTE(OpPositive, I1)
EXECUTE(OpPositive, I2)
EXECUTE(OpPositive, I4)
EXECUTE(OpPositive, I8)
EXECUTE(OpPositive, U1)
EXECUTE(OpPositive, U2)
EXECUTE(OpPositive, U4)
EXECUTE(OpPositive, U8)
EXECUTE(OpPositive, F4)
EXECUTE(OpPositive, F8)
END_TYPE
case WfInsCode::OpNegative:
BEGIN_TYPE
EXECUTE(OpNegative, I1)
EXECUTE(OpNegative, I2)
EXECUTE(OpNegative, I4)
EXECUTE(OpNegative, I8)
EXECUTE(OpNegative, F4)
EXECUTE(OpNegative, F8)
END_TYPE
case WfInsCode::OpConcat:
{
Value first, second;
CONTEXT_ACTION(PopValue(second), L"failed to pop a value from the stack.");
CONTEXT_ACTION(PopValue(first), L"failed to pop a value from the stack.");
PushValue(BoxValue(first.GetText() + second.GetText()));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
case WfInsCode::OpExp:
BEGIN_TYPE
EXECUTE(OpExp, F4)
EXECUTE(OpExp, F8)
END_TYPE
case WfInsCode::OpAdd:
BEGIN_TYPE
EXECUTE(OpAdd, I1)
EXECUTE(OpAdd, I2)
EXECUTE(OpAdd, I4)
EXECUTE(OpAdd, I8)
EXECUTE(OpAdd, U1)
EXECUTE(OpAdd, U2)
EXECUTE(OpAdd, U4)
EXECUTE(OpAdd, U8)
EXECUTE(OpAdd, F4)
EXECUTE(OpAdd, F8)
END_TYPE
case WfInsCode::OpSub:
BEGIN_TYPE
EXECUTE(OpSub, I1)
EXECUTE(OpSub, I2)
EXECUTE(OpSub, I4)
EXECUTE(OpSub, I8)
EXECUTE(OpSub, U1)
EXECUTE(OpSub, U2)
EXECUTE(OpSub, U4)
EXECUTE(OpSub, U8)
EXECUTE(OpSub, F4)
EXECUTE(OpSub, F8)
END_TYPE
case WfInsCode::OpMul:
BEGIN_TYPE
EXECUTE(OpMul, I1)
EXECUTE(OpMul, I2)
EXECUTE(OpMul, I4)
EXECUTE(OpMul, I8)
EXECUTE(OpMul, U1)
EXECUTE(OpMul, U2)
EXECUTE(OpMul, U4)
EXECUTE(OpMul, U8)
EXECUTE(OpMul, F4)
EXECUTE(OpMul, F8)
END_TYPE
case WfInsCode::OpDiv:
BEGIN_TYPE
EXECUTE(OpDiv, I1)
EXECUTE(OpDiv, I2)
EXECUTE(OpDiv, I4)
EXECUTE(OpDiv, I8)
EXECUTE(OpDiv, U1)
EXECUTE(OpDiv, U2)
EXECUTE(OpDiv, U4)
EXECUTE(OpDiv, U8)
EXECUTE(OpDiv, F4)
EXECUTE(OpDiv, F8)
END_TYPE
case WfInsCode::OpMod:
BEGIN_TYPE
EXECUTE(OpMod, I1)
EXECUTE(OpMod, I2)
EXECUTE(OpMod, I4)
EXECUTE(OpMod, I8)
EXECUTE(OpMod, U1)
EXECUTE(OpMod, U2)
EXECUTE(OpMod, U4)
EXECUTE(OpMod, U8)
END_TYPE
case WfInsCode::OpShl:
BEGIN_TYPE
EXECUTE(OpShl, I1)
EXECUTE(OpShl, I2)
EXECUTE(OpShl, I4)
EXECUTE(OpShl, I8)
EXECUTE(OpShl, U1)
EXECUTE(OpShl, U2)
EXECUTE(OpShl, U4)
EXECUTE(OpShl, U8)
END_TYPE
case WfInsCode::OpShr:
BEGIN_TYPE
EXECUTE(OpShr, I1)
EXECUTE(OpShr, I2)
EXECUTE(OpShr, I4)
EXECUTE(OpShr, I8)
EXECUTE(OpShr, U1)
EXECUTE(OpShr, U2)
EXECUTE(OpShr, U4)
EXECUTE(OpShr, U8)
END_TYPE
case WfInsCode::OpXor:
BEGIN_TYPE
EXECUTE(OpXor, Bool)
EXECUTE(OpXor, I1)
EXECUTE(OpXor, I2)
EXECUTE(OpXor, I4)
EXECUTE(OpXor, I8)
EXECUTE(OpXor, U1)
EXECUTE(OpXor, U2)
EXECUTE(OpXor, U4)
EXECUTE(OpXor, U8)
END_TYPE
case WfInsCode::OpAnd:
BEGIN_TYPE
EXECUTE(OpAnd_Bool, Bool)
EXECUTE(OpAnd, I1)
EXECUTE(OpAnd, I2)
EXECUTE(OpAnd, I4)
EXECUTE(OpAnd, I8)
EXECUTE(OpAnd, U1)
EXECUTE(OpAnd, U2)
EXECUTE(OpAnd, U4)
EXECUTE(OpAnd, U8)
END_TYPE
case WfInsCode::OpOr:
BEGIN_TYPE
EXECUTE(OpOr_Bool, Bool)
EXECUTE(OpOr, I1)
EXECUTE(OpOr, I2)
EXECUTE(OpOr, I4)
EXECUTE(OpOr, I8)
EXECUTE(OpOr, U1)
EXECUTE(OpOr, U2)
EXECUTE(OpOr, U4)
EXECUTE(OpOr, U8)
END_TYPE
case WfInsCode::OpLT:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
vint value = UnboxValue<vint>(operand);
PushValue(BoxValue(value < 0));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
break;
case WfInsCode::OpGT:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
vint value = UnboxValue<vint>(operand);
PushValue(BoxValue(value > 0));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
break;
case WfInsCode::OpLE:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
vint value = UnboxValue<vint>(operand);
PushValue(BoxValue(value <= 0));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
break;
case WfInsCode::OpGE:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
vint value = UnboxValue<vint>(operand);
PushValue(BoxValue(value >= 0));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
break;
case WfInsCode::OpEQ:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
vint value = UnboxValue<vint>(operand);
PushValue(BoxValue(value == 0));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
break;
case WfInsCode::OpNE:
{
Value operand;
CONTEXT_ACTION(PopValue(operand), L"failed to pop a value from the stack.");
vint value = UnboxValue<vint>(operand);
PushValue(BoxValue(value != 0));
return WfRuntimeExecutionAction::ExecuteInstruction;
}
break;
default:
return WfRuntimeExecutionAction::Nop;
}
}
