in impl/src/tooling/icpp/interpreter/op_eval.cpp [1152:2009]
void Evaluator::evaluateOpCode(const InterpOp* op)
{
#ifdef BSQ_DEBUG_BUILD
//TODO: update position info for debugging
#endif
switch(op->tag)
{
case OpCodeTag::DeadFlowOp:
{
this->evalDeadFlowOp();
break;
}
case OpCodeTag::AbortOp:
{
this->evalAbortOp(static_cast<const AbortOp*>(op));
break;
}
case OpCodeTag::AssertOp:
{
this->evalAssertCheckOp(static_cast<const AssertOp*>(op));
break;
}
case OpCodeTag::DebugOp:
{
this->evalDebugOp(static_cast<const DebugOp*>(op));
break;
}
case OpCodeTag::LoadUnintVariableValueOp:
{
this->evalLoadUnintVariableValueOp(static_cast<const LoadUnintVariableValueOp*>(op));
break;
}
case OpCodeTag::NoneInitUnionOp:
{
this->evalNoneInitUnionOp(static_cast<const NoneInitUnionOp*>(op));
break;
}
case OpCodeTag::StoreConstantMaskValueOp:
{
this->evalStoreConstantMaskValueOp(static_cast<const StoreConstantMaskValueOp*>(op));
break;
}
case OpCodeTag::DirectAssignOp:
{
auto daop = static_cast<const DirectAssignOp*>(op);
if(daop->sguard.enabled)
{
this->evalDirectAssignOp<true>(daop);
}
else
{
this->evalDirectAssignOp<false>(daop);
}
break;
}
case OpCodeTag::BoxOp:
{
auto bop = static_cast<const BoxOp*>(op);
if(bop->sguard.enabled)
{
this->evalBoxOp<true>(bop);
}
else
{
this->evalBoxOp<false>(bop);
}
break;
}
case OpCodeTag::ExtractOp:
{
auto exop = static_cast<const ExtractOp*>(op);
if(exop->sguard.enabled)
{
this->evalExtractOp<true>(exop);
}
else
{
this->evalExtractOp<false>(exop);
}
break;
}
case OpCodeTag::LoadConstOp:
{
this->evalLoadConstOp(static_cast<const LoadConstOp*>(op));
break;
}
case OpCodeTag::TupleHasIndexOp:
{
this->evalTupleHasIndexOp(static_cast<const TupleHasIndexOp*>(op));
break;
}
case OpCodeTag::RecordHasPropertyOp:
{
this->evalRecordHasPropertyOp(static_cast<const RecordHasPropertyOp*>(op));
break;
}
case OpCodeTag::LoadTupleIndexDirectOp:
{
this->evalLoadTupleIndexDirectOp(static_cast<const LoadTupleIndexDirectOp*>(op));
break;
}
case OpCodeTag::LoadTupleIndexVirtualOp:
{
this->evalLoadTupleIndexVirtualOp(static_cast<const LoadTupleIndexVirtualOp*>(op));
break;
}
case OpCodeTag::LoadTupleIndexSetGuardDirectOp:
{
this->evalLoadTupleIndexSetGuardDirectOp(static_cast<const LoadTupleIndexSetGuardDirectOp*>(op));
break;
}
case OpCodeTag::LoadTupleIndexSetGuardVirtualOp:
{
this->evalLoadTupleIndexSetGuardVirtualOp(static_cast<const LoadTupleIndexSetGuardVirtualOp*>(op));
break;
}
case OpCodeTag::LoadRecordPropertyDirectOp:
{
this->evalLoadRecordPropertyDirectOp(static_cast<const LoadRecordPropertyDirectOp*>(op));
break;
}
case OpCodeTag::LoadRecordPropertyVirtualOp:
{
this->evalLoadRecordPropertyVirtualOp(static_cast<const LoadRecordPropertyVirtualOp*>(op));
break;
}
case OpCodeTag::LoadRecordPropertySetGuardDirectOp:
{
this->evalLoadRecordPropertySetGuardDirectOp(static_cast<const LoadRecordPropertySetGuardDirectOp*>(op));
break;
}
case OpCodeTag::LoadRecordPropertySetGuardVirtualOp:
{
this->evalLoadRecordPropertySetGuardVirtualOp(static_cast<const LoadRecordPropertySetGuardVirtualOp*>(op));
break;
}
case OpCodeTag::LoadEntityFieldDirectOp:
{
this->evalLoadDirectFieldOp(static_cast<const LoadEntityFieldDirectOp*>(op));
break;
}
case OpCodeTag::LoadEntityFieldVirtualOp:
{
this->evalLoadVirtualFieldOp(static_cast<const LoadEntityFieldVirtualOp*>(op));
break;
}
case OpCodeTag::ProjectTupleOp:
{
this->evalProjectTupleOp(static_cast<const ProjectTupleOp*>(op));
break;
}
case OpCodeTag::ProjectRecordOp:
{
this->evalProjectRecordOp(static_cast<const ProjectRecordOp*>(op));
break;
}
case OpCodeTag::ProjectEntityOp:
{
this->evalProjectEntityOp(static_cast<const ProjectEntityOp*>(op));
break;
}
case OpCodeTag::UpdateTupleOp:
{
this->evalUpdateTupleOp(static_cast<const UpdateTupleOp*>(op));
break;
}
case OpCodeTag::UpdateRecordOp:
{
this->evalUpdateRecordOp(static_cast<const UpdateRecordOp*>(op));
break;
}
case OpCodeTag::UpdateEntityOp:
{
this->evalUpdateEntityOp(static_cast<const UpdateEntityOp*>(op));
break;
}
case OpCodeTag::LoadFromEpehmeralListOp:
{
this->evalLoadFromEpehmeralListOp(static_cast<const LoadFromEpehmeralListOp*>(op));
break;
}
case OpCodeTag::MultiLoadFromEpehmeralListOp:
{
this->evalMultiLoadFromEpehmeralListOp(static_cast<const MultiLoadFromEpehmeralListOp*>(op));
break;
}
case OpCodeTag::SliceEphemeralListOp:
{
this->evalSliceEphemeralListOp(static_cast<const SliceEphemeralListOp*>(op));
break;
}
case OpCodeTag::InvokeFixedFunctionOp:
{
auto opc = static_cast<const InvokeFixedFunctionOp*>(op);
if(opc->sguard.enabled)
{
this->evalInvokeFixedFunctionOp<true>(opc);
}
else
{
this->evalInvokeFixedFunctionOp<false>(opc);
}
break;
}
case OpCodeTag::InvokeVirtualFunctionOp:
{
this->evalInvokeVirtualFunctionOp(static_cast<const InvokeVirtualFunctionOp*>(op));
break;
}
case OpCodeTag::InvokeVirtualOperatorOp:
{
this->evalInvokeVirtualOperatorOp(static_cast<const InvokeVirtualOperatorOp*>(op));
break;
}
case OpCodeTag::ConstructorTupleOp:
{
this->evalConstructorTupleOp(static_cast<const ConstructorTupleOp*>(op));
break;
}
case OpCodeTag::ConstructorTupleFromEphemeralListOp:
{
this->evalConstructorTupleFromEphemeralListOp(static_cast<const ConstructorTupleFromEphemeralListOp*>(op));
break;
}
case OpCodeTag::ConstructorRecordOp:
{
this->evalConstructorRecordOp(static_cast<const ConstructorRecordOp*>(op));
break;
}
case OpCodeTag::ConstructorRecordFromEphemeralListOp:
{
this->evalConstructorRecordFromEphemeralListOp(static_cast<const ConstructorRecordFromEphemeralListOp*>(op));
break;
}
case OpCodeTag::EphemeralListExtendOp:
{
this->evalEphemeralListExtendOp(static_cast<const EphemeralListExtendOp*>(op));
break;
}
case OpCodeTag::ConstructorEphemeralListOp:
{
this->evalConstructorEphemeralListOp(static_cast<const ConstructorEphemeralListOp*>(op));
break;
}
case OpCodeTag::ConstructorPrimaryCollectionEmptyOp:
{
this->evalConstructorPrimaryCollectionEmptyOp(static_cast<const ConstructorPrimaryCollectionEmptyOp*>(op));
break;
}
case OpCodeTag::ConstructorPrimaryCollectionSingletonsOp:
{
this->evalConstructorPrimaryCollectionSingletonsOp(static_cast<const ConstructorPrimaryCollectionSingletonsOp*>(op));
break;
}
case OpCodeTag::ConstructorPrimaryCollectionCopiesOp:
{
this->evalConstructorPrimaryCollectionCopiesOp(static_cast<const ConstructorPrimaryCollectionCopiesOp*>(op));
break;
}
case OpCodeTag::ConstructorPrimaryCollectionMixedOp:
{
this->evalConstructorPrimaryCollectionMixedOp(static_cast<const ConstructorPrimaryCollectionMixedOp*>(op));
break;
}
case OpCodeTag::PrefixNotOp:
{
this->evalPrefixNotOp(static_cast<const PrefixNotOp*>(op));
break;
}
case OpCodeTag::AllTrueOp:
{
this->evalAllTrueOp(static_cast<const AllTrueOp*>(op));
break;
}
case OpCodeTag::SomeTrueOp:
{
this->evalSomeTrueOp(static_cast<const SomeTrueOp*>(op));
break;
}
case OpCodeTag::BinKeyEqFastOp:
{
auto ope = static_cast<const BinKeyEqFastOp*>(op);
if(ope->sguard.enabled)
{
this->evalBinKeyEqFastOp<true>(ope);
}
else
{
this->evalBinKeyEqFastOp<false>(ope);
}
break;
}
case OpCodeTag::BinKeyEqStaticOp:
{
auto ope = static_cast<const BinKeyEqStaticOp*>(op);
if(ope->sguard.enabled)
{
this->evalBinKeyEqStaticOp<true>(ope);
}
else
{
this->evalBinKeyEqStaticOp<false>(ope);
}
break;
}
case OpCodeTag::BinKeyEqVirtualOp:
{
auto ope = static_cast<const BinKeyEqVirtualOp*>(op);
if(ope->sguard.enabled)
{
this->evalBinKeyEqVirtualOp<true>(ope);
}
else
{
this->evalBinKeyEqVirtualOp<false>(ope);
}
break;
}
case OpCodeTag::BinKeyLessFastOp:
{
auto ope = static_cast<const BinKeyLessFastOp*>(op);
if(ope->sguard.enabled)
{
this->evalBinKeyLessFastOp<true>(ope);
}
else
{
this->evalBinKeyLessFastOp<false>(ope);
}
break;
}
case OpCodeTag::BinKeyLessStaticOp:
{
auto ope = static_cast<const BinKeyLessStaticOp*>(op);
if(ope->sguard.enabled)
{
this->evalBinKeyLessStaticOp<true>(ope);
}
else
{
this->evalBinKeyLessStaticOp<false>(ope);
}
break;
}
case OpCodeTag::BinKeyLessVirtualOp:
{
auto ope = static_cast<const BinKeyLessVirtualOp*>(op);
if(ope->sguard.enabled)
{
this->evalBinKeyLessVirtualOp<true>(ope);
}
else
{
this->evalBinKeyLessVirtualOp<false>(ope);
}
break;
}
case OpCodeTag::TypeIsNoneOp:
{
auto opc = static_cast<const TypeIsNoneOp*>(op);
if(opc->sguard.enabled)
{
this->evalIsNoneOp<true>(opc);
}
else
{
this->evalIsNoneOp<false>(opc);
}
break;
}
case OpCodeTag::TypeIsSomeOp:
{
auto opc = static_cast<const TypeIsSomeOp*>(op);
if(opc->sguard.enabled)
{
this->evalIsSomeOp<true>(opc);
}
else
{
this->evalIsSomeOp<false>(opc);
}
break;
}
case OpCodeTag::TypeTagIsOp:
{
auto opc = static_cast<const TypeTagIsOp*>(op);
if(opc->sguard.enabled)
{
this->evalTypeTagIsOp<true>(opc);
}
else
{
this->evalTypeTagIsOp<false>(opc);
}
break;
}
case OpCodeTag::TypeTagSubtypeOfOp:
{
auto opc = static_cast<const TypeTagSubtypeOfOp*>(op);
if(opc->sguard.enabled)
{
this->evalTypeTagSubtypeOfOp<true>(opc);
}
else
{
this->evalTypeTagSubtypeOfOp<false>(opc);
}
break;
}
//
// ---- jump operations are handled in the outer loop ----
//
case OpCodeTag::RegisterAssignOp:
{
auto opc = static_cast<const RegisterAssignOp*>(op);
if(opc->sguard.enabled)
{
this->evalRegisterAssignOp<true>(opc);
}
else
{
this->evalRegisterAssignOp<false>(opc);
}
break;
}
case OpCodeTag::ReturnAssignOp:
{
this->evalReturnAssignOp(static_cast<const ReturnAssignOp*>(op));
break;
}
case OpCodeTag::ReturnAssignOfConsOp:
{
this->evalReturnAssignOfConsOp(static_cast<const ReturnAssignOfConsOp*>(op));
break;
}
#ifdef BSQ_DEBUG_BUILD
case OpCodeTag::VarLifetimeStartOp:
{
this->evalVarLifetimeStartOp(static_cast<const VarLifetimeStartOp*>(op));
break;
}
case OpCodeTag::VarLifetimeEndOp:
{
this->evalVarLifetimeEndOp(static_cast<const VarLifetimeEndOp*>(op));
break;
}
#endif
case OpCodeTag::NegateIntOp:
{
PrimitiveNegateOperatorMacroChecked(this, op, OpCodeTag::NegateDecimalOp, BSQInt, "Int negation overflow/underflow");
break;
}
case OpCodeTag::NegateBigIntOp:
{
PrimitiveNegateOperatorMacroSafe(this, op, OpCodeTag::NegateBigIntOp, BSQBigInt);
break;
}
case OpCodeTag::NegateRationalOp:
{
assert(false);
break;
}
case OpCodeTag::NegateFloatOp:
{
PrimitiveNegateOperatorMacroSafe(this, op, OpCodeTag::NegateFloatOp, BSQFloat);
break;
}
case OpCodeTag::NegateDecimalOp:
{
PrimitiveNegateOperatorMacroSafe(this, op, OpCodeTag::NegateDecimalOp, BSQDecimal);
break;
}
case OpCodeTag::AddNatOp:
{
PrimitiveBinaryOperatorMacroChecked(this, op, OpCodeTag::AddNatOp, BSQNat, +, __builtin_add_overflow, "Nat addition overflow")
break;
}
case OpCodeTag::AddIntOp:
{
PrimitiveBinaryOperatorMacroChecked(this, op, OpCodeTag::AddIntOp, BSQInt, +, __builtin_add_overflow, "Int addition overflow/underflow")
break;
}
case OpCodeTag::AddBigNatOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::AddBigNatOp, BSQBigNat, +)
break;
}
case OpCodeTag::AddBigIntOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::AddBigIntOp, BSQBigInt, +)
break;
}
case OpCodeTag::AddRationalOp:
{
assert(false);
break;
}
case OpCodeTag::AddFloatOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::AddFloatOp, BSQFloat, +)
break;
}
case OpCodeTag::AddDecimalOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::AddDecimalOp, BSQDecimal, +)
break;
}
case OpCodeTag::SubNatOp:
{
PrimitiveBinaryOperatorMacroChecked(this, op, OpCodeTag::SubNatOp, BSQNat, -, __builtin_sub_overflow, "Nat subtraction overflow")
break;
}
case OpCodeTag::SubIntOp:
{
PrimitiveBinaryOperatorMacroChecked(this, op, OpCodeTag::SubIntOp, BSQInt, -, __builtin_sub_overflow, "Int subtraction overflow/underflow")
break;
}
case OpCodeTag::SubBigNatOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::SubBigNatOp, BSQBigNat, -)
break;
}
case OpCodeTag::SubBigIntOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::SubBigIntOp, BSQBigInt, -)
break;
}
case OpCodeTag::SubRationalOp:
{
assert(false);
break;
}
case OpCodeTag::SubFloatOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::SubFloatOp, BSQFloat, -)
break;
}
case OpCodeTag::SubDecimalOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::SubDecimalOp, BSQDecimal, -)
break;
}
case OpCodeTag::MultNatOp:
{
PrimitiveBinaryOperatorMacroChecked(this, op, OpCodeTag::MultNatOp, BSQNat, *, __builtin_mul_overflow, "Nat multiplication overflow")
break;
}
case OpCodeTag::MultIntOp:
{
PrimitiveBinaryOperatorMacroChecked(this, op, OpCodeTag::MultIntOp, BSQInt, *, __builtin_mul_overflow, "Int multiplication underflow/overflow")
break;
}
case OpCodeTag::MultBigNatOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::MultBigNatOp, BSQBigNat, *)
break;
}
case OpCodeTag::MultBigIntOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::MultBigIntOp, BSQBigInt, *)
break;
}
case OpCodeTag::MultRationalOp:
{
assert(false);
break;
}
case OpCodeTag::MultFloatOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::MultFloatOp, BSQFloat, *)
break;
}
case OpCodeTag::MultDecimalOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::MultDecimalOp, BSQDecimal, *)
break;
}
case OpCodeTag::DivNatOp:
{
PrimitiveBinaryOperatorMacroCheckedDiv(this, op, OpCodeTag::DivNatOp, BSQNat)
break;
}
case OpCodeTag::DivIntOp:
{
PrimitiveBinaryOperatorMacroCheckedDiv(this, op, OpCodeTag::DivIntOp, BSQInt)
break;
}
case OpCodeTag::DivBigNatOp:
{
PrimitiveBinaryOperatorMacroCheckedDiv(this, op, OpCodeTag::DivBigNatOp, BSQBigNat)
break;
}
case OpCodeTag::DivBigIntOp:
{
PrimitiveBinaryOperatorMacroCheckedDiv(this, op, OpCodeTag::DivBigIntOp, BSQBigInt)
break;
}
case OpCodeTag::DivRationalOp:
{
assert(false);
break;
}
case OpCodeTag::DivFloatOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::DivFloatOp, BSQFloat, /)
break;
}
case OpCodeTag::DivDecimalOp:
{
PrimitiveBinaryOperatorMacroSafe(this, op, OpCodeTag::DivDecimalOp, BSQDecimal, /)
break;
}
case OpCodeTag::EqNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::EqNatOp, BSQNat, ==)
break;
}
case OpCodeTag::EqIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::EqIntOp, BSQInt, ==)
break;
}
case OpCodeTag::EqBigNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::EqBigNatOp, BSQBigNat, ==)
break;
}
case OpCodeTag::EqBigIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::EqBigIntOp, BSQBigInt, ==)
break;
}
case OpCodeTag::EqRationalOp:
{
assert(false);
break;
}
case OpCodeTag::NeqNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::NeqNatOp, BSQNat, !=)
break;
}
case OpCodeTag::NeqIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::NeqIntOp, BSQInt, !=)
break;
}
case OpCodeTag::NeqBigNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::NeqBigNatOp, BSQBigNat, !=)
break;
}
case OpCodeTag::NeqBigIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::NeqBigIntOp, BSQBigInt, !=)
break;
}
case OpCodeTag::NeqRationalOp:
{
assert(false);
break;
}
case OpCodeTag::LtNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::LtNatOp, BSQNat, <)
break;
}
case OpCodeTag::LtIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::LtIntOp, BSQInt, <)
break;
}
case OpCodeTag::LtBigNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::LtBigNatOp, BSQBigNat, <)
break;
}
case OpCodeTag::LtBigIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::LtBigIntOp, BSQBigInt, <)
break;
}
case OpCodeTag::LtRationalOp:
{
assert(false);
break;
}
case OpCodeTag::LtFloatOp:
{
PrimitiveBinaryComparatorMacroFP(this, op, OpCodeTag::LtFloatOp, BSQFloat, std::isnan, std::isinf, <)
break;
}
case OpCodeTag::LtDecimalOp:
{
PrimitiveBinaryComparatorMacroFP(this, op, OpCodeTag::LtDecimalOp, BSQDecimal, std::isnan, std::isinf, <)
break;
}
case OpCodeTag::GtNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::GtNatOp, BSQNat, >)
break;
}
case OpCodeTag::GtIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::GtIntOp, BSQInt, >)
break;
}
case OpCodeTag::GtBigNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::GtBigNatOp, BSQBigNat, >)
break;
}
case OpCodeTag::GtBigIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::GtBigIntOp, BSQBigInt, >)
break;
}
case OpCodeTag::GtRationalOp:
{
assert(false);
break;
}
case OpCodeTag::GtFloatOp:
{
PrimitiveBinaryComparatorMacroFP(this, op, OpCodeTag::GtFloatOp, BSQFloat, std::isnan, std::isinf, >)
break;
}
case OpCodeTag::GtDecimalOp:
{
PrimitiveBinaryComparatorMacroFP(this, op, OpCodeTag::GtDecimalOp, BSQDecimal, std::isnan, std::isinf, >)
break;
}
case OpCodeTag::LeNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::LeNatOp, BSQNat, <=)
break;
}
case OpCodeTag::LeIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::LeIntOp, BSQInt, <=)
break;
}
case OpCodeTag::LeBigNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::LeBigNatOp, BSQBigNat, <=)
break;
}
case OpCodeTag::LeBigIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::LeBigIntOp, BSQBigInt, <=)
break;
}
case OpCodeTag::LeRationalOp:
{
assert(false);
break;
}
case OpCodeTag::LeFloatOp:
{
PrimitiveBinaryComparatorMacroFP(this, op, OpCodeTag::LeFloatOp, BSQFloat, std::isnan, std::isinf, <=)
break;
}
case OpCodeTag::LeDecimalOp:
{
PrimitiveBinaryComparatorMacroFP(this, op, OpCodeTag::LeDecimalOp, BSQDecimal, std::isnan, std::isinf, <=)
break;
}
case OpCodeTag::GeNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::GeNatOp, BSQNat, >=)
break;
}
case OpCodeTag::GeIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::GeIntOp, BSQInt, >=)
break;
}
case OpCodeTag::GeBigNatOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::GeBigNatOp, BSQBigNat, >=)
break;
}
case OpCodeTag::GeBigIntOp:
{
PrimitiveBinaryComparatorMacroSafe(this, op, OpCodeTag::GeBigIntOp, BSQBigInt, >=)
break;
}
case OpCodeTag::GeRationalOp:
{
assert(false);
break;
}
case OpCodeTag::GeFloatOp:
{
PrimitiveBinaryComparatorMacroFP(this, op, OpCodeTag::GeFloatOp, BSQFloat, std::isnan, std::isinf, >=)
break;
}
case OpCodeTag::GeDecimalOp:
{
PrimitiveBinaryComparatorMacroFP(this, op, OpCodeTag::GeDecimalOp, BSQDecimal, std::isnan, std::isinf, >=)
break;
}
case OpCodeTag::EqStrPosOp:
{
const PrimitiveBinaryOperatorOp<OpCodeTag::EqStrPosOp>* bop = static_cast<const PrimitiveBinaryOperatorOp<OpCodeTag::EqStrPosOp>*>(op);
auto i1 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->larg));
auto i2 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->rarg));
SLPTR_STORE_CONTENTS_AS(BSQBool, this->evalTargetVar(bop->trgt), iteratorEqual(&i1, &i2));
break;
}
case OpCodeTag::NeqStrPosOp:
{
const PrimitiveBinaryOperatorOp<OpCodeTag::NeqStrPosOp>* bop = static_cast<const PrimitiveBinaryOperatorOp<OpCodeTag::NeqStrPosOp>*>(op);
auto i1 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->larg));
auto i2 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->rarg));
SLPTR_STORE_CONTENTS_AS(BSQBool, this->evalTargetVar(bop->trgt), !iteratorEqual(&i1, &i2));
break;
}
case OpCodeTag::LtStrPosOp:
{
const PrimitiveBinaryOperatorOp<OpCodeTag::LtStrPosOp>* bop = static_cast<const PrimitiveBinaryOperatorOp<OpCodeTag::LtStrPosOp>*>(op);
auto i1 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->larg));
auto i2 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->rarg));
SLPTR_STORE_CONTENTS_AS(BSQBool, this->evalTargetVar(bop->trgt), iteratorLess(&i1, &i2));
break;
}
case OpCodeTag::GtStrPosOp:
{
const PrimitiveBinaryOperatorOp<OpCodeTag::LtStrPosOp>* bop = static_cast<const PrimitiveBinaryOperatorOp<OpCodeTag::LtStrPosOp>*>(op);
auto i1 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->larg));
auto i2 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->rarg));
SLPTR_STORE_CONTENTS_AS(BSQBool, this->evalTargetVar(bop->trgt), iteratorLess(&i2, &i1));
break;
}
case OpCodeTag::LeStrPosOp:
{
const PrimitiveBinaryOperatorOp<OpCodeTag::LtStrPosOp>* bop = static_cast<const PrimitiveBinaryOperatorOp<OpCodeTag::LtStrPosOp>*>(op);
auto i1 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->larg));
auto i2 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->rarg));
SLPTR_STORE_CONTENTS_AS(BSQBool, this->evalTargetVar(bop->trgt), !iteratorLess(&i2, &i1));
break;
}
case OpCodeTag::GeStrPosOp:
{
const PrimitiveBinaryOperatorOp<OpCodeTag::LtStrPosOp>* bop = static_cast<const PrimitiveBinaryOperatorOp<OpCodeTag::LtStrPosOp>*>(op);
auto i1 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->larg));
auto i2 = SLPTR_LOAD_CONTENTS_AS(BSQStringIterator, this->evalArgument(bop->rarg));
SLPTR_STORE_CONTENTS_AS(BSQBool, this->evalTargetVar(bop->trgt), !iteratorLess(&i1, &i2));
break;
}
default:
{
assert(false);
break;
}
}
}