HRESULT Library_corlib_native_System_Reflection_RuntimeMethodInfo::get_ReturnType___SystemType( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_MethodDef_Instance md; CLR_RT_SignatureParser parser; CLR_RT_TypeDescriptor desc; CLR_RT_HeapBlock* hbMeth = stack.Arg0().Dereference(); TINYCLR_CHECK_HRESULT(Library_corlib_native_System_Reflection_MethodBase::GetMethodDescriptor( stack, *hbMeth, md )); parser.Initialize_MethodSignature( md.m_assm, md.m_target ); TINYCLR_CHECK_HRESULT(desc.InitializeFromSignatureParser( parser )); { CLR_RT_HeapBlock& top = stack.PushValue(); CLR_RT_HeapBlock* hbObj; TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(top, g_CLR_RT_WellKnownTypes.m_TypeStatic)); hbObj = top.Dereference(); hbObj->SetReflection( desc.m_reflex ); } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_native_Microsoft_SPOT_Hardware_Utility::CombineArrays( CLR_RT_StackFrame& stack, CLR_RT_HeapBlock& ref1, int offset1, int count1, CLR_RT_HeapBlock& ref2, int offset2, int count2 ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_Array* array1; CLR_RT_HeapBlock_Array* array2; array1 = ref1.DereferenceArray(); FAULT_ON_NULL(array1); array2 = ref2.DereferenceArray(); FAULT_ON_NULL(array2); if(array1->SameHeader( *array2 ) == false) { TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE); } if(count1 < 0) count1 = array1->m_numOfElements; if(count2 < 0) count2 = array2->m_numOfElements; { CLR_RT_HeapBlock& ref = stack.PushValue(); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( ref, count1 + count2, array1->ReflectionDataConst() )); TINYCLR_CHECK_HRESULT(Library_corlib_native_System_Array::Copy( stack, ref1, offset1, ref, 0, count1 )); TINYCLR_CHECK_HRESULT(Library_corlib_native_System_Array::Copy( stack, ref2, offset2, ref, count1, count2 )); } TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_Reflection_ConstructorInfo::Invoke___OBJECT__SZARRAY_OBJECT( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock* thisRef = stack.ThisRef().Dereference(); CLR_RT_MethodDef_Instance md; CLR_RT_HeapBlock_Array* pArray = stack.Arg1().DereferenceArray(); CLR_RT_HeapBlock* args = NULL; int numArgs = 0; if(md.InitializeFromIndex( thisRef->ReflectionDataConst().m_data.m_method ) == false) TINYCLR_SET_AND_LEAVE(CLR_E_NULL_REFERENCE); if(stack.m_customState == 0) { stack.m_customState = 1; if(pArray) { args = (CLR_RT_HeapBlock*)pArray->GetFirstElement(); numArgs = pArray->m_numOfElements; } TINYCLR_CHECK_HRESULT(stack.MakeCall( md, NULL, args, numArgs )); } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_net_security_native_Microsoft_SPOT_Net_Security_SslNative::SecureConnect___STATIC__VOID__I4__STRING__OBJECT( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); CLR_INT32 sslContext = stack.Arg0().NumericByRef().s4; CLR_RT_HeapBlock* hb = stack.Arg1().DereferenceString(); CLR_RT_HeapBlock* socket = stack.Arg2().Dereference(); CLR_INT32 timeout_ms = -1; // wait forever CLR_RT_HeapBlock hbTimeout; int result; LPCSTR szName; CLR_INT32 handle; bool fRes = true; CLR_INT64 *timeout; FAULT_ON_NULL(socket); handle = socket[ Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::FIELD__m_Handle ].NumericByRef().s4; /* Because we could have been a rescheduled call due to a prior call that would have blocked, we need to see * if our handle has been shutdown before continuing. */ if (handle == Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::DISPOSED_HANDLE) { ThrowError( stack, CLR_E_OBJECT_DISPOSED ); TINYCLR_SET_AND_LEAVE(CLR_E_PROCESS_EXCEPTION); } FAULT_ON_NULL_ARG(hb); szName = hb->StringText(); hbTimeout.SetInteger( timeout_ms ); TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout )); while(true) { result = SSL_Connect( handle, szName, sslContext ); if(result == SOCK_EWOULDBLOCK || result == SOCK_TRY_AGAIN) { // non-blocking - allow other threads to run while we wait for socket activity TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_Socket, fRes )); if(result < 0) break; } else { break; } } stack.PopValue(); // Timeout TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result )); TINYCLR_NOCLEANUP(); }
HRESULT Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_FindObjectEnum::FindObjectsInit___VOID__SZARRAY_MicrosoftSPOTCryptokiCryptokiAttribute( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock* pThis = stack.This(); CLR_RT_HeapBlock_Array* pAttribs = stack.Arg1().DereferenceArray(); CLR_RT_HeapBlock* pAttrib; CLR_RT_HeapBlock* pSession = pThis[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_FindObjectEnum::FIELD__m_session].Dereference(); CK_SESSION_HANDLE hSession; CK_ATTRIBUTE attribs[20]; CLR_UINT32 i; FAULT_ON_NULL_ARG(pAttribs); FAULT_ON_NULL(pSession); if(pAttribs->m_numOfElements > ARRAYSIZE(attribs)) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE); hSession = pSession[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Session::FIELD__m_handle].NumericByRef().u4; pAttrib = (CLR_RT_HeapBlock*)pAttribs->GetFirstElement(); for(i=0; i<pAttribs->m_numOfElements; i++) { CLR_RT_HeapBlock* pElement = pAttrib->Dereference(); FAULT_ON_NULL(pElement); CLR_RT_HeapBlock_Array* pValueArray = pElement[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiAttribute::FIELD__Value].DereferenceArray(); FAULT_ON_NULL(pValueArray); attribs[i].type = pElement[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiAttribute::FIELD__Type].NumericByRef().u4; attribs[i].pValue = pValueArray->GetFirstElement(); attribs[i].ulValueLen = pValueArray->m_numOfElements; pAttrib++; } CRYPTOKI_CHECK_RESULT(stack, C_FindObjectsInit(hSession, attribs, pAttribs->m_numOfElements)); TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_Reflection_MethodBase::get_DeclaringType___SystemType( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_MethodDef_Instance md; CLR_RT_TypeDef_Instance cls; CLR_RT_HeapBlock* hbMeth = stack.Arg0().Dereference(); TINYCLR_CHECK_HRESULT(GetMethodDescriptor( stack, *hbMeth, md )); if(cls.InitializeFromMethod( md ) == false) 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_TypeStatic)); hbObj = top.Dereference(); hbObj->SetReflection( cls ); } TINYCLR_NOCLEANUP(); }
HRESULT CLR_RT_HeapBlock_Array::CreateInstance( CLR_RT_HeapBlock& reference, CLR_UINT32 length, CLR_RT_Assembly* assm, CLR_UINT32 tk ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock ref; CLR_RT_TypeDef_Instance cls; CLR_RT_TypeSpec_Instance def; if(cls.ResolveToken( tk, assm )) { ref.SetReflection( cls ); } else if(def.ResolveToken( tk, assm )) { TINYCLR_CHECK_HRESULT(ref.SetReflection( def )); } else { TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE); } ref.ReflectionData().m_levels++; TINYCLR_SET_AND_LEAVE(CreateInstance( reference, length, ref.ReflectionData() )); TINYCLR_NOCLEANUP(); }
HRESULT CLR_RT_XmlState_InValue::ProcessEndWhitespace( CLR_RT_XmlState* st, CLR_UINT8*& buffer, bool& isDone ) { TINYCLR_HEADER(); _ASSERTE(isDone == true); CLR_RT_XmlState_InValue* state = &st->InValue; CLR_RT_HeapBlock* xmlSpace; CLR_RT_XmlSpace xmlSpaceValue; TINYCLR_CHECK_HRESULT(state->reader->GetXmlSpaces()->Peek( xmlSpace )); // note that xmlSpace is boxed _ASSERTE( xmlSpace->DataType() == DATATYPE_VALUETYPE ); xmlSpaceValue = (CLR_RT_XmlSpace)xmlSpace[ 1 ].NumericByRef().s4; if(xmlSpaceValue == XmlSpace_Preserve || !(state->settings & XmlSettings_IgnoreWhitespace)) { TINYCLR_SET_AND_LEAVE(PrepReturn( st, buffer, 0, (xmlSpaceValue == XmlSpace_Preserve) ? XmlNodeType_SignificantWhitespace : XmlNodeType_Whitespace )); } TINYCLR_CLEANUP(); // regardless of result, we'll set up the next state. note that it's not possible to get XML_E_NEED_MORE_DATA here CLR_RT_XmlState_NewTag::Setup( st ); TINYCLR_CLEANUP_END(); }
HRESULT Library_corlib_native_System_Resources_ResourceManager::GetObject___STATIC__OBJECT__SystemResourcesResourceManager__SystemEnum( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock& blkResourceManager = stack.Arg0(); CLR_RT_HeapBlock& blkEnumObj = stack.Arg1(); CLR_RT_HeapBlock* blkVT = blkEnumObj.Dereference(); CLR_RT_HeapBlock* blkEnum = blkVT + 1; CLR_RT_MethodDef_Instance md; if(stack.m_customState == 0) { stack.m_customState = 1; FAULT_ON_NULL(blkVT); if(blkEnum->DataType() != DATATYPE_I2 && blkEnum->DataType() != DATATYPE_U2) TINYCLR_SET_AND_LEAVE( CLR_E_INVALID_PARAMETER ); //call back into ResourceManager.GetObjectFromId(short id); _SIDE_ASSERTE(md.InitializeFromIndex( g_CLR_RT_WellKnownMethods.m_ResourceManager_GetObjectFromId )); TINYCLR_CHECK_HRESULT( stack.MakeCall( md, &blkResourceManager, blkEnum, 1 )); } TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_RuntimeType::GetInterfaces___SZARRAY_SystemType( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_TypeDef_Instance td; CLR_RT_HeapBlock& top = stack.PushValueAndClear(); CLR_RT_HeapBlock* ptr; TINYCLR_CHECK_HRESULT(GetTypeDescriptor( stack.Arg0(), td )); // // Scan the list of interfaces. // CLR_RT_SignatureParser parser; parser.Initialize_Interfaces( td.m_assm, td.m_target ); CLR_RT_SignatureParser::Element res; TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( top, parser.Available(), g_CLR_RT_WellKnownTypes.m_Type )); ptr = (CLR_RT_HeapBlock*)top.DereferenceArray()->GetFirstElement(); while(parser.Available() > 0) { TINYCLR_CHECK_HRESULT(parser.Advance( res )); ptr->SetReflection( res.m_cls ); ptr++; } TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_Reflection_Assembly::GetTypes___SZARRAY_SystemType( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_Assembly_Instance assm; TINYCLR_CHECK_HRESULT(GetTypeDescriptor( stack.Arg0(), assm )); { CLR_RT_Assembly* pASSM = assm.m_assm; CLR_UINT32 num = pASSM->m_pTablesSize[ TBL_TypeDef ]; CLR_RT_HeapBlock& top = stack.PushValue(); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( top, num, g_CLR_RT_WellKnownTypes.m_Type )); if(num) { CLR_RT_HeapBlock* pArray = (CLR_RT_HeapBlock*)top.DereferenceArray()->GetFirstElement(); for(CLR_UINT32 i=0; i<num; i++, pArray++) { CLR_RT_TypeDef_Index idx; idx.Set( pASSM->m_idx, i ); pArray->SetReflection( idx ); } } } TINYCLR_NOCLEANUP(); }
HRESULT CLR_RT_StackFrame::PushAppDomainTransition( CLR_RT_Thread* th, const CLR_RT_MethodDef_Instance& callInst, CLR_RT_HeapBlock* pThis, CLR_RT_HeapBlock* pArgs ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_StackFrame* frame = NULL; int cArgs = callInst.m_target->numArgs; CLR_RT_HeapBlock* proxy; _ASSERTE(pThis->IsTransparentProxy()); proxy = pThis->Dereference(); TINYCLR_CHECK_HRESULT(proxy->TransparentProxyValidate()); TINYCLR_CHECK_HRESULT(Push( th, callInst, cArgs )); frame = th->CurrentFrame(); frame->m_appDomain = proxy->TransparentProxyAppDomain(); frame->m_flags |= CLR_RT_StackFrame::c_AppDomainTransition; frame->m_flags &= ~CLR_RT_StackFrame::c_CallerIsCompatibleForRet; //Marshal the arguments from the caller (on the eval stack) to the callee, unitialized heapblocks that //are set up by the extra blocks in CLR_RT_StackFrame::Push TINYCLR_CHECK_HRESULT(frame->m_appDomain->MarshalObject ( *pThis, frame->m_arguments[ 0 ] )); TINYCLR_CHECK_HRESULT(frame->m_appDomain->MarshalParameters( pArgs, &frame->m_arguments[ 1 ], cArgs-1, false )); (void)g_CLR_RT_ExecutionEngine.SetCurrentAppDomain( frame->m_appDomain ); TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_Reflection_Assembly::GetType___SystemType__STRING( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_Assembly_Instance assm; CLR_RT_TypeDef_Index td; CLR_RT_HeapBlock* hbRef; CLR_RT_HeapBlock* hbObj; LPCSTR szClass = stack.Arg1().RecoverString(); CLR_RT_HeapBlock* hbAsm = stack.Arg0().Dereference(); FAULT_ON_NULL(szClass); FAULT_ON_NULL(hbAsm); TINYCLR_CHECK_HRESULT(GetTypeDescriptor( *hbAsm, assm )); hbRef = &stack.PushValueAndClear(); if(g_CLR_RT_TypeSystem.FindTypeDef( szClass, assm.m_assm, td )) { TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(*hbRef, g_CLR_RT_WellKnownTypes.m_TypeStatic)); hbObj = hbRef->Dereference(); hbObj->SetReflection( td ); } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_native_Microsoft_SPOT_Reflection::GetAssemblyFromHash___STATIC__mscorlibSystemReflectionAssembly__U4( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock& top = stack.PushValueAndClear(); CLR_UINT32 hash = stack.Arg0().NumericByRefConst().u4; TINYCLR_FOREACH_ASSEMBLY_IN_CURRENT_APPDOMAIN(g_CLR_RT_TypeSystem) { if(pASSM->ComputeAssemblyHash() == hash) { CLR_RT_HeapBlock* hbObj; CLR_RT_Assembly_Index idx; idx.Set( pASSM->m_idx ); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(top, g_CLR_RT_WellKnownTypes.m_Assembly)); hbObj = top.Dereference(); hbObj->SetReflection( idx ); TINYCLR_SET_AND_LEAVE(S_OK); } } TINYCLR_FOREACH_ASSEMBLY_IN_CURRENT_APPDOMAIN_END(); TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_Reflection_Assembly::Load___STATIC__SystemReflectionAssembly__SZARRAY_U1( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_Array* array = NULL; CLR_RT_Assembly* assm = NULL; CLR_RT_HeapBlock& top = stack.PushValueAndClear(); CLR_RT_HeapBlock* hbObj; CLR_RECORD_ASSEMBLY* header; array = stack.Arg0().DereferenceArray(); FAULT_ON_NULL(array); header = (CLR_RECORD_ASSEMBLY*)array->GetFirstElement(); TINYCLR_CHECK_HRESULT(CLR_RT_Assembly::VerifyEndian(header)); if(header->GoodAssembly()) { // // Sorry, you'll have to reboot to load this assembly. // if(header->flags & CLR_RECORD_ASSEMBLY::c_Flags_NeedReboot) { TINYCLR_SET_AND_LEAVE(CLR_E_BUSY); } TINYCLR_CHECK_HRESULT(CLR_RT_Assembly::CreateInstance( header, assm )); assm->m_pFile = array; g_CLR_RT_TypeSystem.Link( assm ); TINYCLR_CHECK_HRESULT(g_CLR_RT_TypeSystem.ResolveAll ()); TINYCLR_CHECK_HRESULT(g_CLR_RT_TypeSystem.PrepareForExecution()); } if(assm) { CLR_RT_Assembly_Index idx; idx.Set( 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_CLEANUP(); if(FAILED(hr)) { if(assm) { assm->DestroyInstance(); } } TINYCLR_CLEANUP_END(); }
HRESULT Interop_Marshal_StoreRef( CLR_RT_StackFrame &stackFrame, void *pVoidHeapBlock, UINT32 paramIndex ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock *pHeapBlock = (CLR_RT_HeapBlock *)pVoidHeapBlock; TINYCLR_CHECK_HRESULT(pHeapBlock->StoreToReference( stackFrame.ArgN(paramIndex), 0 )); TINYCLR_NOCLEANUP(); }
void Library_corlib_native_System_Threading_WaitHandle::Reset( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); CLR_RT_HeapBlock* pThis = stack.This(); pThis->ResetFlags( CLR_RT_HeapBlock::HB_Signaled ); stack.SetResult_Boolean( true ); }
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::poll___STATIC__BOOLEAN__OBJECT__I4__I4( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); CLR_RT_HeapBlock* socket = stack.Arg0().Dereference(); CLR_INT32 handle; CLR_INT32 mode = stack.Arg1().NumericByRef().s4; CLR_INT32 timeout_us = stack.Arg2().NumericByRef().s4; CLR_RT_HeapBlock hbTimeout; CLR_INT32 timeout_ms; CLR_INT32 res = 0; bool fRes = true; CLR_INT64* timeout; FAULT_ON_NULL(socket); handle = socket[ FIELD__m_Handle ].NumericByRef().s4; /* Because we could have been a rescheduled call due to a prior call that would have blocked, we need to see * if our handle has been shutdown before continuing. */ if (handle == DISPOSED_HANDLE) { ThrowError( stack, CLR_E_OBJECT_DISPOSED ); TINYCLR_SET_AND_LEAVE (CLR_E_PROCESS_EXCEPTION); } if(timeout_us < 0) timeout_ms = -1; else timeout_ms = timeout_us / 1000; hbTimeout.SetInteger( timeout_ms ); TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout )); while(fRes) { res = Helper__SelectSocket( handle, mode ); if(res != 0) break; TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_Socket, fRes )); } stack.PopValue(); //timer TINYCLR_CHECK_HRESULT(ThrowOnError( stack, res )); stack.SetResult_Boolean( res == 1 ); TINYCLR_NOCLEANUP(); }
//--// SPI HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_HardwareProvider::NativeGetSpiPins___VOID__MicrosoftSPOTHardwareSPISPImodule__BYREF_MicrosoftSPOTHardwareCpuPin__BYREF_MicrosoftSPOTHardwareCpuPin__BYREF_MicrosoftSPOTHardwareCpuPin( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock hbmsk; CLR_RT_HeapBlock hbmiso; CLR_RT_HeapBlock hbmosi; CLR_UINT32 port, msk, miso, mosi; msk = (CLR_UINT32)-1; // GPIO_NONE miso = (CLR_UINT32)-1; // GPIO_NONE mosi = (CLR_UINT32)-1; // GPIO_NONE port = stack.Arg1().NumericByRef().u4; // SPI ports are numbered from 0 up if(port >= CPU_SPI_PortsCount()) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } ::CPU_SPI_GetPins( port, msk, miso, mosi ); hbmsk.SetInteger ( (CLR_INT32)msk ); TINYCLR_CHECK_HRESULT(hbmsk .StoreToReference( stack.Arg2(), 0 )); hbmiso.SetInteger( (CLR_INT32)miso ); TINYCLR_CHECK_HRESULT(hbmiso.StoreToReference( stack.Arg3(), 0 )); hbmosi.SetInteger( (CLR_INT32)mosi ); TINYCLR_CHECK_HRESULT(hbmosi.StoreToReference( stack.Arg4(), 0 )); TINYCLR_NOCLEANUP(); }
HRESULT CLR_RT_HeapBlock_Array::CreateInstance( CLR_RT_HeapBlock& reference, CLR_UINT32 length, const CLR_RT_ReflectionDef_Index& reflex ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_Array* pArray; CLR_RT_TypeDef_Index cls; CLR_RT_TypeDef_Instance inst; reference.SetObjectReference( NULL ); if((CLR_INT32)length < 0) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE); if(reflex.m_kind != REFLECTION_TYPE) { TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE); } if(reflex.m_levels == 1) { cls = reflex.m_data.m_type; } else { cls = g_CLR_RT_WellKnownTypes.m_Array; } if(inst.InitializeFromIndex( cls ) == false) { TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE); } else { CLR_DataType dt = (CLR_DataType)inst.m_target->dataType; const CLR_RT_DataTypeLookup& dtl = c_CLR_RT_DataTypeLookup[ dt ]; if(dtl.m_sizeInBytes == CLR_RT_DataTypeLookup::c_NA) { TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE); } pArray = (CLR_RT_HeapBlock_Array*)g_CLR_RT_ExecutionEngine.ExtractHeapBlocksForArray( inst, length, reflex ); CHECK_ALLOCATION(pArray); reference.SetObjectReference( pArray ); TINYCLR_SET_AND_LEAVE(pArray->ClearElements( 0, length )); } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_native_Microsoft_SPOT_Reflection::GetAssemblies___STATIC__SZARRAY_mscorlibSystemReflectionAssembly( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock& top = stack.PushValueAndClear(); #if defined(TINYCLR_APPDOMAINS) TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.GetCurrentAppDomain()->GetAssemblies( top )); #else int count = 0; CLR_RT_HeapBlock* pArray = NULL; for(int pass=0; pass<2; pass++) { TINYCLR_FOREACH_ASSEMBLY(g_CLR_RT_TypeSystem) { if(pASSM->m_header->flags & CLR_RECORD_ASSEMBLY::c_Flags_Patch) continue; if(pass == 0) { count++; } else { CLR_RT_HeapBlock* hbObj; CLR_RT_Assembly_Index idx; idx.Set( pASSM->m_idx ); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(*pArray, g_CLR_RT_WellKnownTypes.m_Assembly)); hbObj = pArray->Dereference(); hbObj->SetReflection( idx ); pArray++; } } TINYCLR_FOREACH_ASSEMBLY_END(); if(pass == 0) { TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( top, count, g_CLR_RT_WellKnownTypes.m_Assembly )); pArray = (CLR_RT_HeapBlock*)top.DereferenceArray()->GetFirstElement(); } } #endif //TINYCLR_APPDOMAINS TINYCLR_NOCLEANUP(); }
HRESULT CLR_RT_HeapBlock_XmlNameTable::Grow() { TINYCLR_HEADER(); CLR_RT_HeapBlock_Array* oldEntries; CLR_RT_HeapBlock newEntriesHB; CLR_RT_HeapBlock_Array* newEntries; CLR_RT_HeapBlock_XmlNameTable_Entry* entry; CLR_RT_HeapBlock_XmlNameTable_Entry* next; CLR_RT_HeapBlock* newEntryHB; CLR_UINT32 i; CLR_INT32 newIndex; CLR_INT32 newMask; newMask = GetMask() * 2 + 1; // allocate a new instance of Entry array TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( newEntriesHB, newMask + 1, g_CLR_RT_WellKnownTypes.m_XmlNameTable_Entry )); newEntries = newEntriesHB.DereferenceArray(); oldEntries = GetEntries(); // Go through the old buckets, and resort them for(i = 0; i < oldEntries->m_numOfElements; i++) { entry = (CLR_RT_HeapBlock_XmlNameTable_Entry*)((CLR_RT_HeapBlock*)oldEntries->GetElement( i ))->Dereference(); while(entry != NULL) { newIndex = entry->GetHashCode() & newMask; next = entry->GetNext(); newEntryHB = (CLR_RT_HeapBlock*)newEntries->GetElement( newIndex ); entry->SetNext( (CLR_RT_HeapBlock_XmlNameTable_Entry*)newEntryHB->Dereference() ); newEntryHB->SetObjectReference( entry ); entry = next; } } SetEntries( newEntries ); SetMask ( newMask ); TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::MarshalSockAddress( struct SOCK_sockaddr* addrDst, CLR_UINT32& addrLen, const CLR_RT_HeapBlock& blkSockAddress ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); CLR_RT_HeapBlock_Array* ptrSockAddress; SOCK_sockaddr_in* dst = (SOCK_sockaddr_in*)addrDst; SOCK_sockaddr_in* src; ptrSockAddress = blkSockAddress.DereferenceArray(); FAULT_ON_NULL(ptrSockAddress); if(ptrSockAddress->m_numOfElements > addrLen) TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); src = (SOCK_sockaddr_in*)ptrSockAddress->GetFirstElement(); dst->sin_family = SwapEndianIfBEc16(src->sin_family); dst->sin_port = src->sin_port; dst->sin_addr.S_un.S_addr = src->sin_addr.S_un.S_addr; //already in network byte order memcpy(dst->sin_zero, src->sin_zero, sizeof(dst->sin_zero)); addrLen = ptrSockAddress->m_numOfElements; TINYCLR_NOCLEANUP(); }
HRESULT CLR_RT_HeapBlock_MemoryStream::ToArray( CLR_RT_HeapBlock& ref ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_UINT32 tot; CLR_RT_HeapBlock_Array* array; CLR_UINT8* buf; tot = 0; TINYCLR_FOREACH_NODE(Buffer,node,m_buffers) { tot += node->m_length; } TINYCLR_FOREACH_NODE_END(); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( ref, tot, g_CLR_RT_WellKnownTypes.m_UInt8 )); array = ref.DereferenceArray(); buf = array->GetFirstElement(); TINYCLR_FOREACH_NODE(Buffer,node,m_buffers) { memcpy( buf, node->m_payload, node->m_length ); buf += node->m_length; }
HRESULT Library_corlib_native_System_AppDomain::Unload___STATIC__VOID__SystemAppDomain( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_AppDomain* appDomainSav; CLR_RT_AppDomain* appDomain; CLR_RT_HeapBlock hbTimeout; CLR_INT64* timeout; bool fRes; TINYCLR_CHECK_HRESULT(GetAppDomain( stack.ThisRef(), appDomain, appDomainSav, false )); hbTimeout.SetInteger( 5 * 1000 ); if(stack.m_customState == 0) { //Attempt to unload the AppDomain only once TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.UnloadAppDomain( appDomain, stack.m_owningThread )); } TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout )); fRes = true; while(fRes) { //Check to make sure this AppDomain is the one that caused the event to fire if(appDomain->m_state == CLR_RT_AppDomain::AppDomainState_Unloaded) break; _ASSERTE(CLR_EE_IS(UnloadingAppDomain)); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_AppDomain, fRes )); } if(!fRes) TINYCLR_SET_AND_LEAVE(CLR_E_TIMEOUT); appDomain->DestroyInstance(); stack.PopValue(); TINYCLR_CLEANUP(); g_CLR_RT_ExecutionEngine.SetCurrentAppDomain( appDomainSav ); TINYCLR_CLEANUP_END(); }
HRESULT Library_spot_net_security_native_Microsoft_SPOT_Net_Security_SslNative::UpdateCertificates___STATIC__VOID__I4__MicrosoftSPOTNativeSystemSecurityCryptographyX509CertificatesX509Certificate__SZARRAY_MicrosoftSPOTNativeSystemSecurityCryptographyX509CertificatesX509Certificate( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); CLR_INT32 sslContext = stack.Arg0().NumericByRef().s4; CLR_RT_HeapBlock* hbCert = stack.Arg1().Dereference(); CLR_RT_HeapBlock_Array* arrCA = stack.Arg2().DereferenceArray(); CLR_RT_HeapBlock_Array* arrCert; CLR_UINT8* sslCert; int i; CLR_RT_HeapBlock* hbPwd; LPCSTR szPwd; FAULT_ON_NULL(hbCert); FAULT_ON_NULL(arrCA); arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_certificate ].DereferenceArray(); FAULT_ON_NULL(arrCert); sslCert = arrCert->GetFirstElement(); hbPwd = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_password ].Dereference(); FAULT_ON_NULL(hbPwd); szPwd = hbPwd->StringText(); SSL_ClearCertificateAuthority( sslContext ); if(!SSL_AddCertificateAuthority( sslContext, (const char*)sslCert, arrCert->m_numOfElements, szPwd )) TINYCLR_SET_AND_LEAVE(CLR_E_FAIL); for(i=0; i<(int)arrCA->m_numOfElements; i++) { hbCert = (CLR_RT_HeapBlock*)arrCA->GetElement( i ); FAULT_ON_NULL(arrCert); arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_certificate ].DereferenceArray(); sslCert = arrCert->GetFirstElement(); hbPwd = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_password ].Dereference(); szPwd = hbPwd->StringText(); if(!SSL_AddCertificateAuthority( sslContext, (const char*)sslCert, arrCert->m_numOfElements, szPwd )) TINYCLR_SET_AND_LEAVE(CLR_E_FAIL); } TINYCLR_NOCLEANUP(); }
CLR_INT64* Library_corlib_native_System_TimeSpan::GetValuePtr( CLR_RT_HeapBlock& ref ) { NATIVE_PROFILE_CLR_CORE(); CLR_RT_HeapBlock* obj = &ref; CLR_DataType dt = obj->DataType(); if(dt == DATATYPE_OBJECT || dt == DATATYPE_BYREF) { obj = obj->Dereference(); if(!obj) return NULL; dt = obj->DataType(); } if(dt == DATATYPE_TIMESPAN) { return (CLR_INT64*)&obj->NumericByRef().s8; } if(dt == DATATYPE_I8) { return (CLR_INT64*)&obj->NumericByRef().s8; } if(dt == DATATYPE_VALUETYPE && obj->ObjectCls().m_data == g_CLR_RT_WellKnownTypes.m_TimeSpan.m_data) { return (CLR_INT64*)&obj[ FIELD__m_ticks ].NumericByRef().s8; } return NULL; }
// Note that prefix and namespaceURI need to be atomized (with nametable) prior to calling AddNamespace HRESULT CLR_RT_HeapBlock_XmlNamespaceStack::AddNamespace( CLR_RT_HeapBlock_String* prefix, CLR_RT_HeapBlock_String* namespaceURI ) { TINYCLR_HEADER(); CLR_RT_HeapBlock ref; CLR_RT_HeapBlock_XmlNamespaceEntry* entry; TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( ref, g_CLR_RT_WellKnownTypes.m_XmlReader_NamespaceEntry )); entry = (CLR_RT_HeapBlock_XmlNamespaceEntry*)ref.Dereference(); entry->SetPrefix ( prefix ); entry->SetNamespaceURI( namespaceURI ); TINYCLR_SET_AND_LEAVE(Push( entry )); TINYCLR_NOCLEANUP(); }
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(); }
void CLR_RT_HeapBlock_Timer::SpawnTimer( CLR_RT_Thread* th ) { NATIVE_PROFILE_CLR_CORE(); //Only one managed timer max _ASSERTE(m_references.NumOfNodes() == 1); CLR_RT_ObjectToEvent_Source* ref = (CLR_RT_ObjectToEvent_Source*)m_references.FirstValidNode(); CLR_RT_HeapBlock* managedTimer = ref->m_objectPtr; CLR_RT_HeapBlock* callback = &managedTimer[ Library_corlib_native_System_Threading_Timer::FIELD__m_callback ]; CLR_RT_HeapBlock* state = &managedTimer[ Library_corlib_native_System_Threading_Timer::FIELD__m_state ]; CLR_RT_HeapBlock_Delegate* delegate = callback->DereferenceDelegate(); CLR_RT_ProtectFromGC gc( *managedTimer ); _ASSERTE(delegate != NULL); if(delegate == NULL) return; _ASSERTE(delegate->DataType() == DATATYPE_DELEGATE_HEAD); m_ticksLastExpiration = g_CLR_RT_ExecutionEngine.m_currentMachineTime; m_timeLastExpiration = m_timeExpire; m_timeExpire = TIMEOUT_INFINITE; if(SUCCEEDED(th->PushThreadProcDelegate( delegate ))) { CLR_RT_StackFrame* stack = th->FirstFrame(); if(stack->Next() != NULL) { int numArgs = stack->m_call.m_target->numArgs; if(numArgs > 0) { stack->m_arguments[ numArgs-1 ].Assign( *state ); } } // // Associate the timer with the thread. // m_flags |= CLR_RT_HeapBlock_Timer::c_Executing; m_flags &= ~CLR_RT_HeapBlock_Timer::c_Triggered; th->m_terminationCallback = CLR_RT_HeapBlock_Timer::ThreadTerminationCallback; th->m_terminationParameter = this; } }