Пример #1
0
int _tmain(int argc, _TCHAR* argv[])
{
    TINYCLR_HEADER();

    CLR_RT_Assembly::InitString();

    CLR_RT_StringVector vec;
    Settings            st;
    LPWSTR              convertFont[] = { L"-convertFont" };

    TINYCLR_CHECK_HRESULT(::CoInitialize( 0 ));

    TINYCLR_CHECK_HRESULT(HAL_Windows::Memory_Resize( 1024 * 1024 ));
    HAL_Init_Custom_Heap();

    CLR_RT_Memory::Reset         ();    

    st.PushArguments( 1, convertFont, vec );
    st.PushArguments( argc-1, argv+1, vec );

    TINYCLR_CHECK_HRESULT(st.ProcessOptions( vec ));

    TINYCLR_CLEANUP();

    if(FAILED(hr))
    {
        fflush( stdout );
    }

    ::CoUninitialize();

    return FAILED(hr) ? 10 : 0;
}
HRESULT CLR_RT_XmlState_InName::ProcessNameParts( CLR_RT_XmlState_InName* state, CLR_UINT32& nameLen, CLR_UINT16 stopsAt )
{
    TINYCLR_HEADER();
    CLR_UINT8* buffer    = state->buffer;
    CLR_UINT8* bufferEnd = state->bufferEnd;
    CLR_UINT32 len       = nameLen;
    
    while(!(c_XmlCharType[ *buffer ] & stopsAt))
    {
        CLR_INT32 count = ProcessNCNameChar( buffer, bufferEnd - buffer, len == 0 );

        if(count > 0)
        {
            len    += count;
            buffer += count;
            if(buffer == bufferEnd) TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA);
        }
        else
        {
            TINYCLR_SET_AND_LEAVE((count == 0) ? XML_E_NEED_MORE_DATA : XML_E_BAD_NAME_CHAR);
        }
    }

    if(len == 0) TINYCLR_SET_AND_LEAVE(XML_E_EMPTY_NAME);

    TINYCLR_CLEANUP();

    nameLen = len;
    state->buffer = buffer;

    TINYCLR_CLEANUP_END();
}
HRESULT CLR_RT_HeapBlock_I2CXAction::CreateInstance( CLR_RT_HeapBlock& owner, CLR_RT_HeapBlock& xActionRef )
{
    NATIVE_PROFILE_CLR_I2C();
    TINYCLR_HEADER();

    CLR_RT_HeapBlock_I2CXAction* xAction = NULL;

    xAction = EVENTCACHE_EXTRACT_NODE(g_CLR_RT_EventCache,CLR_RT_HeapBlock_I2CXAction,DATATYPE_I2C_XACTION); CHECK_ALLOCATION(xAction);

    {
        CLR_RT_ProtectFromGC gc( *xAction );

        xAction->Initialize();

        xAction->m_HalXAction      = NULL;
        xAction->m_HalXActionUnits = NULL;
        xAction->m_dataBuffers     = NULL;
        xAction->m_xActionUnits    = 0;

        m_i2cPorts.LinkAtBack( xAction );

        TINYCLR_CHECK_HRESULT(CLR_RT_ObjectToEvent_Source::CreateInstance( xAction, owner, xActionRef ));
    }

    

    TINYCLR_CLEANUP();

    if(FAILED(hr))
    {
        if(xAction) xAction->ReleaseWhenDeadEx();
    }

    TINYCLR_CLEANUP_END();
}
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_NetworkInformation_NetworkInterface::IPAddressFromString___STATIC__U4__STRING( CLR_RT_StackFrame& stack )
{
    NATIVE_PROFILE_CLR_NETWORK();
    TINYCLR_HEADER();

    LPCSTR szName = stack.Arg0().RecoverString();
    struct SOCK_addrinfo hints;
    struct SOCK_addrinfo* addr = NULL;     
    struct SOCK_sockaddr_in* addr_in;
    int ret;
    
    memset( &hints, 0, sizeof(hints) );

    ret = SOCK_getaddrinfo( szName, NULL, &hints, &addr );

    // getaddrinfo returns a winsock error code rather than SOCK_SOCKET_ERROR, so pass this on to the exception handling
    if(ret != 0 || addr == NULL || addr->ai_family != SOCK_AF_INET)
    {
        TINYCLR_SET_AND_LEAVE(CLR_E_FAIL);
    }

    _ASSERTE(addr->ai_addr != NULL);
    _ASSERTE(addr->ai_addrlen >= sizeof(SOCK_sockaddr_in));

    addr_in = (struct SOCK_sockaddr_in*)addr->ai_addr;

    stack.PushValue().SetInteger( (CLR_UINT32)addr_in->sin_addr.S_un.S_addr );

    TINYCLR_CLEANUP();

    if( addr ) SOCK_freeaddrinfo( addr );

    TINYCLR_CLEANUP_END();
}
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_spot_native_Microsoft_SPOT_Reflection::GetAssemblyInfo___STATIC__BOOLEAN__SZARRAY_U1__MicrosoftSPOTReflectionAssemblyInfo( CLR_RT_StackFrame& stack )
{
    NATIVE_PROFILE_CLR_CORE();
    TINYCLR_HEADER();

    CLR_RT_HeapBlock_Array* array = NULL;
    CLR_RT_Assembly*        assm  = NULL;
    CLR_RECORD_ASSEMBLY*    header;

    array = stack.Arg0().DereferenceArray(); FAULT_ON_NULL(array);

    header = (CLR_RECORD_ASSEMBLY*)array->GetFirstElement();

    if(header->GoodAssembly())
    {
        CLR_RT_HeapBlock* dst = stack.Arg1().Dereference(); FAULT_ON_NULL(dst);

        TINYCLR_CHECK_HRESULT(CLR_RT_Assembly::CreateInstance( header, assm ));

        TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance( dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyInfo::FIELD__m_name ], assm->m_szName ));

        {
            CLR_RT_HeapBlock& refs   = dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyInfo::FIELD__m_refs ];
            CLR_UINT32        numRef = assm->m_pTablesSize[ TBL_AssemblyRef ];


            TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( refs, numRef, g_CLR_RT_WellKnownTypes.m_UInt32 ));

            {
                const CLR_RECORD_ASSEMBLYREF* ar  =              assm->GetAssemblyRef( 0 );
                CLR_UINT32*                   dst = (CLR_UINT32*)refs.DereferenceArray()->GetFirstElement();

                while(numRef--)
                {
                    *dst++ = assm->ComputeAssemblyHash( ar++ );
                }
            }
        }

        dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyInfo::FIELD__m_flags ].SetInteger(                 assm->m_header->flags                  , DATATYPE_U4 );
        dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyInfo::FIELD__m_size  ].SetInteger( ROUNDTOMULTIPLE(assm->m_header->TotalSize(), CLR_INT32), DATATYPE_I4 );
        dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyInfo::FIELD__m_hash  ].SetInteger(                 assm->ComputeAssemblyHash()            , DATATYPE_U4 );

        stack.SetResult_Boolean( true );
    }
    else
    {
        stack.SetResult_Boolean( false );
    }

    TINYCLR_CLEANUP();

    if(assm)
    {
        assm->DestroyInstance();
    }

    TINYCLR_CLEANUP_END();
}
HRESULT Library_corlib_native_System_Reflection_Assembly::LoadInternal___STATIC__SystemReflectionAssembly__STRING__BOOLEAN__I4__I4__I4__I4( CLR_RT_StackFrame& stack )
{
    NATIVE_PROFILE_CLR_CORE();
    TINYCLR_HEADER();

#if defined(TINYCLR_APPDOMAINS)
    CLR_RT_AppDomain*     appDomain = g_CLR_RT_ExecutionEngine.GetCurrentAppDomain();
#endif
    CLR_RT_HeapBlock*     pArgs     = &stack.Arg0();
    CLR_RT_Assembly*      assembly;
    LPCSTR                szAssembly;
    CLR_RT_Assembly_Index idx; 
    bool                  fVersion;
    CLR_INT16             maj, min, build, rev;
    CLR_RT_HeapBlock&     top = stack.PushValueAndClear();
    
    szAssembly = pArgs[ 0 ].RecoverString(); FAULT_ON_NULL(szAssembly );
    fVersion   = pArgs[ 1 ].NumericByRef().u1 != 0;    
    maj        = pArgs[ 2 ].NumericByRef().s4;    
    min        = pArgs[ 3 ].NumericByRef().s4;
    build      = pArgs[ 4 ].NumericByRef().s4;
    rev        = pArgs[ 5 ].NumericByRef().s4;

    if(fVersion && (maj < 0 || min < 0 || build < 0 || rev < 0))
    {
        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);
    }
    
#if defined(TINYCLR_APPDOMAINS)
    TINYCLR_CHECK_HRESULT(appDomain->LoadAssembly( assembly ));
#endif
    idx.Set( assembly->m_idx );

    top.SetReflection( idx );

    TINYCLR_CLEANUP();

    //Avoid exception handling in common case.  Just return NULL on failure.
    //Managed code decides to throw the exception or not.  
    hr = S_OK;

    TINYCLR_CLEANUP_END();
}
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 CLR_HW_Hardware::TransferAllInterruptsToApplicationQueue()
{
    NATIVE_PROFILE_CLR_HARDWARE();
    TINYCLR_HEADER();

    while(true)
    {
        HalInterruptRecord* rec;

        {
            GLOBAL_LOCK(irq1);

            rec = m_interruptData.m_HalQueue.Peek();
        }

        if(rec == NULL) break;

        CLR_RT_ApplicationInterrupt* queueRec = (CLR_RT_ApplicationInterrupt*)CLR_RT_Memory::Allocate_And_Erase( sizeof(CLR_RT_ApplicationInterrupt), CLR_RT_HeapBlock::HB_CompactOnFailure );  CHECK_ALLOCATION(queueRec);

        queueRec->m_interruptPortInterrupt.m_data1   =                                          rec->m_data1;
        queueRec->m_interruptPortInterrupt.m_data2   =                                          rec->m_data2;
        queueRec->m_interruptPortInterrupt.m_data3   =                                          rec->m_data3;
        queueRec->m_interruptPortInterrupt.m_time    =                                          rec->m_time;
        queueRec->m_interruptPortInterrupt.m_context = (CLR_RT_HeapBlock_NativeEventDispatcher*)rec->m_context;

        m_interruptData.m_applicationQueue.LinkAtBack( queueRec ); ++m_interruptData.m_queuedInterrupts;

        {
            GLOBAL_LOCK(irq2);
            
            m_interruptData.m_HalQueue.Pop();
        }
    }

    if(m_interruptData.m_queuedInterrupts == 0)
    {
        TINYCLR_SET_AND_LEAVE(CLR_E_NO_INTERRUPT);
    }

    TINYCLR_CLEANUP();

    if(CLR_E_OUT_OF_MEMORY == hr)
    {
        // if there is no memory left discard all interrupts to avoid getting into a death spiral of OOM exceptions
        {
            GLOBAL_LOCK(irq3);

            while(!m_interruptData.m_HalQueue.IsEmpty())
            {
                m_interruptData.m_HalQueue.Pop();
            }
        }
    }    
    
    TINYCLR_CLEANUP_END();
}
HRESULT Library_spot_Time_native_Microsoft_SPOT_Time_TimeService::Update___STATIC__MicrosoftSPOTTimeTimeServiceStatus__U4__U4( CLR_RT_StackFrame& stack )
{
    TINYCLR_HEADER(); 

    CLR_RT_HeapBlock* managedStatus = NULL;  

    UINT32 serverIP  = stack.Arg0().NumericByRef().u4;
    UINT32 tolerance = stack.Arg1().NumericByRef().u4;    

    TimeService_Status status;

    hr = TimeService_Update( serverIP, tolerance, &status );

    if(hr == CLR_E_RESCHEDULE) 
    {
        TINYCLR_LEAVE();
    }
    else 
    {
        CLR_RT_HeapBlock& top = stack.PushValueAndClear();

        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_CLEANUP();

    // we are not throwing any exception, we are instead communicating the result through the TimeServiceStatus object we return
    // if the operation did not completed, we need to reschedule this call though
    switch(hr)
    {
        case CLR_E_RESCHEDULE:
            break;
        case CLR_E_TIMEOUT:
        case CLR_E_FAIL:
        default:
            // swallow error
            hr = S_OK; 
            break;
    }

    TINYCLR_CLEANUP_END();
}
Пример #11
0
HRESULT CLR_RT_HeapBlock_XmlReader::Read()
{
    TINYCLR_HEADER();

    CLR_RT_XmlState* state = GetState();

    state->State.bufferStart = GetBuffer();
    state->State.buffer      = state->State.bufferStart + GetOffset();
    state->State.bufferEnd   = state->State.buffer + GetLength();
    state->State.reader      = this;

    if(state->State.initFn)
    {
        state->State.initFn( state );
    }

    while(true)
    {
        TINYCLR_CHECK_HRESULT(state->State.stateFn( state ));
    }

    TINYCLR_CLEANUP();

    if(hr == XML_E_NEED_MORE_DATA)
    {
        if(state->State.cleanUpFn)
        {
            state->State.cleanUpFn( state );
        }
        else
        {
            state->State.ShiftBuffer( state->State.buffer );
        }

        // if after buffer adjustment, there's no room for new data, then we know that
        // we've exceeded one of the system constraints (either the length of name or
        // attribute value is over buffer size)
        if(state->State.bufferEnd - state->State.bufferStart == XmlBufferSize)
        {
            hr = XML_E_LIMIT_EXCEEDED;
        }
    }

    SetOffset( state->State.buffer    - state->State.bufferStart );
    SetLength( state->State.bufferEnd - state->State.buffer      );

    TINYCLR_CLEANUP_END();
}
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_windows_devices_native_Windows_Devices_Gpio_GpioPin::InitNative___BOOLEAN__I4( CLR_RT_StackFrame& stack )
{
    TINYCLR_HEADER();

    GPIO_PIN portId = GPIO_PIN_NONE;
    bool pinAllocated = false;
    CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis);

    portId = stack.Arg1().NumericByRef().u4;

    // Ensure the pin exists.
    if (::CPU_GPIO_Attributes( portId ) == 0)
    {
        TINYCLR_SET_AND_LEAVE(S_OK);
    }

    // Reserve the pin. If this fails, it's already in use.
    pinAllocated = !!::CPU_GPIO_ReservePin( portId, TRUE );
    if (!pinAllocated)
    {
        TINYCLR_SET_AND_LEAVE(S_OK);
    }

    // Initialize the default drive mode.
    if (!::CPU_GPIO_EnableInputPin2( portId, false, NULL, NULL, GPIO_INT_NONE, RESISTOR_DISABLED ))
    {
        TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION);
    }

    pThis[ FIELD__m_pinNumber ].NumericByRef().u4 = portId;

    TINYCLR_CLEANUP();

    if (FAILED(hr))
    {
        if (pinAllocated)
        {
            ::CPU_GPIO_ReservePin( portId, FALSE );
        }
    }

    stack.SetResult_Boolean( pinAllocated );

    TINYCLR_CLEANUP_END();
}
HRESULT Library_corlib_native_System_AppDomain::GetAssemblies___SZARRAY_SystemReflectionAssembly( CLR_RT_StackFrame& stack )
{   
    NATIVE_PROFILE_CLR_CORE();
    TINYCLR_HEADER();
    
    CLR_RT_AppDomain* appDomainSav = NULL;
    CLR_RT_AppDomain* appDomain;    

    TINYCLR_CHECK_HRESULT(GetAppDomain( stack.ThisRef(), appDomain, appDomainSav, true ));

    TINYCLR_CHECK_HRESULT(appDomain->GetAssemblies( stack.PushValueAndClear() ));    

    TINYCLR_CLEANUP();

    g_CLR_RT_ExecutionEngine.SetCurrentAppDomain( appDomainSav );    

    TINYCLR_CLEANUP_END();
}
HRESULT CLR_HW_Hardware::SpawnDispatcher()
{
    NATIVE_PROFILE_CLR_HARDWARE();
    TINYCLR_HEADER();

    CLR_RT_ApplicationInterrupt* interrupt;
    CLR_RT_HeapBlock_NativeEventDispatcher* ioPort;
    CLR_RT_HeapBlock_NativeEventDispatcher ::InterruptPortInterrupt *interruptData;

    // if reboot is in progress, just bail out
    if(CLR_EE_DBG_IS( RebootPending )) 
    {
        return S_OK;
    }

    interrupt = (CLR_RT_ApplicationInterrupt*)m_interruptData.m_applicationQueue.FirstValidNode();

    if((interrupt == NULL) || !g_CLR_RT_ExecutionEngine.EnsureSystemThread( g_CLR_RT_ExecutionEngine.m_interruptThread, ThreadPriority::System_Highest ))
    {
        return S_OK;
    }

    interrupt->Unlink();

    interruptData = &interrupt->m_interruptPortInterrupt;
    ioPort = interruptData->m_context;

    CLR_RT_ProtectFromGC gc1 ( *ioPort );
                    
    TINYCLR_SET_AND_LEAVE(ioPort->StartDispatch( interrupt, g_CLR_RT_ExecutionEngine.m_interruptThread ));
            
    TINYCLR_CLEANUP();

    if(FAILED(hr))
    {
        ioPort->ThreadTerminationCallback( interrupt );
    }

    --m_interruptData.m_queuedInterrupts;

    TINYCLR_CLEANUP_END();    
}
HRESULT CLR_RT_HeapBlock_I2CXAction::AllocateXAction( CLR_UINT32 numXActionUnits )
{
    NATIVE_PROFILE_CLR_I2C();
    TINYCLR_HEADER();

    CLR_UINT32 index;

    if(IsPending())
    {
        TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION);
    }

    m_xActionUnits = numXActionUnits;

    // allocate memory for the transaction
    m_HalXAction = (I2C_HAL_XACTION*)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION) );  CHECK_ALLOCATION(m_HalXAction);

    ((HAL_CONTINUATION*)m_HalXAction)->Initialize();

    ::I2C_XAction_SetState( m_HalXAction, I2C_HAL_XACTION::c_Status_Idle );

    // initialize pointers to data buffers
    m_dataBuffers = (I2C_WORD**)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_WORD*) * numXActionUnits );  CHECK_ALLOCATION(m_dataBuffers);

    // allocate memory for the transaction units
    m_HalXActionUnits = (I2C_HAL_XACTION_UNIT**)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION_UNIT*) * numXActionUnits );  CHECK_ALLOCATION(m_HalXActionUnits);

    for(index = 0; index < numXActionUnits; ++index)
    {            
        m_HalXActionUnits[ index ] = (I2C_HAL_XACTION_UNIT*)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION_UNIT) );  CHECK_ALLOCATION(m_HalXActionUnits[ index ]);
    }
    
    TINYCLR_CLEANUP();

    if(FAILED(hr))
    {   
        ReleaseBuffers();
    }
    
    TINYCLR_CLEANUP_END();
}
HRESULT Library_corlib_native_System_AppDomain::CreateDomain___STATIC__SystemAppDomain__STRING( CLR_RT_StackFrame& stack )
{
    NATIVE_PROFILE_CLR_CORE();
    TINYCLR_HEADER();
   
    CLR_RT_AppDomain*    appDomain   = NULL;        
    CLR_RT_HeapBlock&    pArgs       = stack.Arg0();    
    CLR_RT_HeapBlock     res; res.SetObjectReference( NULL );
    CLR_RT_ProtectFromGC gc( res );
    LPCSTR               szName;

    szName = pArgs.RecoverString(); FAULT_ON_NULL(szName);
    
    TINYCLR_CHECK_HRESULT(CLR_RT_AppDomain::CreateInstance( szName, appDomain ));

    //load mscorlib
    TINYCLR_CHECK_HRESULT(appDomain->LoadAssembly( g_CLR_RT_TypeSystem.m_assemblyMscorlib ));        
    //load Native
    TINYCLR_CHECK_HRESULT(appDomain->LoadAssembly( g_CLR_RT_TypeSystem.m_assemblyNative   ));
    
    TINYCLR_CHECK_HRESULT(appDomain->GetManagedObject( res ));

    //Marshal the new AD to the calling AD.
    TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.GetCurrentAppDomain()->MarshalObject( res, res, appDomain ));

    stack.PushValueAndAssign( res );

    TINYCLR_CLEANUP();

    if(FAILED(hr))
    {
        if(appDomain)
        {
            appDomain->DestroyInstance();
        }        
    }

    TINYCLR_CLEANUP_END();
}
HRESULT Library_spot_native_Microsoft_SPOT_Messaging_EndPoint::ReplyRaw___VOID__MicrosoftSPOTMessagingMessage__SZARRAY_U1( CLR_RT_StackFrame& stack )
{
    NATIVE_PROFILE_CLR_MESSAGING();
    TINYCLR_HEADER();

    CLR_RT_HeapBlock*                            pThis;
    CLR_RT_HeapBlock*                            pMsg;
    CLR_RT_HeapBlock_Array*                      pData;
    CLR_RT_HeapBlock_EndPoint*                   ep;
    CLR_Messaging_Commands::Messaging_Reply*     rpc = NULL;
    CLR_UINT32                                   len;

    pThis = stack.This()                   ; FAULT_ON_NULL(pThis);
    pMsg  = stack.Arg1().Dereference()     ; FAULT_ON_NULL(pMsg );
    pData = stack.Arg2().DereferenceArray(); FAULT_ON_NULL(pData);

    TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_EndPoint::ExtractInstance( pThis[ FIELD__m_handle ], ep ));

    len = sizeof(CLR_RT_HeapBlock_EndPoint::Address) + pData->m_numOfElements;
    rpc = (CLR_Messaging_Commands::Messaging_Reply*)CLR_RT_Memory::Allocate( len ); CHECK_ALLOCATION(rpc);

    rpc->m_addr.m_seq         = pMsg[ Library_spot_native_Microsoft_SPOT_Messaging_Message::FIELD__m_seq      ].NumericByRefConst  ().u4;
    rpc->m_addr.m_to          = ep->m_addr;
    rpc->m_addr.m_from.m_type = pMsg[ Library_spot_native_Microsoft_SPOT_Messaging_Message::FIELD__m_selector ].ReflectionDataConst().GetTypeHash();
    rpc->m_addr.m_from.m_id   = pMsg[ Library_spot_native_Microsoft_SPOT_Messaging_Message::FIELD__m_id       ].NumericByRefConst  ().u4;

    memcpy( rpc->m_data, pData->GetFirstElement(), pData->m_numOfElements );

    CLR_EE_MSG_EVENT_RPC(CLR_Messaging_Commands::c_Messaging_Reply,len,rpc,WP_Flags::c_NonCritical);

    TINYCLR_CLEANUP();

    if(rpc)
    {
        CLR_RT_Memory::Release( rpc );
    }

    TINYCLR_CLEANUP_END();
}
 HRESULT CLR_RT_HeapBlock_Timer::CreateInstance( CLR_UINT32 flags, CLR_RT_HeapBlock& owner, CLR_RT_HeapBlock& tmRef )
{
    NATIVE_PROFILE_CLR_CORE();
    TINYCLR_HEADER();

    CLR_RT_HeapBlock_Timer* timer = NULL;

    //
    // Create a request and stop the calling thread.
    //
    timer = EVENTCACHE_EXTRACT_NODE(g_CLR_RT_EventCache,CLR_RT_HeapBlock_Timer,DATATYPE_TIMER_HEAD); CHECK_ALLOCATION(timer);

    {
        CLR_RT_ProtectFromGC gc( *timer );

        timer->Initialize();

        timer->m_flags               = flags;
        timer->m_timeExpire          = TIMEOUT_INFINITE;
        timer->m_timeFrequency       = TIMEOUT_INFINITE;
        timer->m_timeLastExpiration  = 0;
        timer->m_ticksLastExpiration = 0;

        g_CLR_RT_ExecutionEngine.m_timers.LinkAtBack( timer );

        TINYCLR_SET_AND_LEAVE(CLR_RT_ObjectToEvent_Source::CreateInstance( timer, owner, tmRef ));
    }

    TINYCLR_CLEANUP();

    if(FAILED(hr))
    {
        if(timer) timer->ReleaseWhenDead();
    }

    TINYCLR_CLEANUP_END();
}
Пример #20
0
HRESULT CLR_GFX_Bitmap::CreateInstanceGif( CLR_RT_HeapBlock& ref, const CLR_UINT8* data, const CLR_UINT32 size )
{
    NATIVE_PROFILE_CLR_GRAPHICS();
    TINYCLR_HEADER();

    GifDecoder*               decoder;
    CLR_GFX_Bitmap*           bitmap   = NULL;
    CLR_GFX_BitmapDescription bm;

    // Allocate the decoder
    decoder = (GifDecoder*)CLR_RT_Memory::Allocate( sizeof(GifDecoder) );  CHECK_ALLOCATION(decoder);

    // Initialize the decompression engine
    TINYCLR_CHECK_HRESULT( decoder->GifInitDecompress( data, size ) );

    // At this point decoder would have all the correct output dimension info, so we initialized the CLR_GFX_BitmapDescription
    // with that information, note that we currently only support decompression into the native bpp
    if(bm.BitmapDescription_Initialize( decoder->header.LogicScreenWidth, decoder->header.LogicScreenHeight, CLR_GFX_BitmapDescription::c_NativeBpp ) == false)
    {
        // if the resulting bitmap doesn't match our constraints, stop the decompression
        TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER);
    }

    // Allocate the memory that the decompressed bitmap would need
    TINYCLR_CHECK_HRESULT(CLR_GFX_Bitmap::CreateInstance( ref, bm ));

    TINYCLR_CHECK_HRESULT(CLR_GFX_Bitmap::GetInstanceFromHeapBlock (ref, bitmap));

    TINYCLR_CHECK_HRESULT(decoder->GifStartDecompress( bitmap ));

    TINYCLR_CLEANUP();

    if (decoder) CLR_RT_Memory::Release( decoder );

    TINYCLR_CLEANUP_END();
}
Пример #21
0
HRESULT CLR_RT_StackFrame::Push( CLR_RT_Thread* th, const CLR_RT_MethodDef_Instance& callInst, CLR_INT32 extraBlocks )
{
    NATIVE_PROFILE_CLR_CORE();
    TINYCLR_HEADER();

    CLR_RT_StackFrame*               stack;
    CLR_RT_StackFrame*               caller;
    CLR_RT_Assembly*                 assm;
    const CLR_RECORD_METHODDEF*      md;
    const CLR_RT_MethodDef_Instance* callInstPtr = &callInst;
    CLR_UINT32                       sizeLocals;
    CLR_UINT32                       sizeEvalStack;

#if defined(PLATFORM_WINDOWS)
    if(s_CLR_RT_fTrace_SimulateSpeed > c_CLR_RT_Trace_None)
    {
        CLR_PROF_Handler::SuspendTime();

        HAL_Windows_FastSleep( g_HAL_Configuration_Windows.TicksPerMethodCall );

        CLR_PROF_Handler::ResumeTime();
    }
#endif

    assm          = callInstPtr->m_assm;
    md            = callInstPtr->m_target;

    sizeLocals    = md->numLocals;
    sizeEvalStack = md->lengthEvalStack + CLR_RT_StackFrame::c_OverheadForNewObjOrInteropMethod;

    //--//

    caller = th->CurrentFrame();

    //--//

    //
    // Allocate memory for the runtime state.
    //
    {
        CLR_UINT32 memorySize = sizeLocals + sizeEvalStack;

        if(extraBlocks > 0             ) memorySize += extraBlocks;
        if(memorySize  < c_MinimumStack) memorySize  = c_MinimumStack;

        memorySize += CONVERTFROMSIZETOHEAPBLOCKS(offsetof(CLR_RT_StackFrame,m_extension));

        stack = EVENTCACHE_EXTRACT_NODE_AS_BLOCKS(g_CLR_RT_EventCache,CLR_RT_StackFrame,DATATYPE_STACK_FRAME,0,memorySize);
        CHECK_ALLOCATION(stack);
    }

    //--//

    {   //
        stack->m_owningSubThread = th->CurrentSubThread();  // CLR_RT_SubThread*         m_owningSubThread;  // EVENT HEAP - NO RELOCATION -
        stack->m_owningThread    = th;                      // CLR_RT_Thread*            m_owningThread;     // EVENT HEAP - NO RELOCATION -
        // CLR_UINT32                m_flags;
        //
        stack->m_call            = *callInstPtr;            // CLR_RT_MethodDef_Instance m_call;
        //
        // CLR_RT_MethodHandler      m_nativeMethod;
        // CLR_PMETADATA             m_IPstart;          // ANY   HEAP - DO RELOCATION -
        // CLR_PMETADATA             m_IP;               // ANY   HEAP - DO RELOCATION -
        //
        stack->m_locals          = stack->m_extension;      // CLR_RT_HeapBlock*         m_locals;           // EVENT HEAP - NO RELOCATION -
        stack->m_evalStack       = stack->m_extension + sizeLocals;                      // CLR_RT_HeapBlock*         m_evalStack;        // EVENT HEAP - NO RELOCATION -
        stack->m_evalStackPos    = stack->m_evalStack;      // CLR_RT_HeapBlock*         m_evalStackPos;     // EVENT HEAP - NO RELOCATION -
        stack->m_evalStackEnd    = stack->m_evalStack + sizeEvalStack;                      // CLR_RT_HeapBlock*         m_evalStackEnd;     // EVENT HEAP - NO RELOCATION -
        stack->m_arguments       = NULL;                    // CLR_RT_HeapBlock*         m_arguments;        // EVENT HEAP - NO RELOCATION -
        //
        // union
        // {
        stack->m_customState     = 0;                       //    CLR_UINT32             m_customState;
        //    void*                  m_customPointer;
        // };
        //
#if defined(TINYCLR_PROFILE_NEW_CALLS)
        stack->m_callchain.Enter( stack );                  // CLR_PROF_CounterCallChain m_callchain;
#endif
        //
        // CLR_RT_HeapBlock          m_extension[1];
        //
#if defined(ENABLE_NATIVE_PROFILER)
        stack->m_fNativeProfiled = stack->m_owningThread->m_fNativeProfiled;
#endif
        CLR_RT_MethodHandler impl;

#if defined(TINYCLR_APPDOMAINS)
        stack->m_appDomain = g_CLR_RT_ExecutionEngine.GetCurrentAppDomain();
#endif

        if(md->flags & CLR_RECORD_METHODDEF::MD_DelegateInvoke) // Special case for delegate calls.
        {
            stack->m_nativeMethod = (CLR_RT_MethodHandler)CLR_RT_Thread::Execute_DelegateInvoke;

            stack->m_flags   = CLR_RT_StackFrame::c_MethodKind_Native;
            stack->m_IPstart = NULL;
        }
        else if(assm->m_nativeCode && (impl = assm->m_nativeCode[ stack->m_call.Method() ]) != NULL)
        {
            stack->m_nativeMethod = impl;

            stack->m_flags   = CLR_RT_StackFrame::c_MethodKind_Native;
            stack->m_IPstart = NULL;
            stack->m_IP      = NULL;
        }
#if defined(TINYCLR_JITTER)
        else if(assm->m_jittedCode && (impl = assm->m_jittedCode[ stack->m_call.Method() ]) != NULL)
        {
            stack->m_nativeMethod = (CLR_RT_MethodHandler)(size_t)g_thunkTable.m_address__Internal_Initialize;

            stack->m_flags   = CLR_RT_StackFrame::c_MethodKind_Jitted;
            stack->m_IPstart = (CLR_PMETADATA)impl;

            if(md->flags & CLR_RECORD_METHODDEF::MD_HasExceptionHandlers)
            {
                CLR_UINT32 numEh = *(CLR_UINT32*)stack->m_IPstart;

                stack->m_IP = stack->m_IPstart + sizeof(CLR_UINT32) + numEh * sizeof(CLR_RT_ExceptionHandler);
            }
            else
            {
                stack->m_IP = stack->m_IPstart;
            }
        }
#endif
        else
        {
            stack->m_nativeMethod = (CLR_RT_MethodHandler)CLR_RT_Thread::Execute_IL;

            if(md->RVA == CLR_EmptyIndex) TINYCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED);

            stack->m_flags   = CLR_RT_StackFrame::c_MethodKind_Interpreted;
            stack->m_IPstart = assm->GetByteCode( md->RVA );
            stack->m_IP      = stack->m_IPstart;
        }

#if defined(ENABLE_NATIVE_PROFILER)
        if(stack->m_owningThread->m_fNativeProfiled == false && md->flags & CLR_RECORD_METHODDEF::MD_NativeProfiled)
        {
            stack->m_flags |= CLR_RT_StackFrame::c_NativeProfiled;
            stack->m_owningThread->m_fNativeProfiled = true;
        }
#endif

        //--//

        th->m_stackFrames.LinkAtBack( stack );

#if defined(TINYCLR_PROFILE_NEW_CALLS)
        g_CLR_PRF_Profiler.RecordFunctionCall( th, callInst );
#endif
    }

    if(md->numLocals)
    {
        g_CLR_RT_ExecutionEngine.InitializeLocals( stack->m_locals, assm, md );
    }

    {
        CLR_UINT32 flags = md->flags & (md->MD_Synchronized | md->MD_GloballySynchronized);

        if(flags)
        {
            if(flags & md->MD_Synchronized        ) stack->m_flags |= c_NeedToSynchronize;
            if(flags & md->MD_GloballySynchronized) stack->m_flags |= c_NeedToSynchronizeGlobally;
        }
    }

#if defined(TINYCLR_ENABLE_SOURCELEVELDEBUGGING)
    stack->m_depth = stack->Caller()->Prev() ? stack->Caller()->m_depth + 1 : 0;

    if(g_CLR_RT_ExecutionEngine.m_breakpointsNum)
    {
        if(stack->m_call.DebuggingInfo().HasBreakpoint())
        {
            stack->m_flags |= CLR_RT_StackFrame::c_HasBreakpoint;
        }

        if(stack->m_owningThread->m_fHasJMCStepper || (stack->m_flags & c_HasBreakpoint) || (caller->Prev() != NULL && (caller->m_flags & c_HasBreakpoint)))
        {
            g_CLR_RT_ExecutionEngine.Breakpoint_StackFrame_Push( stack, CLR_DBG_Commands::Debugging_Execution_BreakpointDef::c_DEPTH_STEP_CALL );
        }
    }
#endif

    //--//

#if defined(TINYCLR_JITTER)
    if(s_CLR_RT_fJitter_Enabled && (stack->m_flags & CLR_RT_StackFrame::c_MethodKind_Mask) == CLR_RT_StackFrame::c_MethodKind_Interpreted)
    {
        CLR_RT_ExecutionEngine::ExecutionConstraint_Suspend();

        g_CLR_RT_ExecutionEngine.Compile( stack->m_call, CLR_RT_ExecutionEngine::c_Compile_ARM );

        CLR_RT_ExecutionEngine::ExecutionConstraint_Resume();

        if(assm->m_jittedCode)
        {
            CLR_PMETADATA ipStart = (CLR_PMETADATA)assm->m_jittedCode[ stack->m_call.Method() ];

            if(ipStart != NULL)
            {
                stack->m_nativeMethod = (CLR_RT_MethodHandler)(size_t)g_thunkTable.m_address__Internal_Initialize;

                stack->m_IPstart = ipStart;

                if(md->flags & CLR_RECORD_METHODDEF::MD_HasExceptionHandlers)
                {
                    CLR_UINT32 numEh = *(CLR_UINT32*)ipStart;

                    stack->m_IP = ipStart + sizeof(CLR_UINT32) + numEh * sizeof(CLR_RT_ExceptionHandler);
                }
                else
                {
                    stack->m_IP = ipStart;
                }

                stack->m_flags &= ~CLR_RT_StackFrame::c_MethodKind_Mask;
                stack->m_flags |=  CLR_RT_StackFrame::c_MethodKind_Jitted;
            }
        }
    }
#endif

    if(caller->Prev() != NULL && caller->m_nativeMethod == stack->m_nativeMethod)
    {
        if(stack->m_flags & CLR_RT_StackFrame::c_ProcessSynchronize)
        {
            stack->m_flags |= CLR_RT_StackFrame::c_CallerIsCompatibleForRet;
        }
        else
        {
            stack->m_flags |= CLR_RT_StackFrame::c_CallerIsCompatibleForCall | CLR_RT_StackFrame::c_CallerIsCompatibleForRet;
        }
    }

    //
    // If the arguments are in the caller's stack frame (var == 0), let's link the two.
    //
    if(extraBlocks < 0)
    {
#if defined(PLATFORM_WINDOWS) || (defined(PLATFORM_WINCE) && defined(_DEBUG))
        if(caller->m_evalStackPos > caller->m_evalStackEnd)
        {
            TINYCLR_SET_AND_LEAVE(CLR_E_STACK_OVERFLOW);
        }
#endif

        //
        // Everything is set up correctly, pop the operands.
        //
        stack->m_arguments = &caller->m_evalStackPos[ -md->numArgs ];

        caller->m_evalStackPos = stack->m_arguments;

#if defined(PLATFORM_WINDOWS) || (defined(PLATFORM_WINCE) && defined(_DEBUG))
        if(stack->m_arguments < caller->m_evalStack)
        {
            TINYCLR_SET_AND_LEAVE(CLR_E_STACK_UNDERFLOW);
        }
#endif
    }
    else
    {
        stack->m_arguments = stack->m_evalStackEnd;
    }

    TINYCLR_CLEANUP();


    TINYCLR_CLEANUP_END();
}
HRESULT CLR_RT_ExecutionEngine::Compile( const CLR_RT_MethodDef_Index& md, CLR_UINT32 flags )
{
    TINYCLR_HEADER();

    MethodCompiler mc;
#if !defined(BUILD_RTM)
    CLR_UINT64     stats_start;
#endif

#if defined(PLATFORM_WINDOWS)
    g_CLR_RT_ArmEmulator.InitializeExternalCalls();
#endif

    ////////////////////////////////////////////////////////////////////////////

    //
    // Create thunk table.
    //
    if(g_thunkTable.m_address__Internal_Initialize == 0)
    {
        TINYCLR_CHECK_HRESULT(mc.Initialize( NULL, (CLR_UINT32)(size_t)m_jitter_current ));

        TINYCLR_CHECK_HRESULT(mc.CreateThunks( &g_thunkTable ));

        if(s_CLR_RT_fJitter_Enabled)
        {
            size_t      len = mc.m_Arm_Opcodes.Size() * sizeof(CLR_UINT32);
            FLASH_WORD* src = (FLASH_WORD*)&mc.m_Arm_Opcodes[ 0 ];
            FLASH_WORD* dst = m_jitter_current;
            FLASH_WORD* end = CLR_RT_Persistence_Manager::Bank::IncrementPointer( dst, (CLR_UINT32)len );

            //--//

            CODECOVERAGE_REGISTERTHUNK(Internal_Initialize                     );
            CODECOVERAGE_REGISTERTHUNK(Internal_Restart                        );
            CODECOVERAGE_REGISTERTHUNK(Internal_Error                          );
            CODECOVERAGE_REGISTERTHUNK(Internal_ErrorNoFlush                   );
            CODECOVERAGE_REGISTERTHUNK(Internal_ReturnFromMethod               );

            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__Compare_Values        );

            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericMul            );
            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericDiv            );
            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericDivUn          );
            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericRem            );
            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericRemUn          );
            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericShl            );
            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericShr            );
            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericShrUn          );
            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__InitObject            );
            CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__Convert               );

            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__HandleBoxing     );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__HandleIsInst     );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__HandleCasting    );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__CopyValueType    );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__CloneValueType   );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__LoadFunction     );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__LoadString       );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__NewArray         );

            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__Call             );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__CallVirtual      );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__NewObject        );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__NewDelegate      );

            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__AccessStaticField);

            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__Throw            );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__Rethrow          );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__Leave            );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__EndFinally       );

            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__LoadIndirect     );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__StoreIndirect    );

            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__LoadObject       );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__CopyObject       );
            CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__StoreObject      );

            //--//

            if(end < m_jitter_end)
            {
                ::Flash_ChipReadOnly( FALSE );

                while(dst < end)
                {
                    ::Flash_WriteToSector( Flash_FindSector(dst), dst++, sizeof(FLASH_WORD), (byte *)src );
                    src ++;
                }

                ::Flash_ChipReadOnly( TRUE );

                if(memcmp( m_jitter_current, &mc.m_Arm_Opcodes[ 0 ], len ) == 0)
                {
                    m_jitter_current = dst;
                }
                else
                {
                    CLR_Debug::Printf( "Jitter: failed to write thunk table!\r\n" );
                }
            }
            else
            {
                CLR_Debug::Printf( "Jitter: no space for thunk table!\r\n" );
            }
        }
#if defined(PLATFORM_WINDOWS)
        else
        {
            size_t len = mc.m_Arm_Opcodes.Size() * sizeof(CLR_UINT32);

            m_jitter_current = CLR_RT_Persistence_Manager::Bank::IncrementPointer( m_jitter_current, (CLR_UINT32)len );
        }
#endif

        mc.Release();
    }

    ////////////////////////////////////////////////////////////////////////////

#if !defined(BUILD_RTM)
    if(s_CLR_RT_fJitter_Trace_Compile >= c_CLR_RT_Trace_Info)
    {
        CLR_Debug::Printf( "\r\n\r\nJitting " ); CLR_RT_DUMP::METHOD( md ); CLR_Debug::Printf( "\r\n" );

        stats_start = Time_CurrentTicks();
    }
#endif

    TINYCLR_CHECK_HRESULT(mc.Initialize( &md, (CLR_UINT32)(size_t)m_jitter_current ));

    mc.ReferToThunks( &g_thunkTable );

    ////////////////////////////////////////////////////////////////////////////

    if(mc.m_mdInst.m_target->RVA == CLR_EmptyIndex)
    {
        //
        // Native implementation. Nothing to do.
        //
    }
    else
    {
        TINYCLR_CHECK_HRESULT(mc.ParseArguments());
        TINYCLR_CHECK_HRESULT(mc.ParseLocals   ());

        TINYCLR_CHECK_HRESULT(mc.ParseByteCode ());

        TINYCLR_CHECK_HRESULT(mc.ParseEvalStack());


        TINYCLR_CHECK_HRESULT(mc.GenerateCode());


#if !defined(BUILD_RTM)
        if(s_CLR_RT_fJitter_Trace_Compile >= c_CLR_RT_Trace_Verbose)
        {
            int milliSec = ((int)::Time_TicksToTime( Time_CurrentTicks() - stats_start ) + CLR_RT_Time::c_TickUnits - 1) / CLR_RT_Time::c_TickUnits;

            CLR_Debug::Printf( "Compile time: %dmsec\r\n", milliSec );
        }
#endif

        if(s_CLR_RT_fJitter_Enabled)
        {
            CLR_RT_Assembly* assm = mc.m_mdInst.m_assm;

            if(assm->m_jittedCode == NULL)
            {
                CLR_UINT32 size = assm->m_pTablesSize[ TBL_MethodDef ] * sizeof(CLR_RT_MethodHandler);

                assm->m_jittedCode = (CLR_RT_MethodHandler*)CLR_RT_Memory::Allocate_And_Erase( size );
            }

            if(assm->m_jittedCode)
            {
                size_t      len =               mc.m_Arm_Opcodes.Size() * sizeof(CLR_UINT32);
                FLASH_WORD* src = (FLASH_WORD*)&mc.m_Arm_Opcodes[ 0 ];
                FLASH_WORD* dst = m_jitter_current;
                FLASH_WORD* end = CLR_RT_Persistence_Manager::Bank::IncrementPointer( dst, (CLR_UINT32)len );

                CodeCoverage::Register( dst, md );

                if(end < m_jitter_end)
                {
                    ::Flash_ChipReadOnly( FALSE );

                    while(dst < end)
                    {
                        Flash_WriteToSector( Flash_FindSector(dst), dst++, sizeof(FLASH_WORD),(byte *) src );
                        src ++;
                    }

                    ::Flash_ChipReadOnly( TRUE );

                    if(memcmp( m_jitter_current, &mc.m_Arm_Opcodes[ 0 ], len ) == 0)
                    {
                        assm->m_jittedCode[ mc.m_mdInst.Method() ] = (CLR_RT_MethodHandler)m_jitter_current;

                        m_jitter_current = dst;
                    }
                    else
                    {
                        CLR_Debug::Printf( "Jitter: failed to write method!\r\n" );
                    }
                }
                else
                {
                    CLR_Debug::Printf( "Jitter: no space for method!\r\n" );
                }
            }
            else
            {
                CLR_Debug::Printf( "Jitter: cannot allocate method table!\r\n" );
            }
        }
#if defined(PLATFORM_WINDOWS)
        else
        {
            size_t len = mc.m_Arm_Opcodes.Size() * sizeof(CLR_UINT32);

            m_jitter_current = CLR_RT_Persistence_Manager::Bank::IncrementPointer( m_jitter_current, (CLR_UINT32)len );
        }
#endif
    }

    ////////////////////////////////////////////////////////////////////////////

    TINYCLR_CLEANUP();

    mc.Release();

    TINYCLR_CLEANUP_END();
}
HRESULT CLR_RT_XmlState_InStartElement::Process( CLR_RT_XmlState* st )
{
    TINYCLR_HEADER();
    CLR_RT_XmlState_InStartElement* state = &st->InStartElement;
    
    CLR_UINT8* buffer    = state->buffer;
    CLR_UINT8* bufferEnd = state->bufferEnd;
    CLR_UINT8  c;

    while(c_XmlCharType[ *buffer ] & XmlCharType_Space)
    {
        if(++buffer == bufferEnd) TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA);
    }

    c = *buffer;

    if(c == '>')
    {
        buffer++;
        
        TINYCLR_SET_AND_LEAVE(PrepReturn( state, false ));
    }
    else if(c == '/')
    {
        if((bufferEnd - buffer) >= 2)
        {
            if(*(buffer + 1) == '>')
            {
                buffer += 2;

                CLR_RT_HeapBlock_XmlReader* reader = state->reader;

                if(reader->GetXmlNodes()->GetSize() == 1)
                {
                    reader->SetIsDone( true );
                    
                    state->docState = XmlDocState_DoneWithMainDocument;
                }

                TINYCLR_SET_AND_LEAVE(PrepReturn( state, true ));
            }
            else
            {
                TINYCLR_SET_AND_LEAVE(XML_E_UNEXPECTED_TOKEN);
            }
        }
        else
        {
            TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA);
        }
    }
    else // start of attribute
    {
        CLR_RT_XmlState_InName::Setup( st, buffer, XmlNameType_Attribute );
    }

    TINYCLR_CLEANUP();

    state->buffer = buffer;

    TINYCLR_CLEANUP_END();
}
HRESULT CLR_RT_XmlState_InValue::Process( CLR_RT_XmlState* st )
{
    TINYCLR_HEADER();
    CLR_RT_XmlState_InValue* state = &st->InValue;
    
    CLR_UINT8* buffer    = state->buffer;
    CLR_UINT8* bufferEnd = state->bufferEnd;
    CLR_UINT8* value     = state->value;

    bool processOnly          = state->processOnly;
    CLR_UINT16 normalCharType = state->normalCharType;
    CLR_UINT8 endValueChar    = state->endValueChar;
    
    while(true)
    {
        while(c_XmlCharType[ *buffer ] & normalCharType)
        {
            if(++buffer == bufferEnd) TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA);
        }

        if(*buffer == '\r')
        {
            if(bufferEnd - buffer >= 2)
            {
                if(buffer[ 1 ] == '\n')
                {
                    if(!processOnly)
                    {
                        state->shiftHelper.SetNextCarRet( buffer - value, (CLR_UINT8*)buffer );
                    }
                    buffer += 2;
                }
                else
                {
                    *((LPSTR)buffer) = '\n';
                    buffer++;
                    continue;
                }
            }
            else
            {
                TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA);
            }
        }
        else if(*buffer == endValueChar)
        {
            bool isDone = true;
            
            hr = state->endFn( st, buffer, isDone );

            if(isDone) TINYCLR_LEAVE();
        }
        else if(*buffer == '&')
        {
            CLR_INT32 count = CLR_RT_XmlCharRef::ParseCharRef( (LPSTR)buffer, bufferEnd - buffer, buffer - state->value, &state->shiftHelper );

            if(count > 0)
            {
                buffer += count;
            }
            else
            {
                TINYCLR_SET_AND_LEAVE((count == 0) ? XML_E_NEED_MORE_DATA : XML_E_BAD_OR_UNSUPPORTED_ENTITY);
            }
        }
        else
        {
            bool isDone = true;
            
            hr = state->othersFn( st, buffer, isDone );

            if(isDone) TINYCLR_LEAVE();
        }

        if(buffer == bufferEnd) TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA);
    }

    TINYCLR_CLEANUP();

    state->buffer = buffer;

    TINYCLR_CLEANUP_END();
}
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::getaddrinfo___STATIC__VOID__STRING__BYREF_STRING__BYREF_SZARRAY_SZARRAY_U1( CLR_RT_StackFrame& stack )
{
    NATIVE_PROFILE_CLR_NETWORK();
    TINYCLR_HEADER();

    LPCSTR szName = stack.Arg0().RecoverString();
    struct SOCK_addrinfo hints;
    struct SOCK_addrinfo* addr = NULL;
    struct SOCK_addrinfo* addrT;
    CLR_UINT32        cAddresses = 0;
    CLR_RT_HeapBlock* pAddress;
    CLR_INT32         timeout_ms = 30000;
    CLR_RT_HeapBlock  hbTimeout;
    CLR_INT32         ret;
    bool              fRes = true;
    CLR_INT64*        timeout;

    hbTimeout.SetInteger( timeout_ms );

    TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout ));

    do
    {
        memset( &hints, 0, sizeof(hints) );

        ret = SOCK_getaddrinfo( szName, NULL, &hints, &addr );

        if(ret == SOCK_SOCKET_ERROR)
        {
            if(SOCK_getlasterror() == SOCK_EWOULDBLOCK)
            {
                // non-blocking - allow other threads to run while we wait for handle activity
                TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_Socket, fRes ));
            }
            else
            {
                break;
            }
        }
        else
        {
            break;
        }
    }
    while(fRes);
    
    // timeout expired
    if(!fRes)
    {
        ret = SOCK_SOCKET_ERROR;
        
        ThrowError( stack, SOCK_ETIMEDOUT );
    
        TINYCLR_SET_AND_LEAVE( CLR_E_PROCESS_EXCEPTION );
    }

    // getaddrinfo returns a winsock error code rather than SOCK_SOCKET_ERROR, so pass this on to the exception handling
    if(ret != 0)
    {
        ThrowError( stack, ret );
        TINYCLR_SET_AND_LEAVE(CLR_E_PROCESS_EXCEPTION);
    }

    {
        CLR_RT_HeapBlock  hbCanonicalName;
        CLR_RT_HeapBlock  hbAddresses;
        
        hbCanonicalName.SetObjectReference( NULL );
        CLR_RT_ProtectFromGC gc( hbCanonicalName );

        hbAddresses.SetObjectReference( NULL );
        CLR_RT_ProtectFromGC gc2( hbAddresses );

        for(int pass = 0; pass < 2; pass++)
        {                                    
            cAddresses = 0;

            for(addrT = addr; addrT != NULL; addrT = addrT->ai_next)
            {
                if(pass == 1)
                {
                    if(addrT->ai_canonname && addrT->ai_canonname[ 0 ])
                    {
                        //allocate return string
                        TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance( hbCanonicalName, addrT->ai_canonname ));
                        TINYCLR_CHECK_HRESULT(hbCanonicalName.StoreToReference( stack.Arg1(), 0 ));
                    }

                    //allocate address and store into array
                    pAddress = (CLR_RT_HeapBlock*)hbAddresses.DereferenceArray()->GetElement( cAddresses );

                    TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( *pAddress, (CLR_UINT32)addrT->ai_addrlen, g_CLR_RT_WellKnownTypes.m_UInt8 ));

                    //copy address.
                    memcpy( pAddress->DereferenceArray()->GetFirstElement(), addrT->ai_addr, addrT->ai_addrlen );
                }
                                
                cAddresses++;
            }
                            
            if(pass == 0)
            {
                //allocate array of byte arrays
                CLR_RT_ReflectionDef_Index idx;

                idx.m_kind               = REFLECTION_TYPE;
                idx.m_levels             = 2;
                idx.m_data.m_type.m_data = g_CLR_RT_WellKnownTypes.m_UInt8.m_data;

                TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( hbAddresses, cAddresses, idx ));

                TINYCLR_CHECK_HRESULT(hbAddresses.StoreToReference( stack.Arg2(), 0 ));                
            }
        }    
    }

    stack.PopValue();       // Timeout
    
    TINYCLR_CLEANUP();

    if( addr ) SOCK_freeaddrinfo( addr );

    TINYCLR_CLEANUP_END();
}
HRESULT Library_spot_net_security_native_Microsoft_SPOT_Net_Security_SslNative::InitHelper( CLR_RT_StackFrame& stack, bool isServer )
{
    NATIVE_PROFILE_CLR_NETWORK();
    TINYCLR_HEADER();

    CLR_INT32 sslContext            = -1;
    CLR_INT32 sslMode               = stack.Arg0().NumericByRef().s4;
    CLR_INT32 sslVerify             = stack.Arg1().NumericByRef().s4;
    CLR_RT_HeapBlock *hbCert        = stack.Arg2().Dereference(); 
    CLR_RT_HeapBlock_Array* arrCA   = stack.Arg3().DereferenceArray(); 
    CLR_RT_HeapBlock_Array* arrCert = NULL;
    CLR_UINT8*  sslCert             = NULL;
    int         result;
    int         i;
    bool        isFirstCall = false;
    LPCSTR      szPwd = "";

    if(!g_SSL_SeedData.Initialized)
    {
        BOOL fOK = FALSE;

        isFirstCall = true;

#if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE)
        int i;

        if(!HAL_CONFIG_BLOCK::ApplyConfig( g_SSL_SeedData.Config.GetDriverName(), &g_SSL_SeedData.Config, sizeof(g_SSL_SeedData.Config) ))
        {
            return CLR_E_NOT_SUPPORTED;
        }

        // validate the security key (make sure it isn't all 0x00 or all 0xFF
        for(i=1; i<sizeof(g_SSL_SeedData.Config.SslSeedKey) && !fOK; i++)
        {
            if( g_SSL_SeedData.Config.SslSeedKey[ i   ] != 0 && 
                g_SSL_SeedData.Config.SslSeedKey[ i   ] != 0xFF && 
                g_SSL_SeedData.Config.SslSeedKey[ i-1 ] != g_SSL_SeedData.Config.SslSeedKey[ i ])
            {
                fOK = TRUE;
            }
        }

        if(!fOK)
        {
            return CLR_E_NOT_SUPPORTED;
        }
#endif

        g_SSL_SeedData.m_completion.Initialize();
        
        g_SSL_SeedData.m_completion.InitializeForUserMode( UpdateSslSeedValue, NULL ); 

        g_SSL_SeedData.Initialized = TRUE;
    }


    if(hbCert != NULL)
    {
        arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_certificate ].DereferenceArray(); //FAULT_ON_NULL(arrCert);

        // If arrCert == NULL then the certificate is an X509Certificate2 which uses a certificate handle
        if(arrCert == NULL)
        {
            arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_handle ].DereferenceArray(); FAULT_ON_NULL(arrCert);    

            // pass the certificate handle as the cert data parameter
            sslCert = arrCert->GetFirstElement();

            arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_sessionHandle ].DereferenceArray(); FAULT_ON_NULL(arrCert);    

            // pass the session handle as the ssl context parameter
            sslContext = *(INT32*)arrCert->GetFirstElement();

            // the certificate has already been loaded so just pass an empty string
            szPwd = "";
        }
        else
        {
            arrCert->Pin();
        
            sslCert = arrCert->GetFirstElement();

            CLR_RT_HeapBlock *hbPwd = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_password ].Dereference();// FAULT_ON_NULL(hbPwd);

            szPwd = hbPwd->StringText();
        }
    }

    SSL_RegisterTimeCallback( Time_GetDateTime );

    if(isServer)
    {
        result = (SSL_ServerInit( sslMode, sslVerify, (const char*)sslCert, sslCert == NULL ? 0 : arrCert->m_numOfElements, szPwd, sslContext ) ? 0 : -1);
    }
    else
    {
        result = (SSL_ClientInit( sslMode, sslVerify, (const char*)sslCert, sslCert == NULL ? 0 : arrCert->m_numOfElements, szPwd, sslContext ) ? 0 : -1);
    }

    TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));

    if(isFirstCall)
    {
        GenerateNewSslSeed();
    }

    if(arrCA != NULL)
    {
        for(i=0; i<(int)arrCA->m_numOfElements; i++)
        {
            hbCert = (CLR_RT_HeapBlock*)arrCA->GetElement( i ); FAULT_ON_NULL(hbCert);
            hbCert = hbCert->Dereference();                     FAULT_ON_NULL(hbCert);

            arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_certificate ].DereferenceArray(); //FAULT_ON_NULL(arrCert);

            // If arrCert == NULL then the certificate is an X509Certificate2 which uses a certificate handle
            if(arrCert == NULL)
            {
                CLR_INT32 sessionCtx = 0;

                arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_handle ].DereferenceArray(); FAULT_ON_NULL(arrCert);    

                sslCert = arrCert->GetFirstElement();

                arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_sessionHandle ].DereferenceArray(); FAULT_ON_NULL(arrCert);    

                sessionCtx = *(INT32*)arrCert->GetFirstElement();

                // pass the session handle down as the password paramter and the certificate handle as the data parameter
                result = (SSL_AddCertificateAuthority( sslContext, (const char*)sslCert, arrCert->m_numOfElements, (LPCSTR)&sessionCtx ) ? 0 : -1);
                
                TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));
            }
            else
            {

                arrCert->Pin();

                sslCert = arrCert->GetFirstElement();

                CLR_RT_HeapBlock *hbPwd = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_password ].Dereference(); FAULT_ON_NULL(hbPwd);

                LPCSTR szCAPwd = hbPwd->StringText();
                
                result = (SSL_AddCertificateAuthority( sslContext, (const char*)sslCert, arrCert->m_numOfElements, szCAPwd ) ? 0 : -1);
                
                TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));
            }
        }
    }

    stack.SetResult_I4( sslContext );    

    TINYCLR_CLEANUP();

    if(FAILED(hr) && (sslContext != -1))
    {
        SSL_ExitContext( sslContext );        
    }

    TINYCLR_CLEANUP_END();
}
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();
}
Пример #28
0
HRESULT CLR_GFX_Bitmap::CreateInstanceJpeg( CLR_RT_HeapBlock& ref, const CLR_UINT8* data, const CLR_UINT32 size )
{
    NATIVE_PROFILE_CLR_GRAPHICS();
    TINYCLR_HEADER();

    jpeg_decompress_struct        cinfo;
    CLR_GFX_Bitmap*               bitmap = NULL;
    CreateInstanceJpegHelperParam param;
    GFX_Rect                      rect;

    param.curBuffer = NULL;

    // Set up the error handling
    JPEGErrorManager errorManager;
    cinfo.err                   = jpeg_std_error( &errorManager.pub );
    errorManager.pub.error_exit = JPEGErrorHandler;

#if 0
    if(setjmp( (long long *)errorManager.setjmpBuffer ))
#else
    if(setjmp(errorManager.setjmpBuffer ))
#endif
    {
        if (cinfo.err->msg_code == JERR_OUT_OF_MEMORY)
        {
            TINYCLR_SET_AND_LEAVE( CLR_E_OUT_OF_MEMORY );
        }
        else
        {
            TINYCLR_SET_AND_LEAVE( CLR_E_FAIL );
        }
    }

    // Create the decompression engine
    jpeg_create_decompress( &cinfo );
    jpeg_byte_array_src   ( &cinfo, (UINT8*)data, size );
    jpeg_read_header      ( &cinfo, TRUE );

    // Set output to 16bit 5-6-5 RGB format
    // We can add support for other bit-depth in the future
    cinfo.out_color_space     = JCS_RGB;
    cinfo.do_fancy_upsampling = FALSE;

    jpeg_start_decompress( &cinfo );

    // At this point cinfo would have all the correct output dimension info
    CLR_GFX_BitmapDescription bm;
    if(bm.BitmapDescription_Initialize( cinfo.output_width, cinfo.output_height, CLR_GFX_BitmapDescription::c_NativeBpp ) == false)
    {
        // if the resulting bitmap doesn't match our constraints, stop the decompression
        TINYCLR_SET_AND_LEAVE( CLR_E_INVALID_PARAMETER );
    }

    // Allocate the memory that the decompressed bitmap would need
    TINYCLR_CHECK_HRESULT(CLR_GFX_Bitmap::CreateInstance( ref, bm ));

    TINYCLR_CHECK_HRESULT(CLR_GFX_Bitmap::GetInstanceFromHeapBlock (ref, bitmap));

    // Do the actual decompression
    rect.left = 0;
    rect.top = 0;
    rect.right = cinfo.output_width - 1;
    rect.bottom = cinfo.output_height - 1;

    param.curBuffer = (CLR_UINT8*)CLR_RT_Memory::Allocate( cinfo.output_width * 3 );
    CHECK_ALLOCATION(param.curBuffer);
    param.buffer    = (JSAMPARRAY)&(param.curBuffer);
    param.cinfo     = &cinfo;

    bitmap->SetPixelsHelper( rect, PAL_GFX_Bitmap::c_SetPixelsConfig_NoClip | PAL_GFX_Bitmap::c_SetPixelsConfig_NoClipChecks, &CreateInstanceJpegHelper, &param );

    TINYCLR_CLEANUP();

    if (param.curBuffer) CLR_RT_Memory::Release( param.curBuffer );
    jpeg_destroy_decompress( &cinfo );

    TINYCLR_CLEANUP_END();
}
Пример #29
0
    HRESULT Cmd_ConvertFont( CLR_RT_ParseOptions::ParameterList* params = NULL )
    {
        TINYCLR_HEADER();

        LPCWSTR szFileIn  = PARAM_EXTRACT_STRING(params, 0);
        LPCWSTR szFileOut = PARAM_EXTRACT_STRING(params, 1);

        CLR_GFX_FontBuilder         fb;
        CLR_GFX_Font*               font = NULL;
        CLR_RT_Buffer               buf;
        CLR_RT_Buffer               bufT;
        CLR_UINT8*                  ptr;
        CLR_UINT32                  size;
        TinyResourcesFileHeader     fileHeader;
        TinyResourcesResourceHeader resource;

        TINYCLR_CHECK_HRESULT(fb.Initialize());

        buf.clear();

        TINYCLR_CHECK_HRESULT(CLR_RT_FileStore::LoadFile( szFileIn, buf ));

#if FNT_SUPPORT
        if(StringEndsWithSuffix( szFileIn, L".fntdef" ))
        {
            TINYCLR_CHECK_HRESULT(fb.LoadFromScript( buf ));
        }
        else
        {
            TINYCLR_CHECK_HRESULT(fb.LoadFromFNT( buf, 0, 255, 0 ));
        }
#else
        TINYCLR_CHECK_HRESULT(fb.LoadFromScript( buf ));
#endif

        TINYCLR_CHECK_HRESULT(fb.GenerateFont( font ));

        TINYCLR_CHECK_HRESULT(font->SaveToBuffer( bufT ));

        /*.tinyresources format */

        fileHeader.magicNumber          = TinyResourcesFileHeader::MAGIC_NUMBER;
        fileHeader.version              = CLR_RECORD_RESOURCE_FILE::CURRENT_VERSION;
        fileHeader.sizeOfHeader         = sizeof(fileHeader);
        fileHeader.sizeOfResourceHeader = sizeof(resource);
        fileHeader.numberOfResources    = 1;

        resource.id = 0;
        resource.kind = CLR_RECORD_RESOURCE::RESOURCE_Font;
        resource.pad = 0;
        resource.size = (CLR_UINT32)bufT.size();

        buf.clear();

        size = fileHeader.sizeOfHeader;
        size += fileHeader.numberOfResources*fileHeader.sizeOfResourceHeader;
        size += (CLR_UINT32)bufT.size();

        buf.resize(size);
        ptr = &buf[ 0 ];
        //write file header
        memcpy(ptr, &fileHeader, fileHeader.sizeOfHeader        ); ptr += fileHeader.sizeOfHeader;
        //write resource header
        memcpy(ptr, &resource  , fileHeader.sizeOfResourceHeader); ptr += fileHeader.sizeOfResourceHeader;
        //write resource data
        memcpy(ptr, &bufT[0]   , bufT.size()                    ); ptr += bufT.size();

        TINYCLR_CHECK_HRESULT(CLR_RT_FileStore::SaveFile( szFileOut, buf ));

        TINYCLR_CLEANUP();

        if(font)
        {
            free(font);
        }

        TINYCLR_CLEANUP_END();
    }
Пример #30
0
HRESULT CLR_RT_StackFrame::PopAppDomainTransition()
{
    NATIVE_PROFILE_CLR_CORE();
    TINYCLR_HEADER();

    bool fException = false;
    CLR_RT_HeapBlock exception;
    CLR_RT_StackFrame* caller = this->Caller();

    exception.SetObjectReference( NULL );

    if(m_flags & CLR_RT_StackFrame::c_AppDomainInjectException)
    {
        //this is the last frame on the thread in a doomed AppDomain
        //Convert the current ThreadAbortException into an AppDomainUnloaded exception

        _ASSERTE(m_owningThread->m_flags & CLR_RT_Thread::TH_F_Aborted);
        _ASSERTE(m_owningThread->m_flags & CLR_RT_Thread::TH_F_ContainsDoomedAppDomain);
        _ASSERTE(m_owningThread->m_currentException.Dereference() != NULL);
        _ASSERTE(m_owningThread->m_currentException.Dereference()->ObjectCls().m_data == g_CLR_RT_WellKnownTypes.m_ThreadAbortException.m_data);
        _ASSERTE(!m_appDomain->IsLoaded());

        m_owningThread->m_flags &= ~(CLR_RT_Thread::TH_F_Aborted | CLR_RT_Thread::TH_F_ContainsDoomedAppDomain);

        hr = CLR_E_APPDOMAIN_EXITED;
    }
    else if(m_owningThread->m_currentException.Dereference() == NULL)
    {
        _ASSERTE((m_flags & CLR_RT_StackFrame::c_AppDomainInjectException) == 0);

        //Normal return.  No exception is in flight

        if(m_flags & CLR_RT_StackFrame::c_AppDomainMethodInvoke)
        {
            //  For dynamic invoke,
            //  we do not marshal byRef parameters back to the calling AppDomain
            //  The caller is a native method (MethodBase::Invoke), and does not have the args on it's eval stack.
        }
        else
        {
            int cArgs = m_call.m_target->numArgs;

            //First marshal the ref parameters
            TINYCLR_CHECK_HRESULT(caller->m_appDomain->MarshalParameters( &caller->m_evalStackPos[ -cArgs ], m_arguments, cArgs, true ));

            //Now, pop the caller's arguments off the eval stack
            caller->m_evalStackPos -= cArgs;
        }

        // Now, push the return, if any.
        if(m_call.m_target->retVal != DATATYPE_VOID)
        {
            CLR_RT_HeapBlock& dst = caller->PushValueAndClear();
            CLR_RT_HeapBlock& src = this  ->TopValue ();

            TINYCLR_CHECK_HRESULT(caller->m_appDomain->MarshalObject( src, dst ));

            dst.Promote();
        }
    }
    else //Exception
    {
        //Normal exceptions must be marshaled to the caller's AppDomain
        TINYCLR_CHECK_HRESULT(caller->m_appDomain->MarshalObject( m_owningThread->m_currentException, exception ));
        fException = true;
    }

    TINYCLR_CLEANUP();

    if(FAILED(hr) || fException)
    {
        if(FAILED(hr))
        {
            (void)Library_corlib_native_System_Exception::CreateInstance( exception, hr, caller );
        }

        m_owningThread->m_currentException.Assign( exception );
    }

    (void)g_CLR_RT_ExecutionEngine.SetCurrentAppDomain( caller->m_appDomain );

    TINYCLR_CLEANUP_END();
}