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_corlib_native_System_Reflection_Assembly::GetExecutingAssembly___STATIC__SystemReflectionAssembly( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock& top = stack.PushValueAndClear(); CLR_RT_HeapBlock* hbObj; CLR_RT_StackFrame* caller = stack.Caller(); if(caller == NULL) TINYCLR_SET_AND_LEAVE(S_OK); { CLR_RT_Assembly_Index idx; idx.Set( caller->MethodCall().m_assm->m_idx ); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(top, g_CLR_RT_WellKnownTypes.m_Assembly)); hbObj = top.Dereference(); hbObj->SetReflection( idx ); } TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_Delegate::get_Method___SystemReflectionMethodInfo( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_Delegate* dlg = stack.Arg0().DereferenceDelegate(); dlg = GetLastDelegate( dlg ); if(!dlg) TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE); { CLR_RT_HeapBlock& top = stack.PushValue(); CLR_RT_HeapBlock* hbObj; TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(top, g_CLR_RT_WellKnownTypes.m_MethodInfo)); hbObj = top.Dereference(); hbObj->SetReflection( dlg->DelegateFtn() ); } TINYCLR_NOCLEANUP(); }
HRESULT CLR_RT_HeapBlock_String::CreateInstance( CLR_RT_HeapBlock& reference, LPCSTR szText, CLR_RT_Assembly* assm ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_String* str; reference.SetObjectReference( NULL ); str = (CLR_RT_HeapBlock_String*)g_CLR_RT_ExecutionEngine.ExtractHeapBytesForObjects( DATATYPE_STRING, 0, sizeof(CLR_RT_HeapBlock_String) ); CHECK_ALLOCATION(str); reference.SetObjectReference( str ); #if defined(TINYCLR_NO_ASSEMBLY_STRINGS) TINYCLR_CHECK_HRESULT( CLR_RT_HeapBlock_String::CreateInstance( reference, assm->GetString( CLR_DataFromTk( token ) ) )); #else str->SetStringText( szText, assm ); #endif TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_update_native_Microsoft_SPOT_MFUpdate_MFNativeUpdate::SerializeParameter___STATIC__SZARRAY_U1__OBJECT( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_INT32 offset = 0, size = 0; CLR_RT_HeapBlock &ref = stack.PushValueAndClear(); CLR_UINT8* pData; CLR_RT_HeapBlock& obj = stack.Arg0(); if(!SerializeObject( &obj, NULL, offset, size ) || size <= 0) TINYCLR_SET_AND_LEAVE(CLR_E_FAIL); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance(ref, size, g_CLR_RT_WellKnownTypes.m_UInt8)); pData = (CLR_UINT8*)ref.DereferenceArray()->GetFirstElement(); offset = 0; if(!SerializeObject( &obj, pData, offset, size )) TINYCLR_SET_AND_LEAVE(CLR_E_FAIL); TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_Resources_ResourceManager::GetObject___STATIC__OBJECT__SystemResourcesResourceManager__SystemEnum__I4__I4( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock& blkResourceManager = stack.Arg0(); CLR_RT_MethodDef_Instance md; if(stack.m_customState == 0) { stack.m_customState = 1; //call back into ResourceManager.GetObjectFromId(short id, int offset, int length); _SIDE_ASSERTE(md.InitializeFromIndex( g_CLR_RT_WellKnownMethods.m_ResourceManager_GetObjectChunkFromId )); TINYCLR_CHECK_HRESULT( stack.MakeCall( md, &blkResourceManager, &stack.Arg1(), 3 )); } TINYCLR_NOCLEANUP(); }
HRESULT CLR_RT_HeapBlock_Array::ClearElements( int index, int length ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); const CLR_RT_ReflectionDef_Index& reflex = ReflectionDataConst(); CLR_UINT8* data = GetElement( index ); CLR_RT_Memory::ZeroFill( data, length * m_sizeOfElement ); if(m_fReference) { CLR_DataType dt = (CLR_DataType)m_typeOfElement; bool fAllocate = (reflex.m_levels == 1 && dt == DATATYPE_VALUETYPE); CLR_RT_HeapBlock* ptr = (CLR_RT_HeapBlock*)data; switch(dt) { case DATATYPE_VALUETYPE: case DATATYPE_CLASS: case DATATYPE_WEAKCLASS: dt = DATATYPE_OBJECT; break; } while(length > 0) { ptr->SetDataId( CLR_RT_HEAPBLOCK_RAW_ID(dt,0,1) ); if(fAllocate) { TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( *ptr, reflex.m_data.m_type )); } ptr++; length--; } } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_native_Microsoft_SPOT_Messaging_EndPoint::_ctor___VOID__mscorlibSystemType__U4( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_MESSAGING(); TINYCLR_HEADER(); CLR_RT_HeapBlock* pThis = stack.This(); CLR_RT_HeapBlock_EndPoint::Port port; CLR_RT_HeapBlock_EndPoint* ep; CLR_RT_HeapBlock* hbType = stack.Arg1().Dereference(); FAULT_ON_NULL(pThis); FAULT_ON_NULL(hbType); if(CLR_RT_ReflectionDef_Index::Convert( *hbType, port.m_type ) == false) TINYCLR_SET_AND_LEAVE(CLR_E_NULL_REFERENCE); port.m_id = stack.Arg2().NumericByRefConst().u4; ep = CLR_RT_HeapBlock_EndPoint::FindEndPoint( port ); if(ep) TINYCLR_SET_AND_LEAVE(CLR_E_BUSY); TINYCLR_SET_AND_LEAVE(CLR_RT_HeapBlock_EndPoint::CreateInstance( port, *pThis, pThis[ FIELD__m_handle ] )); 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_spot_native_Microsoft_SPOT_CryptoState::Buffer::Allocate( CLR_RT_HeapBlock& ref, int size ) { TINYCLR_HEADER(); ref.SetObjectReference( NULL ); if(size) { TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( ref, size, g_CLR_RT_WellKnownTypes.m_UInt8 )); m_array = ref.DereferenceArray(); } else { m_array = NULL; } m_offset = 0; m_count = size; TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_BitConverter::GetBytes___STATIC__SZARRAY_U1__R8(CLR_RT_StackFrame& stack) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); #if !defined(TINYCLR_EMULATED_FLOATINGPOINT) double input = stack.Arg0().NumericByRefConst().r8; #else CLR_INT64 input = stack.Arg0().NumericByRefConst().r8; #endif TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance(stack.PushValueAndClear(), 8, g_CLR_RT_WellKnownTypes.m_UInt8)); { BYTE* p = stack.TopValue().DereferenceArray()->GetFirstElement(); #if !defined(TINYCLR_EMULATED_FLOATINGPOINT) *reinterpret_cast<double*>(p) = input; #else *reinterpret_cast<CLR_INT64*>(p) = input; #endif } TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_BitConverter::ToString___STATIC__STRING__SZARRAY_U1(CLR_RT_StackFrame& stack) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_Array* pArray = stack.Arg0().DereferenceArray(); FAULT_ON_NULL_ARG(pArray); if (pArray->m_numOfElements == 0) { TINYCLR_CHECK_HRESULT(stack.SetResult_String("")); } else { BYTE* p = pArray->GetFirstElement(); char* pOutput = ByteArrayToHex(p, 0, pArray->m_numOfElements); TINYCLR_CHECK_HRESULT(stack.SetResult_String(pOutput)); delete[] pOutput; } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_Port::Read___BOOLEAN( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_HARDWARE(); TINYCLR_HEADER(); CLR_UINT32 state; 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); } // Read state from Hardware state = ::CPU_GPIO_GetPinState( pThis[ FIELD__m_portId ].NumericByRefConst().u4 ); // Return value to the managed application. stack.SetResult_Boolean( state == 0 ? false : true ) ; TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_net_security_native_Microsoft_SPOT_Net_Security_SslNative::DataAvailable___STATIC__I4__OBJECT( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); CLR_RT_HeapBlock* socket = stack.Arg0().Dereference(); int result; CLR_INT32 handle; FAULT_ON_NULL(socket); handle = socket[ Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::FIELD__m_Handle ].NumericByRef().s4; result = SSL_DataAvailable( handle ); // ThrowOnError expects anything other than 0 to be a failure - so return 0 if we don't have an error TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result >= 0 ? 0 : result )); stack.SetResult_I4( result ); TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_RuntimeType::get_BaseType___SystemType( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_TypeDef_Instance td; CLR_UINT32 levels; CLR_RT_HeapBlock& top = stack.PushValueAndClear(); TINYCLR_CHECK_HRESULT(GetTypeDescriptor( stack.Arg0(), td, &levels )); if(levels > 0) { top.SetReflection( g_CLR_RT_WellKnownTypes.m_Array ); } else if(td.SwitchToParent()) { top.SetReflection( td ); } TINYCLR_NOCLEANUP(); }
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_corlib_native_System_Text_UTF8Encoding::GetBytes___SZARRAY_U1__STRING( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); size_t cBytes; CLR_RT_HeapBlock_Array* arr; LPCSTR str; CLR_RT_HeapBlock& ret = stack.PushValueAndClear(); str = stack.Arg1().RecoverString(); FAULT_ON_NULL(str); cBytes = hal_strlen_s(str); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( ret, (CLR_UINT32)cBytes, g_CLR_RT_WellKnownTypes.m_UInt8 )); arr = ret.DereferenceArray(); memcpy( arr->GetFirstElement(), str, cBytes ); TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_Threading_Monitor::Enter___STATIC__VOID__OBJECT( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_StackFrame* caller = NULL; if(stack.Arg0().Dereference() == NULL) { TINYCLR_SET_AND_LEAVE(CLR_E_ARGUMENT_NULL); } switch(stack.m_customState) { case 0: { caller = stack.Caller(); FAULT_ON_NULL(caller); // We need to set the constraint on the caller, not on us... hr = g_CLR_RT_ExecutionEngine.LockObject( stack.Arg0(), caller->m_owningSubThread, TIMEOUT_INFINITE, false ); if(hr == CLR_E_THREAD_WAITING) { stack.m_customState = 1; } TINYCLR_LEAVE(); } break; case 1: TINYCLR_SET_AND_LEAVE(S_OK); break; default: TINYCLR_SET_AND_LEAVE(CLR_E_FAIL); } TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_RuntimeType::GetName( CLR_RT_HeapBlock& arg, bool fFullName, CLR_RT_HeapBlock& res ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_TypeDef_Instance td; CLR_UINT32 levels; char rgBuffer[ 256 ]; LPSTR szBuffer; size_t iBuffer; TINYCLR_CHECK_HRESULT(GetTypeDescriptor( arg, td, &levels )); szBuffer = rgBuffer; iBuffer = MAXSTRLEN(rgBuffer); TINYCLR_CHECK_HRESULT(g_CLR_RT_TypeSystem.BuildTypeName( td, szBuffer, iBuffer, fFullName ? CLR_RT_TypeSystem::TYPENAME_FLAGS_FULL : 0, levels )); TINYCLR_SET_AND_LEAVE(CLR_RT_HeapBlock_String::CreateInstance( res, rgBuffer )); TINYCLR_NOCLEANUP(); }
HRESULT FAT_FINDFILES::FindNext( FS_FILEINFO *fi, BOOL *fileFound ) { TINYCLR_HEADER(); FAT_FILE fileInfo; FAT_Directory* dirEntry; if(!fi || !fileFound) { TINYCLR_SET_AND_LEAVE(CLR_E_FILE_IO); } do { if(fileInfo.Parse( m_logicDisk, &m_entryEnum ) != S_OK) { *fileFound = FALSE; TINYCLR_SET_AND_LEAVE(S_OK); } dirEntry = fileInfo.GetDirectoryEntry(); if(!dirEntry) TINYCLR_SET_AND_LEAVE(CLR_E_FILE_IO); } while(dirEntry->DIR_Name[0] == '.' || dirEntry->DIR_Attr == ATTR_VOLUME_ID); // Skip the "." and ".." and the Volume_ID entries fi->Attributes = dirEntry->DIR_Attr; fi->Size = dirEntry->Get_DIR_FileSize(); fi->CreationTime = FAT_Utility::FATTimeToTicks( dirEntry->Get_DIR_CrtDate() , dirEntry->Get_DIR_CrtTime(), dirEntry->DIR_CrtTimeTenth ); fi->LastAccessTime = FAT_Utility::FATTimeToTicks( dirEntry->Get_DIR_LstAccDate(), 0 , 0 ); fi->LastWriteTime = FAT_Utility::FATTimeToTicks( dirEntry->Get_DIR_WrtDate() , dirEntry->Get_DIR_WrtTime(), 0 ); TINYCLR_CHECK_HRESULT(fileInfo.CopyFileName( (LPWSTR)(fi->FileName), fi->FileNameSize )); *fileFound = TRUE; 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(); }
static HRESULT Microsoft_SPOT_Hardware_InterruptPort_EnableInterrupt( CLR_RT_HeapBlock* pThis, CLR_RT_HeapBlock_NativeEventDispatcher* pIOPort ) { TINYCLR_HEADER(); { CLR_INT32 &flags = pThis[ Library_spot_hardware_native_Microsoft_SPOT_Hardware_Port::FIELD__m_flags ].NumericByRef().s4; CLR_UINT32 portId = pThis[ Library_spot_hardware_native_Microsoft_SPOT_Hardware_Port::FIELD__m_portId ].NumericByRef().u4; CLR_INT32 glitchFilterEnable = pThis[ Library_spot_hardware_native_Microsoft_SPOT_Hardware_Port::FIELD__m_glitchFilterEnable ].NumericByRef().s4; GPIO_RESISTOR resistorMode = (GPIO_RESISTOR)pThis[ Library_spot_hardware_native_Microsoft_SPOT_Hardware_Port::FIELD__m_resistorMode ].NumericByRef().s4; GPIO_INT_EDGE interruptMode = (GPIO_INT_EDGE)pThis[ Library_spot_hardware_native_Microsoft_SPOT_Hardware_Port::FIELD__m_interruptMode ].NumericByRef().s4; if(flags & GPIO_PortParams::c_Disposed) { TINYCLR_SET_AND_LEAVE(CLR_E_PIN_DEAD); } if(flags & GPIO_PortParams::c_InterruptDisabled) { flags &= ~GPIO_PortParams::c_InterruptDisabled; if( !::CPU_GPIO_EnableInputPin2( portId, glitchFilterEnable, Library_spot_hardware_native_Microsoft_SPOT_Hardware_Port::IsrProcedure, pIOPort, interruptMode, resistorMode ) ) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } } } 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::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_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiSign::SignInit___VOID__MicrosoftSPOTCryptokiSession__MicrosoftSPOTCryptokiMechanism__SystemSecurityCryptographyCryptoKey( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock* pSession = stack.Arg1().Dereference(); CLR_RT_HeapBlock* pMech = stack.Arg2().Dereference(); CLR_RT_HeapBlock* pKeyHandle = stack.Arg3().Dereference(); CLR_RT_HeapBlock_Array* pArrParam; CK_MECHANISM mech; CK_OBJECT_HANDLE hKey; CK_SESSION_HANDLE hSession; FAULT_ON_NULL_ARG(pSession); FAULT_ON_NULL_ARG(pMech); hSession = (CK_SESSION_HANDLE)pSession[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Session::FIELD__m_handle].NumericByRef().s4; mech.mechanism = pMech[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Mechanism::FIELD__Type].NumericByRef().u4; pArrParam = pMech[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Mechanism::FIELD__Parameter].DereferenceArray(); if(pArrParam != NULL && pArrParam->m_numOfElements > 0) { mech.pParameter = pArrParam->GetFirstElement(); mech.ulParameterLen = pArrParam->m_numOfElements; } else { mech.pParameter = NULL; mech.ulParameterLen = 0; } hKey = (CK_OBJECT_HANDLE)pKeyHandle[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiObject::FIELD__m_handle].NumericByRef().s4; CRYPTOKI_CHECK_RESULT(stack, C_SignInit(hSession, &mech, hKey)); TINYCLR_NOCLEANUP(); }
HRESULT Library_windows_devices_native_Windows_Devices_Gpio_GpioPin::set_DebounceTimeout___VOID__mscorlibSystemTimeSpan( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); GPIO_PIN pin; CLR_INT64 value; 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); } value = (CLR_INT64_TEMP_CAST) stack.Arg1().NumericByRef().s8 / TIME_CONVERSION__TO_MILLISECONDS; pin = (GPIO_PIN)( pThis[ FIELD__m_pinNumber ].NumericByRefConst().u4 ); if (!::CPU_GPIO_SetPinDebounce( pin, value )) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } TINYCLR_SET_AND_LEAVE(stack.NotImplementedStub()); TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_I2CDevice__Configuration::GetInitialConfig(CLR_RT_HeapBlock& ref, I2C_USER_CONFIGURATION& nativeConfig) { NATIVE_PROFILE_CLR_HARDWARE(); TINYCLR_HEADER(); CLR_RT_HeapBlock* config = ref.Dereference(); FAULT_ON_NULL(config); nativeConfig.Address = config[ FIELD__Address ].NumericByRef().u2; nativeConfig.ClockRate = config[ FIELD__ClockRateKhz ].NumericByRef().s4; if(nativeConfig.Address > c_MaxI2cAddress) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } if(nativeConfig.ClockRate < c_MimimumClockRateKhz || c_MaximumClockRateKhz < nativeConfig.ClockRate) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER) } TINYCLR_NOCLEANUP(); }
HRESULT Library_windows_devices_native_Windows_Devices_Gpio_GpioPin::Write___VOID__WindowsDevicesGpioGpioPinValue( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); BOOL state; 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); } pThis[ FIELD__m_lastOutputValue ].NumericByRef().s4 = stack.Arg1().NumericByRef().s4; state = (stack.Arg1().NumericByRef().s4 != GpioPinValue_Low); // If the current drive mode is set to output, write the value to the pin. if (pThis[ FIELD__m_driveMode ].NumericByRefConst().s4 == GpioPinDriveMode_Output) { ::CPU_GPIO_SetPinState( pThis[ FIELD__m_pinNumber ].NumericByRefConst().u4, state ); } TINYCLR_NOCLEANUP(); }
HRESULT Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiDigest::DigestKeyInternal___VOID__SystemSecurityCryptographyCryptoKey( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock* pThis = stack.This(); CLR_RT_HeapBlock* phKey = stack.Arg1().Dereference(); CLR_RT_HeapBlock* pSession = pThis[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_SessionContainer::FIELD__m_session].Dereference(); CK_SESSION_HANDLE hSession; CK_OBJECT_HANDLE hKey; FAULT_ON_NULL_ARG(phKey); FAULT_ON_NULL(pSession); 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); hKey = (CK_OBJECT_HANDLE)phKey[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiObject::FIELD__m_handle].NumericByRef().s4; CRYPTOKI_CHECK_RESULT(stack, C_DigestKey(hSession, hKey)); TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_HardwareProvider::NativeIsSupportedBaudRate___BOOLEAN__I4__BYREF_U4( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock hbBR; CLR_UINT32 port; CLR_UINT32 SupportedBaudrate; port = stack.Arg1().NumericByRef().u4; TINYCLR_CHECK_HRESULT(hbBR.LoadFromReference( stack.Arg2() )); SupportedBaudrate = hbBR.NumericByRef().u4; if (CPU_USART_IsBaudrateSupported(port,SupportedBaudrate) == TRUE) stack.SetResult_Boolean( true ); else stack.SetResult_Boolean( false ); hbBR.SetInteger( (CLR_UINT32)SupportedBaudrate ); TINYCLR_CHECK_HRESULT(hbBR.StoreToReference( stack.Arg2(), 0 )); TINYCLR_NOCLEANUP(); }