//------------------------------------------------------------
VIREO_FUNCTION_SIGNATURE3(ArrayIndexElt, TypedArrayCoreRef, Int32, void)
{
TypedArrayCoreRef array = _Param(0);
Int32 length = array->Length();
TypeRef elementType = array->ElementType();
Int32 index = _Param(1);
if (_ParamPointer(2)) {
if (index < 0 || index >= length) {
elementType->InitData(_ParamPointer(2));
} else {
elementType->CopyData(array->BeginAt(index), _ParamPointer(2));
}
}
return _NextInstruction();
}
VIREO_FUNCTION_SIGNATURE4(AnalogWaveformBuild, AnalogWaveform, Timestamp, Double, TypedArrayCoreRef)
{
_Param(0)._t0 = _ParamPointer(1) ? _Param(1) : Timestamp(0, 0);
_Param(0)._dt = _ParamPointer(2) ? _Param(2) : 1.0;
TypedArrayCoreRef* argY_source = _ParamPointer(3);
TypedArrayCoreRef* waveY_dest = &_Param(0)._Y;
if (argY_source) {
if (!(*argY_source)->ElementType()->IsA((*waveY_dest)->ElementType())) {
THREAD_EXEC()->LogEvent(EventLog::kHardDataError, "AnalogWaveformBuild() Type of argument-3 does not match type of output waveform");
return THREAD_EXEC()->Stop();
}
TypeRef type = (*argY_source)->Type();
type->CopyData(argY_source, waveY_dest);
}
return _NextInstruction();
}
//------------------------------------------------------------
VIREO_FUNCTION_SIGNATURE4(ArrayReplaceElt, TypedArrayCoreRef, TypedArrayCoreRef, Int32, void)
{
TypedArrayCoreRef arrayOut = _Param(0);
TypedArrayCoreRef arrayIn = _Param(1);
TypeRef elementType = arrayOut->ElementType();
Int32 index = _Param(2);
Int32 length = arrayIn->Length();
if(arrayOut != arrayIn){
arrayOut->Type()->CopyData(_ParamPointer(1), _ParamPointer(0));
}
if (index >= 0 && index < length) {
void* pDest = arrayOut->BeginAt(index);
elementType->CopyData(_ParamPointer(3), pDest);
}
return _NextInstruction();
}
// Convert variant to data of given type. Error if the data types don't match
VIREO_FUNCTION_SIGNATURET(VariantToData, VariantToDataParamBlock)
{
ErrorCluster *errPtr = _ParamPointer(ErrorClust);
if (!errPtr || !errPtr->status) {
TypeRef inputType = _ParamImmediate(InputData._paramType);
void* inputData = _ParamImmediate(InputData)._pData;
TypeRef targetType = _ParamPointer(TargetType);
TypeRef outputType = _ParamImmediate(OutputData._paramType);
void* outputData = _ParamImmediate(OutputData)._pData;
if (targetType->IsStaticTypeWildcard() || (!outputType->IsStaticTypeAndDataWildcard() && !outputType->IsA(targetType, true))) {
// In VIA, TargetType is a required argument. Generated VIA from G must guarantee this.
// If TargetType is optional, just throw internal error and exit.
// OutputData is optional. However, if supplied, outputType MUST be same as targetType. Generated VIA from G must guarantee this.
// If violated, just throw internal error and exit.
// We should not throw valid LV errors.
if (errPtr)
errPtr->SetErrorAndAppendCallChain(true, kUnspecifiedError, "Variant To Data");
return _NextInstruction();
}
if (inputType->IsVariant()) {
VariantTypeRef variant = *reinterpret_cast<VariantTypeRef *>_ParamImmediate(InputData._pData);
if (VariantType::IsNullVariant(variant)) {
if (errPtr)
errPtr->SetErrorAndAppendCallChain(true, kVariantIncompatibleType, "Variant To Data");
} else {
TypeRef underlyingType = variant->_underlyingTypeRef;
if (targetType->IsVariant()) {
if (outputData)
*static_cast<VariantTypeRef *>(outputData) = VariantType::CreateNewVariantFromType(underlyingType);
} else if (underlyingType->IsA(targetType, true)) {
if (outputData)
targetType->CopyData(underlyingType->Begin(kPARead), outputData);
} else if (errPtr) {
VariantType::SetVariantToDataTypeError(underlyingType, targetType, outputType, outputData, errPtr);
}
}
} else {
