HRESULT Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiSign::SignInternal___SZARRAY_U1__SZARRAY_U1__I4__I4( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock* pThis = stack.This(); CLR_RT_HeapBlock_Array* pData = stack.Arg1().DereferenceArray(); CLR_RT_HeapBlock_Array* pRes; CLR_INT32 offset = stack.Arg2().NumericByRef().s4; CLR_INT32 len = stack.Arg3().NumericByRef().s4; CLR_RT_HeapBlock* pSession = pThis[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_SessionContainer::FIELD__m_session].Dereference(); CK_SESSION_HANDLE hSession; CK_ULONG sigLen = 0; CLR_RT_HeapBlock hbRef; FAULT_ON_NULL(pSession); FAULT_ON_NULL_ARG(pData); if((offset + len) > (CLR_INT32)pData->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE); hSession = (CK_SESSION_HANDLE)pSession[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Session::FIELD__m_handle].NumericByRef().s4; if(hSession == CK_SESSION_HANDLE_INVALID) TINYCLR_SET_AND_LEAVE(CLR_E_OBJECT_DISPOSED); CRYPTOKI_CHECK_RESULT(stack, C_Sign(hSession, pData->GetElement(offset), len, NULL, (CK_ULONG_PTR)&sigLen)); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance(hbRef, sigLen, g_CLR_RT_WellKnownTypes.m_UInt8)); pRes = hbRef.DereferenceArray(); CRYPTOKI_CHECK_RESULT(stack, C_Sign(hSession, pData->GetElement(offset), len, pRes->GetFirstElement(), (CK_ULONG_PTR)&sigLen)); if(sigLen < pRes->m_numOfElements) { TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance(stack.PushValue(), sigLen, g_CLR_RT_WellKnownTypes.m_UInt8)); memcpy(stack.TopValue().DereferenceArray()->GetFirstElement(), pRes->GetFirstElement(), sigLen); } else { stack.SetResult_Object(pRes); } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_NativeEventDispatcher::EnableInterrupt___VOID( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock_NativeEventDispatcher *pNativeDisp = NULL; CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); if(pThis[ FIELD__m_disposed ].NumericByRef().s1 != 0) { TINYCLR_SET_AND_LEAVE(CLR_E_OBJECT_DISPOSED); } TINYCLR_CHECK_HRESULT(GetEventDispatcher( stack, pNativeDisp )); // Calls driver to enable interrupts TINYCLR_CHECK_HRESULT(pNativeDisp->m_DriverMethods->m_EnableProc( pNativeDisp, true )); TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_hardware_usb_native_Microsoft_SPOT_Hardware_UsbClient_UsbStream::nativeClose___VOID( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_INT32 controllerIndex, streamIndex, stream; CLR_RT_HeapBlock* pThis; pThis = stack.This(); FAULT_ON_NULL(pThis); controllerIndex = pThis[ Library_spot_hardware_usb_native_Microsoft_SPOT_Hardware_UsbClient_UsbStream::FIELD__m_controllerIndex ].NumericByRef().s4; streamIndex = pThis[ Library_spot_hardware_usb_native_Microsoft_SPOT_Hardware_UsbClient_UsbStream::FIELD__m_streamIndex ].NumericByRef().s4; stream = (controllerIndex << USB_CONTROLLER_SHIFT) + streamIndex; if( !USB_CloseStream( stream ) ) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_Time_native_Microsoft_SPOT_Time_TimeService::get_LastSyncStatus___STATIC__MicrosoftSPOTTimeTimeServiceStatus( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); TimeService_Status status; CLR_RT_HeapBlock& top = stack.PushValueAndClear(); CLR_RT_HeapBlock* managedStatus = NULL; TINYCLR_CHECK_HRESULT(TimeService_GetLastSyncStatus( &status )); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( top, g_CLR_RT_WellKnownTypes.m_TimeServiceStatus )); managedStatus = top.Dereference(); managedStatus[ ManagedStatus::FIELD__Flags ].SetInteger( status.Flags ); managedStatus[ ManagedStatus::FIELD__SyncSourceServer ].SetInteger( status.ServerIP ); managedStatus[ ManagedStatus::FIELD__SyncTimeOffset ].SetInteger( status.SyncOffset ); managedStatus[ ManagedStatus::FIELD__TimeUTC ].SetInteger( status.CurrentTimeUTC ); TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_InterruptPort::DisableInterrupt___VOID( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_HARDWARE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_NativeEventDispatcher* port; CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); if(pThis[ Library_spot_hardware_native_Microsoft_SPOT_Hardware_NativeEventDispatcher::FIELD__m_disposed ].NumericByRef().s1 != 0) { TINYCLR_SET_AND_LEAVE(CLR_E_OBJECT_DISPOSED); } TINYCLR_CHECK_HRESULT(Library_spot_hardware_native_Microsoft_SPOT_Hardware_NativeEventDispatcher::GetEventDispatcher( stack, port )); TINYCLR_SET_AND_LEAVE(Microsoft_SPOT_Hardware_InterruptPort_DisableInterrupt( pThis, port )); TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_Time_native_Microsoft_SPOT_Time_TimeService::SetUtcTime___STATIC__VOID__I8( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); INT64 utc = stack.Arg0().NumericByRef().s8; INT64 utcBefore = Time_GetUtcTime(); INT64 utcNow = Time_SetUtcTime( utc, false ); // correct the uptime if(utcNow > utcBefore) { g_CLR_RT_ExecutionEngine.m_startTime += (utcNow - utcBefore); } else { g_CLR_RT_ExecutionEngine.m_startTime -= (utcBefore - utcNow); } TINYCLR_NOCLEANUP_NOLABEL(); }
HRESULT Library_spot_Time_native_Microsoft_SPOT_Time_TimeService::get_Settings___STATIC__MicrosoftSPOTTimeTimeServiceSettings( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); TimeService_Settings settings; CLR_RT_HeapBlock& top = stack.PushValueAndClear(); CLR_RT_HeapBlock* managedSettings = NULL; TINYCLR_CHECK_HRESULT(TimeService_LoadSettings(&settings)); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( top, g_CLR_RT_WellKnownTypes.m_TimeServiceSettings )); managedSettings = top.Dereference(); managedSettings[ ManagedSettings::FIELD__PrimaryServerIP ].SetInteger( settings.PrimaryServerIP ); managedSettings[ ManagedSettings::FIELD__AlternateServerIP ].SetInteger( settings.AlternateServerIP ); managedSettings[ ManagedSettings::FIELD__RefreshTime ].SetInteger( settings.RefreshTime ); managedSettings[ ManagedSettings::FIELD__Tolerance ].SetInteger( settings.Tolerance ); managedSettings[ ManagedSettings::FIELD__ForceSyncAtWakeUp ].SetBoolean( settings.Flags & TimeService_Settings_Flags_ForceSyncAtWakeUp ); managedSettings[ ManagedSettings::FIELD__AutoDayLightSavings ].SetBoolean( settings.Flags & TimeService_Settings_Flags_AutoDST ); TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_native_Microsoft_SPOT_CryptoState::LoadAsymmetricKey( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock* pThis; CLR_RT_HeapBlock_Array* array; pThis = stack.This(); FAULT_ON_NULL(pThis); // // Init RSA key. // array = pThis[ Library_spot_native_Microsoft_SPOT_Cryptography_Key_RSA::FIELD__m_modulus ].DereferenceArray(); FAULT_ON_NULL(array); memcpy( &m_keyAsymmetric.module, array->GetFirstElement(), sizeof(m_keyAsymmetric.module) ); array = pThis[ Library_spot_native_Microsoft_SPOT_Cryptography_Key_RSA::FIELD__m_exponent ].DereferenceArray(); FAULT_ON_NULL(array); memcpy( &m_keyAsymmetric.exponent, array->GetFirstElement(), sizeof(m_keyAsymmetric.exponent) ); m_keyAsymmetric.exponent_len = RSA_KEY_SIZE_BYTES / sizeof(DWORD); TINYCLR_NOCLEANUP(); }
HRESULT Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Cryptoki::GetSlotsInternal___STATIC__SZARRAY_MicrosoftSPOTCryptokiSlot( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CK_ULONG i; CK_SLOT_ID slots[NETMF_CRYPTOKI_MAX_SLOTS]; CK_ULONG count = NETMF_CRYPTOKI_MAX_SLOTS; CLR_RT_HeapBlock_Array* pSlots; CLR_RT_HeapBlock ref; CLR_RT_HeapBlock* pSlotRef; CRYPTOKI_CHECK_RESULT(stack, C_GetSlotList(CK_FALSE, slots, &count)); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance(ref, (CLR_UINT32)count, g_CLR_RT_WellKnownTypes.m_CryptokiSlot)); pSlots = ref.DereferenceArray(); pSlotRef = (CLR_RT_HeapBlock*)pSlots->GetFirstElement(); for(i=0; i<count; i++) { CLR_RT_HeapBlock* pSlot; TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( pSlotRef[i], g_CLR_RT_WellKnownTypes.m_CryptokiSlot )); pSlot = pSlotRef[i].Dereference(); pSlot[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Slot::FIELD__m_slotIndex ].SetInteger ((CLR_INT32)slots[i]); pSlot[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Slot::FIELD__m_disposed ].SetBoolean (false ); pSlot[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Slot::FIELD__m_evtDispatcher].SetObjectReference(NULL ); pSlot[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Slot::FIELD__m_slotEvent ].SetObjectReference(NULL ); pSlot[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Slot::FIELD__m_slotInfo ].SetObjectReference(NULL ); } stack.SetResult_Object(pSlots); TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_io_native_Microsoft_SPOT_IO_NativeFindFile::GetFileInfo___STATIC__MicrosoftSPOTIONativeFileInfo__STRING( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_IO(); TINYCLR_HEADER(); FS_FILEINFO fileInfo; BOOL found; UnicodeString pathW; FileSystemVolume* driver; CLR_RT_HeapBlock& top = stack.PushValueAndClear(); TINYCLR_CHECK_HRESULT(Library_spot_io_native_Microsoft_SPOT_IO_NativeIO::FindVolume( stack.Arg0(), driver, pathW )); TINYCLR_CHECK_HRESULT(driver->GetFileInfo( pathW, &fileInfo, &found )); if(found) { CLR_RT_HeapBlock* managedFi; TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( top, g_CLR_RT_WellKnownTypes.m_NativeFileInfo )); managedFi = top.Dereference(); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__Attributes ].SetInteger( (CLR_UINT32)fileInfo.Attributes ); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__CreationTime ].SetInteger( (CLR_INT64)fileInfo.CreationTime ); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__LastAccessTime ].SetInteger( (CLR_INT64)fileInfo.LastAccessTime ); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__LastWriteTime ].SetInteger( (CLR_INT64)fileInfo.LastWriteTime ); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__Size ].SetInteger( (CLR_INT64)fileInfo.Size ); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__FileName ].SetObjectReference( NULL ); } else { top.SetObjectReference( NULL ); } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_io_native_Microsoft_SPOT_IO_NativeFindFile::GetNext___MicrosoftSPOTIONativeFileInfo( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_IO(); TINYCLR_HEADER(); CLR_RT_FindFile* ff; FS_FILEINFO* fi; BOOL found; CLR_RT_HeapBlock& top = stack.PushValueAndClear(); TINYCLR_CHECK_HRESULT(GetFindFile( stack, ff )); TINYCLR_CHECK_HRESULT(ff->GetNext( &fi, &found )); if(found) { CLR_RT_HeapBlock* managedFi; TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( top, g_CLR_RT_WellKnownTypes.m_NativeFileInfo )); managedFi = top.Dereference(); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__Attributes ].SetInteger( (CLR_UINT32)fi->Attributes ); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__CreationTime ].SetInteger( (CLR_INT64)fi->CreationTime ); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__LastAccessTime ].SetInteger( (CLR_INT64)fi->LastAccessTime ); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__LastWriteTime ].SetInteger( (CLR_INT64)fi->LastWriteTime ); managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__Size ].SetInteger( (CLR_INT64)fi->Size ); TINYCLR_CHECK_HRESULT(ff->CreateFilenameString( managedFi[ Library_spot_io_native_Microsoft_SPOT_IO_NativeFileInfo::FIELD__FileName ] )); } else { top.SetObjectReference( NULL ); } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_NativeEventDispatcher::Dispose___VOID__BOOLEAN( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock_NativeEventDispatcher *pNativeDisp = NULL; CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); TINYCLR_CHECK_HRESULT(GetEventDispatcher( stack, pNativeDisp )); // Cleanup the HAL queue from the instance of assiciated CLR_RT_HeapBlock_NativeEventDispatcher pNativeDisp->RemoveFromHALQueue(); // Calls driver to enable interrupts. Consider that there could be no driver // associated to this object so check that the driver methods are set // we will be tolerant in this case and not throw any exception if(pNativeDisp->m_DriverMethods != NULL) { TINYCLR_CHECK_HRESULT(pNativeDisp->m_DriverMethods->m_CleanupProc( pNativeDisp )); } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_native_Microsoft_SPOT_CryptoState::LoadSymmetricKey( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock* pThis; CLR_RT_HeapBlock_Array* array; pThis = stack.This() ; FAULT_ON_NULL(pThis); array = pThis[ Library_spot_native_Microsoft_SPOT_Cryptography_Key_TinyEncryptionAlgorithm::FIELD__m_value ].DereferenceArray(); FAULT_ON_NULL(array); memcpy( m_keySymmetric.Seed, array->GetFirstElement(), ARRAYSIZE(m_keySymmetric.Seed) ); if(pThis[ Library_spot_native_Microsoft_SPOT_Cryptography_Key_TinyEncryptionAlgorithm::FIELD__m_doublyEncrypted ].NumericByRefConst().u1 != 0) { KeySeed deviceKey; UINT8 iv[ TEA_KEY_SIZE_BYTES ]; memset( iv, 0, sizeof(iv) ); GetDeviceKey( (UINT8*)deviceKey.Seed ); ::Crypto_Decrypt( deviceKey.Seed, iv, sizeof(iv), m_keySymmetric.Seed, sizeof(m_keySymmetric.Seed), m_keySymmetric.Seed, sizeof(m_keySymmetric.Seed) ); } TINYCLR_NOCLEANUP(); }
HRESULT Library_Community_Hardware_QuadratureEncoder_Community_Hardware_QuadratureEncoder::set_Count___VOID__I4( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); TINYCLR_SET_AND_LEAVE(stack.NotImplementedStub()); TINYCLR_NOCLEANUP(); }
HRESULT Library_Community_Hardware_QuadratureEncoder_Community_Hardware_QuadratureEncoder::GetQuadratureEncoderPinsForChannel___VOID__CommunityHardwareQuadratureEncoderChannel__BYREF_MicrosoftSPOTHardwareMicrosoftSPOTHardwareCpuPin__BYREF_MicrosoftSPOTHardwareMicrosoftSPOTHardwareCpuPin( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); TINYCLR_SET_AND_LEAVE(stack.NotImplementedStub()); TINYCLR_NOCLEANUP(); }
HRESULT Library_Community_Hardware_QuadratureEncoder_Community_Hardware_QuadratureEncoder::GetIOPin___MicrosoftSPOTHardwareMicrosoftSPOTHardwareCpuPin__I4( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); TINYCLR_SET_AND_LEAVE(stack.NotImplementedStub()); TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_touch_native_Microsoft_SPOT_Touch_TouchEventProcessor::ProcessEvent___MicrosoftSPOTNativeMicrosoftSPOTBaseEvent__U4__U4__mscorlibSystemDateTime( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); TINYCLR_SET_AND_LEAVE(stack.NotImplementedStub()); TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_Reflection_FieldInfo::SetValue___VOID__OBJECT__OBJECT( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_FieldDef_Instance instFD; CLR_RT_TypeDef_Instance instTD; CLR_RT_TypeDescriptor instTDescObj; CLR_RT_TypeDef_Instance instTDField; const CLR_RECORD_FIELDDEF* fd; CLR_RT_HeapBlock* obj; bool fValueType; CLR_RT_HeapBlock& srcVal = stack.Arg2(); CLR_RT_HeapBlock& srcObj = stack.Arg1(); CLR_RT_HeapBlock val; val.Assign( srcVal ); CLR_RT_ProtectFromGC gc( val ); TINYCLR_CHECK_HRESULT(Library_corlib_native_System_Reflection_FieldInfo::Initialize( stack, instFD, instTD, obj )); fd = instFD.m_target; if(fd->flags & CLR_RECORD_FIELDDEF::FD_NoReflection) // don't allow reflection for fields with NoReflection attribute { TINYCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); } TINYCLR_CHECK_HRESULT(instTDescObj.InitializeFromFieldDefinition(instFD)); // make sure the right side object is of the same type as the left side if(NULL != val.Dereference() && !CLR_RT_ExecutionEngine::IsInstanceOf(val, instTDescObj.m_handlerCls)) TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE); fValueType = obj->IsAValueType(); if(fValueType || (c_CLR_RT_DataTypeLookup[ obj->DataType() ].m_flags & CLR_RT_DataTypeLookup::c_OptimizedValueType)) { if(val.Dereference() == NULL || !val.Dereference()->IsBoxed()) TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE); if(fValueType) { _ASSERTE(NULL != obj->Dereference()); if(NULL == obj->Dereference()) TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); instTDField.InitializeFromIndex( obj->Dereference()->ObjectCls() ); } else { instTDField.InitializeFromIndex( *c_CLR_RT_DataTypeLookup[ obj->DataType() ].m_cls ); } TINYCLR_CHECK_HRESULT(val.PerformUnboxing( instTDField )); } else { #if defined(TINYCLR_APPDOMAINS) if(srcObj.IsTransparentProxy()) { _ASSERTE(srcObj.DataType() == DATATYPE_OBJECT); _ASSERTE(srcObj.Dereference() != NULL && srcObj.Dereference()->DataType() == DATATYPE_TRANSPARENT_PROXY); TINYCLR_CHECK_HRESULT(srcObj.Dereference()->TransparentProxyValidate()); TINYCLR_CHECK_HRESULT(srcObj.Dereference()->TransparentProxyAppDomain()->MarshalObject( val, val )); } #endif } switch(obj->DataType()) { case DATATYPE_DATETIME: // Special case. case DATATYPE_TIMESPAN: // Special case. obj->NumericByRef().s8 = val.NumericByRefConst().s8; break; default: obj->Assign( val ); break; } TINYCLR_NOCLEANUP(); }
void SetResult_bool( CLR_RT_StackFrame &stackFrame, bool value ) { NATIVE_PROFILE_CLR_CORE(); stackFrame.SetResult_Boolean( value ); }
void SetResult_double( CLR_RT_StackFrame &stackFrame, CLR_INT64& value ) { NATIVE_PROFILE_CLR_CORE(); stackFrame.SetResult_R8( value ); }
void SetResult_UINT64( CLR_RT_StackFrame &stackFrame, UINT64 value ) { NATIVE_PROFILE_CLR_CORE(); stackFrame.SetResult_U8( value ); }
void SetResult_INT16( CLR_RT_StackFrame &stackFrame, INT16 value ) { NATIVE_PROFILE_CLR_CORE(); stackFrame.SetResult( value, DATATYPE_I2 ); }
void SetResult_CHAR( CLR_RT_StackFrame &stackFrame, CHAR value ) { NATIVE_PROFILE_CLR_CORE(); stackFrame.SetResult( value, DATATYPE_I1 ); }
HRESULT Library_corlib_native_System_AppDomain::LoadInternal___SystemReflectionAssembly__STRING__BOOLEAN__I4__I4__I4__I4( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock* pArgs = &(stack.Arg1()); CLR_RT_AppDomain* appDomainSav; CLR_RT_AppDomain* appDomain; CLR_RT_Assembly* assembly; CLR_RT_Assembly_Index idx; bool fVersion; CLR_INT16 maj, min, build, rev; LPCSTR szAssembly; TINYCLR_CHECK_HRESULT(GetAppDomain( stack.ThisRef(), appDomain, appDomainSav, true )); szAssembly = pArgs[ 0 ].RecoverString(); FAULT_ON_NULL(szAssembly); fVersion = pArgs[ 1 ].NumericByRef().u8 != 0; maj = pArgs[ 2 ].NumericByRef().s4; min = pArgs[ 3 ].NumericByRef().s4; build = pArgs[ 4 ].NumericByRef().s4; rev = pArgs[ 5 ].NumericByRef().s4; if(fVersion && (maj == -1 || min == -1 || build == -1 || rev == -1)) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } if(fVersion) { CLR_RECORD_VERSION ver; ver.iMajorVersion = (CLR_UINT16) maj; ver.iMinorVersion = (CLR_UINT16) min; ver.iBuildNumber = (CLR_UINT16) build; ver.iRevisionNumber = (CLR_UINT16) rev; assembly = g_CLR_RT_TypeSystem.FindAssembly( szAssembly, &ver, true ); FAULT_ON_NULL_HR(assembly, CLR_E_INVALID_PARAMETER); } else { assembly = g_CLR_RT_TypeSystem.FindAssembly( szAssembly, NULL, false ); FAULT_ON_NULL_HR(assembly, CLR_E_INVALID_PARAMETER); } TINYCLR_CHECK_HRESULT(appDomain->LoadAssembly( assembly )); { CLR_RT_HeapBlock& top = stack.PushValue(); CLR_RT_HeapBlock* hbObj; idx.Set( assembly->m_idx ); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(top, g_CLR_RT_WellKnownTypes.m_Assembly)); hbObj = top.Dereference(); hbObj->SetReflection( idx ); } TINYCLR_CLEANUP(); g_CLR_RT_ExecutionEngine.SetCurrentAppDomain( appDomainSav ); TINYCLR_CLEANUP_END(); }
void SetResult_UINT32( CLR_RT_StackFrame &stackFrame, UINT32 value ) { NATIVE_PROFILE_CLR_CORE(); stackFrame.SetResult( value, DATATYPE_U4 ); }
HRESULT Library_spot_hardware_serial_native_System_IO_Ports_SerialPort::Read___I4__SZARRAY_U1__I4__I4( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_HARDWARE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_Array* readBuffer; CLR_RT_HeapBlock* pThis; CLR_RT_HeapBlock* config; CLR_UINT8* ptr; CLR_INT32 offset; CLR_INT32 count; CLR_INT32 totLength; CLR_INT32 totRead; CLR_RT_HeapBlock* timeout; CLR_INT64* timeoutTicks; CLR_INT32 port; bool fRes; pThis = stack.This(); FAULT_ON_NULL(pThis); // check if the object was disposed if(pThis[ FIELD__m_fDisposed ].NumericByRef().s1 != 0) { TINYCLR_SET_AND_LEAVE(CLR_E_OBJECT_DISPOSED); } config = pThis[ FIELD__m_config ].Dereference(); FAULT_ON_NULL(config); readBuffer = stack.Arg1().DereferenceArray(); FAULT_ON_NULL(readBuffer); offset = stack.Arg2().NumericByRef().s4; count = stack.Arg3().NumericByRef().s4; totLength = readBuffer->m_numOfElements; timeout = &config[ Library_spot_hardware_serial_native_System_IO_Ports_SerialPort__Configuration::FIELD__ReadTimeout ]; port = config[ Library_spot_hardware_serial_native_System_IO_Ports_SerialPort__Configuration::FIELD__PortIndex ].NumericByRef().s4; // // Bound checking. // if(offset < 0 || offset > totLength) { TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE); } if(count == -1) { count = totLength - offset; } else { if(count < 0 || (offset+count) > totLength) { TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE); } } TINYCLR_CHECK_HRESULT(stack.SetupTimeout( *timeout, timeoutTicks )); // // Push "totRead" onto the eval stack. // if(stack.m_customState == 1) { stack.PushValueI4( 0 ); stack.m_customState = 2; } //--// totRead = stack.m_evalStack[ 1 ].NumericByRef().s4; ptr = readBuffer->GetFirstElement(); ptr += offset + totRead; count -= totRead; fRes = true; while(fRes && count > 0) { int read = ::USART_Read( port, (char*)ptr, count ); if(read == 0) { stack.m_evalStack[ 1 ].NumericByRef().s4 = totRead; TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeoutTicks, CLR_RT_ExecutionEngine::c_Event_SerialPort, fRes )); } else if(read < 0) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } else { ptr += read; totRead += read; count -= read; } } stack.PopValue(); // totRead stack.PopValue(); // Timeout stack.SetResult_I4( totRead ); TINYCLR_NOCLEANUP(); }
void SetResult_float( CLR_RT_StackFrame &stackFrame, CLR_INT32 value ) { NATIVE_PROFILE_CLR_CORE(); stackFrame.SetResult_R4( value ); }
HRESULT Library_spot_native_Microsoft_SPOT_Reflection::GetAssemblyMemoryInfo___STATIC__BOOLEAN__mscorlibSystemReflectionAssembly__MicrosoftSPOTReflectionAssemblyMemoryInfo( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_Assembly_Instance assm; const CLR_RECORD_ASSEMBLY* header = NULL; TINYCLR_CHECK_HRESULT(Library_corlib_native_System_Reflection_Assembly::GetTypeDescriptor( *stack.Arg0().Dereference(), assm )); header = assm.m_assm->m_header; if(header->GoodAssembly()) { CLR_RT_HeapBlock* dst = stack.Arg1().Dereference(); FAULT_ON_NULL(dst); CLR_RT_Assembly::Offsets offsets; offsets.iBase = ROUNDTOMULTIPLE(sizeof(CLR_RT_Assembly) , CLR_UINT32); offsets.iAssemblyRef = ROUNDTOMULTIPLE(assm.m_assm->m_pTablesSize[ TBL_AssemblyRef ] * sizeof(CLR_RT_AssemblyRef_CrossReference), CLR_UINT32); offsets.iTypeRef = ROUNDTOMULTIPLE(assm.m_assm->m_pTablesSize[ TBL_TypeRef ] * sizeof(CLR_RT_TypeRef_CrossReference ), CLR_UINT32); offsets.iFieldRef = ROUNDTOMULTIPLE(assm.m_assm->m_pTablesSize[ TBL_FieldRef ] * sizeof(CLR_RT_FieldRef_CrossReference ), CLR_UINT32); offsets.iMethodRef = ROUNDTOMULTIPLE(assm.m_assm->m_pTablesSize[ TBL_MethodRef ] * sizeof(CLR_RT_MethodRef_CrossReference ), CLR_UINT32); offsets.iTypeDef = ROUNDTOMULTIPLE(assm.m_assm->m_pTablesSize[ TBL_TypeDef ] * sizeof(CLR_RT_TypeDef_CrossReference ), CLR_UINT32); offsets.iFieldDef = ROUNDTOMULTIPLE(assm.m_assm->m_pTablesSize[ TBL_FieldDef ] * sizeof(CLR_RT_FieldDef_CrossReference ), CLR_UINT32); offsets.iMethodDef = ROUNDTOMULTIPLE(assm.m_assm->m_pTablesSize[ TBL_MethodDef ] * sizeof(CLR_RT_MethodDef_CrossReference ), CLR_UINT32); #if !defined(TINYCLR_APPDOMAINS) offsets.iStaticFields = ROUNDTOMULTIPLE(assm.m_assm->m_iStaticFields * sizeof(CLR_RT_HeapBlock ), CLR_UINT32); #endif #if defined(TINYCLR_ENABLE_SOURCELEVELDEBUGGING) offsets.iDebuggingInfoMethods = ROUNDTOMULTIPLE(assm.m_assm->m_pTablesSize[ TBL_MethodDef ] * sizeof(CLR_RT_MethodDef_DebuggingInfo ), CLR_UINT32); #endif //#if defined(TINYCLR_ENABLE_SOURCELEVELDEBUGGING) size_t iTotalRamSize = offsets.iBase + offsets.iAssemblyRef + offsets.iTypeRef + offsets.iFieldRef + offsets.iMethodRef + offsets.iTypeDef + offsets.iFieldDef + offsets.iMethodDef; #if !defined(TINYCLR_APPDOMAINS) iTotalRamSize += offsets.iStaticFields; #endif #if defined(TINYCLR_ENABLE_SOURCELEVELDEBUGGING) iTotalRamSize += offsets.iDebuggingInfoMethods; #endif //#if defined(TINYCLR_ENABLE_SOURCELEVELDEBUGGING) size_t iMetaData = header->SizeOfTable( TBL_AssemblyRef ) + header->SizeOfTable( TBL_TypeRef ) + header->SizeOfTable( TBL_FieldRef ) + header->SizeOfTable( TBL_MethodRef ) + header->SizeOfTable( TBL_TypeDef ) + header->SizeOfTable( TBL_FieldDef ) + header->SizeOfTable( TBL_MethodDef ) + header->SizeOfTable( TBL_Attributes ) + header->SizeOfTable( TBL_TypeSpec ) + header->SizeOfTable( TBL_Signatures ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__RamSize ].SetInteger( iTotalRamSize , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__RomSize ].SetInteger( ROUNDTOMULTIPLE(assm.m_assm->m_header->TotalSize(), CLR_INT32) , DATATYPE_I4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__MetadataSize ].SetInteger( iMetaData , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__AssemblyRef ].SetInteger( offsets.iAssemblyRef , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__AssemblyRefElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_AssemblyRef ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__TypeRef ].SetInteger( offsets.iTypeRef , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__TypeRefElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_TypeRef ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__FieldRef ].SetInteger( offsets.iFieldRef , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__FieldRefElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_FieldRef ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__MethodRef ].SetInteger( offsets.iMethodRef , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__MethodRefElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_MethodRef ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__TypeDef ].SetInteger( offsets.iTypeDef , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__TypeDefElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_TypeDef ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__FieldDef ].SetInteger( offsets.iFieldDef , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__FieldDefElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_FieldDef ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__MethodDef ].SetInteger( offsets.iMethodDef , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__MethodDefElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_MethodDef ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__StaticFields ].SetInteger( assm.m_assm->m_iStaticFields , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__Attributes ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_Attributes ] * sizeof(CLR_RECORD_ATTRIBUTE), DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__AttributesElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_Attributes ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__TypeSpec ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_TypeSpec ] * sizeof(CLR_RECORD_TYPESPEC ), DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__TypeSpecElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_TypeSpec ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__Resources ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_Resources ] * sizeof(CLR_RECORD_RESOURCE ), DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__ResourcesElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_Resources ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__ResourcesFiles ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_ResourcesFiles ] * sizeof(CLR_RECORD_RESOURCE ), DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__ResourcesFilesElements ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_ResourcesFiles ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__ResourcesData ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_ResourcesData ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__Strings ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_Strings ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__Signatures ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_Signatures ] , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyMemoryInfo::FIELD__ByteCode ].SetInteger( assm.m_assm->m_pTablesSize[ TBL_ByteCode ] , DATATYPE_U4 ); stack.SetResult_Boolean( true ); } else { stack.SetResult_Boolean( false ); } TINYCLR_NOCLEANUP(); }
void SetResult_LPCSTR( CLR_RT_StackFrame &stackFrame, LPCSTR lpszString ) { NATIVE_PROFILE_CLR_CORE(); stackFrame.SetResult_String( lpszString ); }
HRESULT Library_spot_native_Microsoft_SPOT_Reflection::GetTypesImplementingInterface___STATIC__SZARRAY_mscorlibSystemType__mscorlibSystemType( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock& top = stack.PushValueAndClear(); int tot = 0; CLR_RT_HeapBlock* pArray = NULL; CLR_RT_TypeDef_Instance tdMatch; CLR_RT_HeapBlock* hbType = stack.Arg0().Dereference(); TINYCLR_CHECK_HRESULT(Library_corlib_native_System_RuntimeType::GetTypeDescriptor( *hbType, tdMatch )); if((tdMatch.m_target->flags & CLR_RECORD_TYPEDEF::TD_Semantics_Mask) != CLR_RECORD_TYPEDEF::TD_Semantics_Interface) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } for(int pass=0; pass<2; pass++) { int count = 0; TINYCLR_FOREACH_ASSEMBLY_IN_CURRENT_APPDOMAIN(g_CLR_RT_TypeSystem) { const CLR_RECORD_TYPEDEF* td = pASSM->GetTypeDef( 0 ); int tblSize = pASSM->m_pTablesSize[ TBL_TypeDef ]; for(int i=0; i<tblSize; i++, td++) { if(td->flags & CLR_RECORD_TYPEDEF::TD_Abstract) continue; CLR_RT_TypeDef_Index idx; idx.Set( pASSM->m_idx, i ); if(CLR_RT_ExecutionEngine::IsInstanceOf( idx, tdMatch )) { if(pass == 0) { tot++; } else { CLR_RT_HeapBlock* hbObj; TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(pArray[count], g_CLR_RT_WellKnownTypes.m_TypeStatic)); hbObj = pArray[count].Dereference(); hbObj->SetReflection( idx ); } count++; } } } TINYCLR_FOREACH_ASSEMBLY_IN_CURRENT_APPDOMAIN_END(); if(pass == 0) { if(tot == 0) break; TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( top, tot, g_CLR_RT_WellKnownTypes.m_TypeStatic )); CLR_RT_HeapBlock_Array* array = top.DereferenceArray(); pArray = (CLR_RT_HeapBlock*)array->GetFirstElement(); } } TINYCLR_NOCLEANUP(); }