oc_thread.c

Go to the documentation of this file.

#include <oc_thread.h>
#include <oc_object.h>
#include <oc_memman.h>
#include <oc_sys_lld.h>
#include <oc_system_cfg.h>
#include <oc_stdlib.h>
#include <oc_processman.h>
#include <oc_threadman.h>
#include <oc_intman.h>
#include <oc_mem_lld.h>
#include <oc_debug.h>

#define _________________________________________TYPES_SECTION______________________________________________________________________________

typedef struct
{
    oC_Thread_RevertFunction_t      Function;
    void *                          Object;
    uint32_t                        Parameter;
} RevertAction_t;

typedef oC_Thread_FinishedFunction_t FinishedFunction_t;

//==========================================================================================================================================
//==========================================================================================================================================
struct Thread_t
{
    oC_ObjectControl_t       ObjectControl;          
    oC_Process_t             Process;                
    oC_Thread_Priority_t     Priority;               
    const char *             Name;                   
    oC_UInt_t *              RedZone;                
    oC_UInt_t *              RedZoneEnd;             
    void *                   RealStackStart;         
    oC_SYS_LLD_Context_t *   Context;                
    void *                   StackStart;             
    oC_Int_t                 RealStackSize;          
    uint32_t *               BlockedFlag;            
    uint32_t                 StateToUnblock;         
    uint32_t                 UnblockMask;            
    oC_Thread_Unblock_t      Unblock;                
    oC_Timestamp_t           TimeoutTimestamp;       
    oC_Time_t                ExecutionTime;          
    uint32_t                 LastExecutionTick;      
    oC_Int_t                 StackSize;              
    oC_Thread_Function_t     Function;               
    void *                   Parameter;              
    FinishedFunction_t       FinishedFunction;       
    void *                   FinishedParameter;      
    RevertAction_t           ActionsToRevert[CFG_UINT8_MAX_ACTIONS_TO_REVERT];  
};

typedef bool (*CheckFunction_t)( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask );

#undef  _________________________________________TYPES_SECTION______________________________________________________________________________

#define _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________

static void ThreadExitHandler( void );
static bool CheckUnblockedWhenEqual         ( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask );
static bool CheckUnblockedWhenNotEqual      ( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask );
static bool CheckUnblockedWhenSmaller       ( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask );
static bool CheckUnblockedWhenGreater       ( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask );
static bool CheckUnblockedWhenSmallerOrEqual( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask );
static bool CheckUnblockedWhenGreaterOrEqual( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask );

#undef  _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________


#define _________________________________________VARIABLES_SECTION__________________________________________________________________________

static const uint16_t           NotUsedByteValue = 0xbeef;
static const CheckFunction_t    CheckFunctions[] = {
                CheckUnblockedWhenEqual ,
                CheckUnblockedWhenNotEqual,
                CheckUnblockedWhenSmaller ,
                CheckUnblockedWhenGreater ,
                CheckUnblockedWhenSmallerOrEqual ,
                CheckUnblockedWhenGreaterOrEqual
};

#undef  _________________________________________VARIABLES_SECTION__________________________________________________________________________


#define _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________


//==========================================================================================================================================
//==========================================================================================================================================
oC_Thread_t oC_Thread_New( oC_Thread_Priority_t Priority , oC_Int_t StackSize , void * Process , const char * Name , oC_Thread_Function_t Function , void * Parameter )
{
    oC_Thread_t thread = NULL;

    if(oC_SYS_LLD_IsMachineSupportMultithreadMode())
    {
        Allocator_t     allocator = NULL;
        oC_Process_t    process   = Process;

        if(process == NULL)
        {
            process   = oC_ProcessMan_GetCurrentProcess();
        }

        if(oC_Process_IsCorrect(process) == false)
        {
            kdebuglog(oC_LogType_Error,"thread: process 0x%08X is not correct" , Process);
        }

        allocator = oC_Process_GetAllocator(process);

        if(StackSize == 0)
        {
            StackSize = oC_ThreadMan_GetDefaultStackSize();
        }

        StackSize = oC_MemMan_AlignSizeTo(StackSize,oC_MEM_LLD_STACK_ALIGNMENT);

        if(allocator)
        {
            thread = kmalloc(sizeof(struct Thread_t) , allocator , AllocationFlags_CanWait1Second | AllocationFlags_ZeroFill );

            if(thread)
            {
                oC_MemorySize_t redZoneSize        = oC_ThreadMan_GetRedZoneSize();
                oC_UInt_t       minimumContextSize = oC_SYS_LLD_GetMinimumContextSize(StackSize + redZoneSize);
                void * realStack = kamalloc(minimumContextSize , allocator , AllocationFlags_CanWait1Second , oC_MEM_LLD_STACK_ALIGNMENT );
                void * endStack  = (void*)(((oC_UInt_t)realStack) + minimumContextSize);

                /* Filling a stack with special value for checking if all stack is used */
                for(uint16_t * stack = (uint16_t*)realStack; stack < ((uint16_t*)endStack) ; stack++ )
                {
                    *stack = NotUsedByteValue;
                }

                if(realStack)
                {
                    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

                    thread->ObjectControl       = oC_CountObjectControl(thread,oC_ObjectId_Thread);
                    thread->Name                = Name;
                    thread->Priority            = Priority + oC_Process_GetPriority(process);
                    thread->BlockedFlag         = NULL;
                    thread->TimeoutTimestamp    = 0;
                    thread->ExecutionTime       = 0;
                    thread->RealStackSize       = minimumContextSize;
                    thread->StackSize           = StackSize;
                    thread->Process             = process;
                    thread->Function            = Function;
                    thread->Parameter           = Parameter;
                    thread->RealStackStart      = realStack;

                    if(oC_SYS_LLD_IsStackPushDecrementPointer())
                    {
                        // 0x00000000 - ,----------------------------------------.
                        //              |                RED ZONE                |
                        //              |----------------------------------------|
                        //              |                 STACK                  |
                        // 0xFFFFFFFF - '----------------------------------------'
                        thread->RedZone   = realStack;
                        thread->Context   = oC_MemMan_AlignAddressTo((void*)(((oC_UInt_t)realStack) + redZoneSize),oC_MEM_LLD_STACK_ALIGNMENT);
                    }
                    else
                    {
                        // 0x00000000 - ,----------------------------------------.
                        //              |                 STACK                  |
                        //              |----------------------------------------|
                        //              |                RED ZONE                |
                        // 0xFFFFFFFF - '----------------------------------------'
                        thread->RedZone   = (void*)(((oC_UInt_t)realStack) + StackSize);
                        thread->Context   = realStack;
                    }

                    thread->StackStart = thread->Context;
                    thread->RedZoneEnd = oC_MemMan_AlignAddressTo((void*)(((oC_UInt_t)thread->RedZone) + redZoneSize),oC_MEM_LLD_STACK_ALIGNMENT);

                    errorCode = oC_SYS_LLD_InitializeContext(&thread->Context,StackSize,Function,Parameter,ThreadExitHandler);

                    if(errorCode == oC_ErrorCode_ModuleNotStartedYet)
                    {
                        oC_SYS_LLD_TurnOnDriver();
                        errorCode = oC_SYS_LLD_InitializeContext(&thread->Context,StackSize,Function,Parameter,ThreadExitHandler);
                    }

                    if(oC_ErrorOccur(errorCode))
                    {
                        oC_SaveError("Thread: Cannot initialize context" , errorCode);

                        if(!kfree(realStack , AllocationFlags_CanWait1Second) ||
                           !kfree(thread , AllocationFlags_CanWait1Second)
                           )
                        {
                            oC_SaveError("Thread: Cannot release memory" , oC_ErrorCode_AllocationError);
                        }
                        thread = NULL;
                    }
                }
                else
                {
                    bool stackReleased  = kfree(realStack,0);

                    oC_SaveIfFalse("Stack"      , stackReleased || realStack          == NULL, oC_ErrorCode_ReleaseError);
                    if(!kfree(thread,AllocationFlags_CanWait1Second))
                    {
                        oC_SaveError("Thread: Cannot release memory" , oC_ErrorCode_AllocationError);
                    }
                    thread = NULL;
                }
            }
        }

    }

    return thread;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_IsOwnedByStack( oC_Thread_t Thread , const void * Address , bool * outAddressInRedZone )
{
    bool owned = false;

    if(oC_Thread_IsCorrect(Thread) && (outAddressInRedZone == NULL || isram(outAddressInRedZone)))
    {
        void * stackEnd     = Thread->StackStart;
        void * stackStart   = Thread->StackStart;

        stackEnd += Thread->StackSize;

        if(outAddressInRedZone != NULL)
        {
            void * redZoneStart = Thread->RedZone;
            void * redZoneEnd   = Thread->RedZoneEnd;
            *outAddressInRedZone = Address >= redZoneStart && Address <= redZoneEnd;
        }

        owned = Address >= stackStart && Address < stackEnd;
    }

    return owned;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Thread_t oC_Thread_CloneWithNewStack( oC_Thread_t Thread , oC_MemorySize_t NewStackSize )
{
    oC_Thread_t newThread = NULL;

    if(oC_Thread_IsCorrect(Thread) && NewStackSize > 0)
    {
        newThread = oC_Thread_New(Thread->Priority,NewStackSize,Thread->Process,Thread->Name,Thread->Function,Thread->Parameter);
    }

    return newThread;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_Delete( oC_Thread_t * Thread )
{
    bool deleted = false;

    if(isram(Thread) && oC_Thread_IsCorrect(*Thread))
    {
        if(oC_ThreadMan_GetCurrentThread() != (*Thread))
        {
            uint32_t blockingFlag  = 0;
            bool     threadRemoved = false;

            oC_Thread_SetBlocked(*Thread,&blockingFlag,oC_Thread_Unblock_WhenEqual,0xff,oC_Thread_UnblockMask_All,oC_hour(1));

            oC_IntMan_EnterCriticalSection();

            if(oC_Thread_IsActive(*Thread))
            {
                threadRemoved               = oC_SaveIfErrorOccur("Thread - Removing from list: ", oC_ThreadMan_RemoveThread(*Thread));
                deleted                     = threadRemoved;
                (*Thread)->ObjectControl    = 0;
            }
            else
            {
                void * realStack = (*Thread)->RealStackStart;

                bool     stackReleased = false;
                bool     objectReleased= false;

                oC_ARRAY_FOREACH_IN_ARRAY((*Thread)->ActionsToRevert,action)
                {
                    if(action->Function != NULL)
                    {
                        if(oC_SaveIfFalse("cannot revert action", isaddresscorrect(action->Function), oC_ErrorCode_WrongAddress))
                        {
                            oC_SaveIfFalse("cannot revert action",  action->Function(*Thread,action->Object,action->Parameter), oC_ErrorCode_InternalDataAreDamaged );
                        }
                    }
                }

                threadRemoved = true;
                (*Thread)->ObjectControl = 0;

                stackReleased  = kfree(realStack, AllocationFlags_CanWaitForever);
                objectReleased = kfree(*Thread,   AllocationFlags_CanWaitForever);

                if(
                    threadRemoved
                 && oC_SaveIfFalse("Thread - Stack  - ", stackReleased  , oC_ErrorCode_ReleaseError )
                 && oC_SaveIfFalse("Thread - Object - ", objectReleased , oC_ErrorCode_ReleaseError )
                    )
                {
                    *Thread = NULL;
                    deleted = true;
                }

            }
            oC_IntMan_ExitCriticalSection();

        }
        else
        {
            oC_IntMan_EnterCriticalSection();
            /* This is current thread, we cannot delete it now */
            oC_ErrorCode_t errorCode = oC_ThreadMan_RemoveThread(*Thread);

            if(oC_ErrorOccur(errorCode))
            {
                oC_SaveError((*Thread)->Name , errorCode);
            }
            else
            {
                deleted = true;
            }

            oC_IntMan_ExitCriticalSection();

            if(oC_IntMan_AreInterruptsTurnedOn())
            {
                while(deleted);
            }
        }
    }


    return deleted;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_IsCorrect( oC_Thread_t Thread )
{
    return oC_MemMan_IsDynamicAllocatedAddress(Thread) && oC_CheckObjectControl(Thread,oC_ObjectId_Thread,Thread->ObjectControl);
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_IsActive( oC_Thread_t Thread )
{
    return oC_Thread_IsCorrect(Thread) && oC_ThreadMan_ContainsThread(Thread);
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_SetBlocked( oC_Thread_t Thread , uint32_t * BlockingFlag , oC_Thread_Unblock_t Unblock , uint32_t StateToUnblock , oC_Thread_UnblockMask_t UnblockMask , oC_Time_t Timeout )
{
    bool blocked = false;

    if(
        oC_Thread_IsCorrect(Thread) &&
        oC_MemMan_IsRamAddress(BlockingFlag) &&
        Timeout >= 0
        )
    {
        oC_IntMan_EnterCriticalSection();
        Thread->BlockedFlag         = BlockingFlag;
        Thread->StateToUnblock      = StateToUnblock;
        Thread->TimeoutTimestamp    = oC_KTime_GetTimestamp() + Timeout;
        Thread->Unblock             = Unblock;
        Thread->UnblockMask         = UnblockMask;
        oC_IntMan_ExitCriticalSection();

        oC_ThreadMan_SwitchThread();

        blocked = *BlockingFlag != StateToUnblock;
    }

    return blocked;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_SetUnblocked( oC_Thread_t Thread )
{
    bool unblocked = false;

    if(oC_Thread_IsCorrect(Thread))
    {
        oC_IntMan_EnterCriticalSection();
        Thread->BlockedFlag         = NULL;
        Thread->TimeoutTimestamp    = 0;
        unblocked                   = true;
        oC_IntMan_ExitCriticalSection();

        oC_ThreadMan_SwitchThread();
    }

    return unblocked;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_IsBlocked( oC_Thread_t Thread )
{
    bool blocked = true;

    if(oC_Thread_IsCorrect(Thread))
    {
        oC_IntMan_EnterCriticalSection();
        oC_Timestamp_t currentTimestamp = oC_KTime_GetTimestamp();
        oC_Timestamp_t timeout          = Thread->TimeoutTimestamp;
        uint32_t       blockedFlag      = *Thread->BlockedFlag;
        uint32_t       stateToUnblock   = Thread->StateToUnblock;
        uint32_t       unblockMask      = Thread->UnblockMask;
        uint32_t*      blockedFlagRef   = Thread->BlockedFlag;
        oC_IntMan_ExitCriticalSection();

        if(
            ((blockedFlagRef == NULL) && (currentTimestamp < Thread->TimeoutTimestamp)) ||
            ((blockedFlagRef != NULL) && (CheckFunctions[Thread->Unblock](blockedFlag,stateToUnblock,unblockMask)) && (currentTimestamp < timeout))
            )
        {
            blocked = true;
        }
        else
        {
            blocked = false;
        }
    }

    return blocked;
}


//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_IsBlockedBy( oC_Thread_t Thread , uint32_t * BlockingFlag )
{
    return oC_Thread_IsCorrect(Thread) && isram(BlockingFlag) && Thread->BlockedFlag == BlockingFlag;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_Run( oC_Thread_t Thread )
{
    bool runned = false;

    if(oC_Thread_IsCorrect(Thread))
    {
        oC_ErrorCode_t errorCode = oC_ThreadMan_AddThread(Thread);

        if(oC_ErrorOccur(errorCode))
        {
            oC_SaveError(Thread->Name,errorCode);
        }
        else
        {
            runned = true;
        }
    }

    return runned;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_Cancel( oC_Thread_t * Thread )
{
    bool canceled = false;

    if(oC_Thread_IsCorrect(*Thread))
    {
        oC_Thread_t thread = *Thread;

        if(thread->FinishedFunction != NULL)
        {
            if(oC_SaveIfFalse("Finished Function", isaddresscorrect(thread->FinishedFunction), oC_ErrorCode_WrongAddress))
            {
                thread->FinishedFunction(thread, thread->FinishedParameter);
                thread->FinishedFunction = NULL;
            }
        }

        oC_ErrorCode_t errorCode = oC_ThreadMan_RemoveThread(*Thread);

        if(oC_ErrorOccur(errorCode))
        {
            oC_SaveError((*Thread)->Name , errorCode);
        }
        else
        {
            canceled = true;
            *Thread  = NULL;
        }
    }

    return canceled;
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_Thread_GetContext( oC_Thread_t Thread )
{
    void * context = NULL;

    if(oC_Thread_IsCorrect(Thread))
    {
        context = Thread->Context;
    }

    return context;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Thread_Priority_t oC_Thread_GetPriority( oC_Thread_t Thread )
{
    oC_Thread_Priority_t priority = 0;

    if(oC_Thread_IsCorrect(Thread))
    {
        priority = Thread->Priority;
    }

    return priority;
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_Thread_GetParameter( oC_Thread_t Thread )
{
    void * parameter = NULL;

    if(oC_Thread_IsCorrect(Thread))
    {
        parameter = Thread->Parameter;
    }

    return parameter;
}

//==========================================================================================================================================
//==========================================================================================================================================
const char * oC_Thread_GetName( oC_Thread_t Thread )
{
    const char * name = "incorrect thread";

    if(oC_Thread_IsCorrect(Thread))
    {
        name = Thread->Name;
    }

    return name;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_Sleep( oC_Thread_t Thread , oC_Time_t Time )
{
    bool asleep = false;

    if(oC_Thread_IsCorrect(Thread))
    {
        oC_IntMan_EnterCriticalSection();

        Thread->BlockedFlag         = NULL;
        Thread->TimeoutTimestamp    = oC_KTime_GetTimestamp() + Time;
        asleep                      = true;
        oC_IntMan_ExitCriticalSection();

        while(oC_Thread_IsBlocked(Thread));
    }

    return asleep;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Time_t oC_Thread_GetExecutionTime  ( oC_Thread_t Thread )
{
    oC_Time_t executionTime = 0;

    if(oC_Thread_IsCorrect(Thread))
    {
        executionTime = Thread->ExecutionTime;
    }

    return executionTime;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_AddToExecutionTime( oC_Thread_t Thread , oC_Time_t Time )
{
    bool added = false;

    if(oC_Thread_IsCorrect(Thread))
    {
        Thread->ExecutionTime += Time;
    }

    return added;
}

//==========================================================================================================================================
//==========================================================================================================================================
uint64_t oC_Thread_GetLastExecutionTick(oC_Thread_t Thread )
{
    uint64_t tick = 0;

    if(oC_Thread_IsCorrect(Thread))
    {
        tick = Thread->LastExecutionTick;
    }

    return tick;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_SetLastExecutionTick(oC_Thread_t Thread , uint64_t Tick )
{
    bool set = false;

    if(oC_Thread_IsCorrect(Thread))
    {
        Thread->LastExecutionTick = Tick;
    }

    return set;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_UInt_t oC_Thread_GetStackSize( oC_Thread_t Thread )
{
    oC_UInt_t size = 0;

    if(oC_Thread_IsCorrect(Thread))
    {
        size = oC_SYS_LLD_GetContextStackSize(Thread->Context);

        if(size != Thread->StackSize)
        {
            size = Thread->StackSize;
        }
    }

    return size;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Int_t oC_Thread_GetFreeStackSize( oC_Thread_t Thread , bool Current )
{
    oC_Int_t size = 0;

    if(oC_Thread_IsCorrect(Thread))
    {
        if(Current)
        {
            size = oC_SYS_LLD_GetContextFreeStackSize(Thread->Context);
        }
        else
        {
            oC_UInt_t contextSize = oC_SYS_LLD_GetContextStackSize(Thread->Context);
            uint16_t* redZoneEnd  = (void*)(((oC_UInt_t)Thread->RedZoneEnd));

            //==========================================================================================================================
            /*
             * Checking if red zone is was used
             */
            //==========================================================================================================================
            for(uint16_t * stack = (uint16_t*)Thread->RedZone ; stack < redZoneEnd ; stack++ )
            {
                if(*stack != NotUsedByteValue)
                {
                    size-=sizeof(uint16_t);
                }
            }

            if(size == 0)
            {
                uint16_t * stackEnd = (Thread->StackStart + contextSize);

                //======================================================================================================================
                /*
                 * If 'Red-Zone' was not used, then check if there is any stack free
                 */
                //======================================================================================================================
                for(uint16_t * stack = Thread->StackStart ; stack < stackEnd ; stack++ )
                {
                    if(*stack == NotUsedByteValue)
                    {
                        size+=sizeof(uint16_t);
                    }
                }
            }
        }
    }

    return size;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_SaveToRevert( oC_Thread_t Thread , oC_Thread_RevertFunction_t Function, void * Object , uint32_t Parameter )
{
    bool success = false;

    if(
        oC_SaveIfFalse("Thread object", oC_Thread_IsCorrect(Thread), oC_ErrorCode_ObjectNotCorrect  )
     && oC_SaveIfFalse("Function"     , isaddresscorrect(Function) , oC_ErrorCode_WrongAddress      )
        )
    {
        oC_IntMan_EnterCriticalSection();
        oC_ARRAY_FOREACH_IN_ARRAY(Thread->ActionsToRevert,action)
        {
            if(action->Function == NULL)
            {
                action->Function = Function;
                action->Object   = Object;
                action->Parameter= Parameter;

                success = true;
                break;
            }
        }
        oC_IntMan_ExitCriticalSection();
        oC_SaveIfFalse("Cannot add function", success, oC_ErrorCode_NoFreeSlots);
    }

    return success;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_RemoveFromRevert( oC_Thread_t Thread , oC_Thread_RevertFunction_t Function, void * Object )
{
    bool success = false;

    if(
        oC_SaveIfFalse("Thread object", oC_Thread_IsCorrect(Thread), oC_ErrorCode_ObjectNotCorrect  )
     && oC_SaveIfFalse("Function"     , isaddresscorrect(Function) , oC_ErrorCode_WrongAddress      )
        )
    {
        oC_IntMan_EnterCriticalSection();
        oC_ARRAY_FOREACH_IN_ARRAY(Thread->ActionsToRevert,action)
        {
            if(action->Function == Function && action->Object == Object)
            {
                action->Function    = NULL;
                action->Parameter   = 0;
                action->Object      = NULL;
                success = true;
                break;
            }
        }
        oC_IntMan_ExitCriticalSection();
        oC_SaveIfFalse("Cannot remove function", success, oC_ErrorCode_ObjectNotFoundOnList);
    }

    return success;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Thread_SetFinishedFunction( oC_Thread_t Thread , oC_Thread_FinishedFunction_t Function, void * Parameter )
{
    bool success = false;

    if(
        oC_SaveIfFalse("Thread object", oC_Thread_IsCorrect(Thread), oC_ErrorCode_ObjectNotCorrect  )
     && oC_SaveIfFalse("Function"     , isaddresscorrect(Function) , oC_ErrorCode_WrongAddress      )
        )
    {
        Thread->FinishedFunction    = Function;
        Thread->FinishedParameter   = Parameter;
        success                     = true;
    }

    return success;
}

#undef  _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

#define _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
static void ThreadExitHandler( void )
{
    oC_Thread_t          thread   = oC_ThreadMan_GetCurrentThread();
    oC_List(oC_Thread_t) threads  = oC_ThreadMan_GetList();
    bool                 contains = oC_List_Contains(threads,thread);

    if(thread->FinishedFunction != NULL)
    {
        if(oC_SaveIfFalse("Finished Function", isaddresscorrect(thread->FinishedFunction), oC_ErrorCode_WrongAddress))
        {
            thread->FinishedFunction(thread, thread->FinishedParameter);
            thread->FinishedFunction = NULL;
        }
    }

    if(oC_Thread_IsCorrect(thread) && contains)
    {
        oC_Thread_Delete(&thread);
    }
    while(1);
}

//==========================================================================================================================================
//==========================================================================================================================================
static bool CheckUnblockedWhenEqual( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask )
{
    return (Value & UnblockMask) != (Expected & UnblockMask);
}

//==========================================================================================================================================
//==========================================================================================================================================
static bool CheckUnblockedWhenNotEqual( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask )
{
    return (Value & UnblockMask) == (Expected & UnblockMask);
}

//==========================================================================================================================================
//==========================================================================================================================================
static bool CheckUnblockedWhenSmaller( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask )
{
    return (Value & UnblockMask) >= (Expected & UnblockMask);
}

//==========================================================================================================================================
//==========================================================================================================================================
static bool CheckUnblockedWhenGreater( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask )
{
    return (Value & UnblockMask) <= (Expected & UnblockMask);
}

//==========================================================================================================================================
//==========================================================================================================================================
static bool CheckUnblockedWhenSmallerOrEqual( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask )
{
    return (Value & UnblockMask) > (Expected & UnblockMask);
}

//==========================================================================================================================================
//==========================================================================================================================================
static bool CheckUnblockedWhenGreaterOrEqual( uint32_t Value , uint32_t Expected , oC_Thread_UnblockMask_t UnblockMask )
{
    return (Value & UnblockMask ) < (Expected & UnblockMask);
}

#undef  _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________