/**********************************************************************************************************************
 *  COPYRIGHT
 *  -------------------------------------------------------------------------------------------------------------------
 *  \verbatim
 *  Copyright (c) 2024 by Vector Informatik GmbH.                                                  All rights reserved.
 *
 *                This software is copyright protected and proprietary to Vector Informatik GmbH.
 *                Vector Informatik GmbH grants to you only those rights as set out in the license conditions.
 *                All other rights remain with Vector Informatik GmbH.
 *  \endverbatim
 *  -------------------------------------------------------------------------------------------------------------------
 *  FILE DESCRIPTION
 *  -----------------------------------------------------------------------------------------------------------------*/
/*!        \file  vstdlib.h
 *        \brief  Interface of the generic Vector Standard Library (VStdLib_GenericAsr)
 *      \details  This is the header file of the VStdLib. It contains the public (inline) APIs and global data of
 *                the VStdLib.
 *                It has to be included by other modules to access the APIs of the VStdLib.
 *
 *********************************************************************************************************************/

/**********************************************************************************************************************
 *  REVISION HISTORY
 *  -------------------------------------------------------------------------------------------------------------------
 *  Version   Date        Author  Change Id      Description
 *  -------------------------------------------------------------------------------------------------------------------
 *  01.00.00  2012-05-08  vistvi      Creation
 *  01.00.01  2013-09-04  vistvi      ESCAN00064708: Inconsistent file names
 *  01.01.00  2013-12-10  vistvi      ESCAN00073131: MISRA Improvements
 *  02.00.00  2015-01-12  vistkr      ESCAN00080277: FEAT-427: SafeBSW Step I
 *                                    ESCAN00081720: Extended version check is not available for MSR4
 *            2015-05-04  vistkr      ESCAN00081765: FEAT-1275: SafeBSW Step 2
 *                                    ESCAN00082267: FEAT-1379: Optimized copy operation for large data
 *  02.00.01  2015-12-02  vistkr      ESCAN00086942: Compiler error: Last line of file ends without a newline
 *  02.00.02  2016-04-14  vistkr      ESCAN00089506: Remove trace links for memory manipulation services
 *  03.00.00  2018-10-23  vistkr      STORYC-6844:   MISRA-C:2012: VStdLib
 *  03.01.00  2021-01-18  visgaz      CAN-1574:      [VStdLib] Support bit search functions
 *  03.02.00  2021-03-15  visgaz      CAN-1579:      [VStdLib] Support memory comparison functions
 *                                    CAN-1577:      [VStdLib] Support serialization functions
 *  03.03.00  2021-04-12  visgaz      CAN-2834:      [VStdLib] Optimize memory comparison functions
 *                                    CAN-2831:      [VStdLib] Optimize serialization functions
 *                                    CAN-1576:      [VStdLib] Support endianess conversion functions
 *                                    ESCAN00108975: Compiler warning: 'type cast': pointer truncation from 'uint8 *' to 'uint32_least'
 *  03.04.00  2021-06-07  visgaz      CANCORE-325:   [VStdLib] Convert CReqSpec, CAD and TestSpec to the new textbased format
 *                                    ESCAN00109680: Compiler warning: Conversion from 'uint8 *' to 'uint64' is sign-extended
 *  03.05.00  2022-03-29  visgaz      CANCORE-455:   [VStdLib] Support MemCpy with endianness conversion functions
 *                                    ESCAN00110377: Compiler warning: Constant out of range
 *                                    ESCAN00110415: Compiler warning: Narrowing or signed-to-unsigned type conversion found
 *                                    -              Refactored description for endianness conversion and (de-)serialization feature
 *            2022-07-07  visnaj      CANHAL-1215:   [VStdLib] Support VStdLib_MemCheck()
 *  03.06.00  2023-01-10  visgaz      CANCORE-1197:  [VStdLib] Finite Execution Time Analysis
 *            2023-01-25              CANCORE-1379:  [VStdLib] Safety analysis
 *  03.07.00  2023-02-14  vismte      CANCORE-1647:  [VStdLib] Implementation of sawtooth functions for BitCopy
 *                                    CANCORE-1699:  [VStdLib] Implementation of monotone functions for BitCopy
 *            2023-03-23  vismte      ESCAN00114258: Incomplete description for FETA-ID FETA_VSTDLIB_CALL_LOC_MEMCHECK_8_REMAINING
 *  03.08.00  2023-04-13  vismte      CANCORE-1904:  [VStdLib] Review findings
 *                                    CANCORE-1203:  [VStdLib] Support MemCpy_s with return value
 *                                    CANCORE-1201:  [VStdLib] Extend Embedded Compiler tests and fix compiler warnings
 *  03.08.01  2023-07-26  vismte      ESCAN00115111: Compiler error during VCA analysis in <ModuleName>_VStdLib.vcaspecs.c
 *  03.09.00  2024-09-24  hjenhani    CANCORE-2865:  [VStdLib] Make VStdLib VCA (Silent Analysis) compatible
 *********************************************************************************************************************/

#ifndef VSTDLIB_H
# define VSTDLIB_H

/**********************************************************************************************************************
 *  INCLUDES
 *********************************************************************************************************************/

# include "Std_Types.h"

# include "VStdLib_Cfg.h"

# if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
#  include "Det.h"
# endif

/**********************************************************************************************************************
 *  GLOBAL CONSTANT MACROS
 *********************************************************************************************************************/

/* Vendor and module identification */
# define VSTDLIB_VENDOR_ID                   (30u)
# if !defined (VSTDLIB_MODULE_ID)
#  define VSTDLIB_MODULE_ID                  (255u)
# endif

/* Component version information (decimal version of ALM implementation package) */
# define VSTDLIB_SW_MAJOR_VERSION            (3u)
# define VSTDLIB_SW_MINOR_VERSION            (9u)
# define VSTDLIB_SW_PATCH_VERSION            (0u)

# if !defined (VSTDLIB_INSTANCE_ID_DET)
#  define VSTDLIB_INSTANCE_ID_DET            (0u)
# endif

/* API service IDs */
# define VSTDLIB_SID_MEM_SET                 (0x00u) /*!< Service ID: VStdLib_MemClr(), VStdLib_MemSet() */
# define VSTDLIB_SID_MEM_COPY                (0x01u) /*!< Service ID: VStdLib_MemCpy(), VStdLib_MemCpyEndianPlatformToBig(), VStdLib_MemCpyEndianPlatformToLittle(),
                                                                      VStdLib_MemCpyEndianBigToPlatform(), VStdLib_MemCpyEndianLittleToPlatform() */
# define VSTDLIB_SID_MEM_COPY_16             (0x02u) /*!< Service ID: VStdLib_MemCpy16() */
# define VSTDLIB_SID_MEM_COPY_32             (0x03u) /*!< Service ID: VStdLib_MemCpy32() */
# define VSTDLIB_SID_MEM_COPY_S              (0x04u) /*!< Service ID: VStdLib_MemCpy_s(), VStdLib_MemCpy_Return_s(), VStdLib_MemCpyEndianPlatformToBig_s(),
                                                                      VStdLib_MemCpyEndianPlatformToLittle_s(), VStdLib_MemCpyEndianBigToPlatform_s(),
                                                                      VStdLib_MemCpyEndianLittleToPlatform_s() */
# define VSTDLIB_SID_GET_VERSION_INFO        (0x05u) /*!< Service ID: VStdLib_GetVersionInfo() */
# define VSTDLIB_SID_MEM_CMP                 (0x06u) /*!< Service ID: VStdLib_MemCmp() */
# define VSTDLIB_SID_CNV_UINT16_TO_ARRAY_BE  (0x07u) /*!< Service ID: VStdLib_ConvertUint16ToUint8ArrayBigEndian(), VStdLib_ConvertSint16ToUint8ArrayBigEndian() */
# define VSTDLIB_SID_CNV_UINT16_TO_ARRAY_LE  (0x08u) /*!< Service ID: VStdLib_ConvertUint16ToUint8ArrayLittleEndian(), VStdLib_ConvertSint16ToUint8ArrayLittleEndian() */
# define VSTDLIB_SID_CNV_ARRAY_TO_UINT16_BE  (0x09u) /*!< Service ID: VStdLib_ConvertUint8ArrayToUint16BigEndian(), VStdLib_ConvertUint8ArrayToSint16BigEndian() */
# define VSTDLIB_SID_CNV_ARRAY_TO_UINT16_LE  (0x0Au) /*!< Service ID: VStdLib_ConvertUint8ArrayToUint16LittleEndian(), VStdLib_ConvertUint8ArrayToSint16LittleEndian() */
# define VSTDLIB_SID_CNV_UINT32_TO_ARRAY_BE  (0x0Bu) /*!< Service ID: VStdLib_ConvertUint32ToUint8ArrayBigEndian(), VStdLib_ConvertSint32ToUint8ArrayBigEndian() */
# define VSTDLIB_SID_CNV_UINT32_TO_ARRAY_LE  (0x0Cu) /*!< Service ID: VStdLib_ConvertUint32ToUint8ArrayLittleEndian(), VStdLib_ConvertSint32ToUint8ArrayLittleEndian() */
# define VSTDLIB_SID_CNV_ARRAY_TO_UINT32_BE  (0x0Du) /*!< Service ID: VStdLib_ConvertUint8ArrayToUint32BigEndian(), VStdLib_ConvertUint8ArrayToSint32BigEndian() */
# define VSTDLIB_SID_CNV_ARRAY_TO_UINT32_LE  (0x0Eu) /*!< Service ID: VStdLib_ConvertUint8ArrayToUint32LittleEndian(), VStdLib_ConvertUint8ArrayToSint32LittleEndian() */
# define VSTDLIB_SID_CNV_UINT64_TO_ARRAY_BE  (0x0Fu) /*!< Service ID: VStdLib_ConvertUint64ToUint8ArrayBigEndian(), VStdLib_ConvertSint64ToUint8ArrayBigEndian() */
# define VSTDLIB_SID_CNV_UINT64_TO_ARRAY_LE  (0x10u) /*!< Service ID: VStdLib_ConvertUint64ToUint8ArrayLittleEndian(), VStdLib_ConvertSint64ToUint8ArrayLittleEndian() */
# define VSTDLIB_SID_CNV_ARRAY_TO_UINT64_BE  (0x11u) /*!< Service ID: VStdLib_ConvertUint8ArrayToUint64BigEndian(), VStdLib_ConvertUint8ArrayToSint64BigEndian() */
# define VSTDLIB_SID_CNV_ARRAY_TO_UINT64_LE  (0x12u) /*!< Service ID: VStdLib_ConvertUint8ArrayToUint64LittleEndian(), VStdLib_ConvertUint8ArrayToSint64LittleEndian() */
# define VSTDLIB_SID_MEM_COPY_SWAP_ENDIAN    (0x13u) /*!< Service ID: VStdLib_MemCpySwapEndian(), VStdLib_MemCpyEndianPlatformToBig(),
                                                                      VStdLib_MemCpyEndianPlatformToLittle(), VStdLib_MemCpyEndianBigToPlatform(),
                                                                      VStdLib_MemCpyEndianLittleToPlatform() */
# define VSTDLIB_SID_MEM_COPY_SWAP_ENDIAN_S  (0x14u) /*!< Service ID: VStdLib_MemCpySwapEndian_s(), VStdLib_MemCpyEndianPlatformToBig_s(),
                                                                      VStdLib_MemCpyEndianPlatformToLittle_s(), VStdLib_MemCpyEndianBigToPlatform_s(),
                                                                      VStdLib_MemCpyEndianLittleToPlatform_s() */
# define VSTDLIB_SID_MEM_CHECK               (0x15u) /*!< Service ID: VStdLib_MemCheck() */

# define VSTDLIB_SID_BIT_COPY_SAW            (0x16u) /*!< Service ID: VStdLib_BitCpySawBigToBigEndian(), VStdLib_BitCpySawBigToLittleEndian(),
                                                                      VStdLib_BitCpySawLittleToBigEndian(), VStdLib_BitCpySawLittleToLittleEndian() */
# define VSTDLIB_SID_BIT_COPY_MON            (0x17u) /*!< Service ID: VStdLib_BitCpyMonBigToBigEndian(), VStdLib_BitCpyMonBigToLittleEndian(),
                                                                      VStdLib_BitCpyMonLittleToBigEndian(), VStdLib_BitCpyMonLittleToLittleEndian() */
# define VSTDLIB_SID_BIT_COPY_SAW_S          (0x18u) /*!< Service ID: VStdLib_BitCpySawBigToBigEndian_s(), VStdLib_BitCpySawBigToLittleEndian_s(),
                                                                      VStdLib_BitCpySawLittleToBigEndian_s(), VStdLib_BitCpySawLittleToLittleEndian_s() */
# define VSTDLIB_SID_BIT_COPY_MON_S          (0x19u) /*!< Service ID: VStdLib_BitCpyMonBigToBigEndian_s(), VStdLib_BitCpyMonBigToLittleEndian_s(),
                                                                      VStdLib_BitCpyMonLittleToBigEndian_s(), VStdLib_BitCpyMonLittleToLittleEndian_s() */

/* Error codes */
# define VSTDLIB_E_NO_ERROR                  (0x00u) /*!< Used to check if no error occurred */
# define VSTDLIB_E_PARAM_POINTER             (0x01u) /*!< Error code: API used with invalid pointer parameter (e.g. NULL) */
# define VSTDLIB_E_PARAM_SIZE                (0x02u) /*!< Error code: API used with invalid destination buffer size */
# define VSTDLIB_E_PARAM_INTTYPE             (0x03u) /*!< Error code: API used with invalid integer type parameter */

/* Large data support */
# if !defined (VSTDLIB_SUPPORT_LARGE_DATA)
#  define VSTDLIB_SUPPORT_LARGE_DATA         STD_ON
# endif

/* Return value from bit search APIs, if bit position or bit count is not available */
# define VSTDLIB_BITPOS_NA                   (0x80u)
# define VSTDLIB_BITCNT_NA                   VSTDLIB_BITPOS_NA

/*! Possible values for the integer type parameter of the memory copy with endianness conversion APIs */
# define VSTDLIB_INTTYPE_8                   (1u)
# define VSTDLIB_INTTYPE_16                  (2u)
# define VSTDLIB_INTTYPE_32                  (4u)
# if defined (PLATFORM_SUPPORT_SINT64_UINT64)
#  define VSTDLIB_INTTYPE_64                 (8u)
# endif

/**********************************************************************************************************************
 *  GLOBAL DATA TYPES AND STRUCTURES
 *********************************************************************************************************************/
 
/* Module specific definition of LOCAL_INLINE */
# if !defined (VSTDLIB_LOCAL_INLINE)
#  define VSTDLIB_LOCAL_INLINE               LOCAL_INLINE
# endif

/*! Data type for nCnt API parameters */
# if (VSTDLIB_SUPPORT_LARGE_DATA == STD_ON)
typedef uint32_least VStdLib_CntType;
# else
typedef uint16_least VStdLib_CntType;
# endif

/**********************************************************************************************************************
 *  GLOBAL FUNCTION MACROS (MACRO API)
 *********************************************************************************************************************/

/* PRQA S 3453 VSTDLIB_FUNCTION_LIKE_MACRO */ /* MD_MSR_FctLikeMacro */

# if (VSTDLIB_USE_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_MemClr()
 *********************************************************************************************************************/
/*! \brief       Initializes memory to zero.
 *  \details     Sets nCnt bytes starting at pDst to zero.
 *  \param[out]  pDst          Pointer to the memory location to be initialized, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to initialize, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_LIBRARY_FUNCTIONS == STD_ON,
 *               else it is realized by a call to VStdLib_MemSet() with 'nPattern' == 0.
 *               The compatible definition VStdLib_MemClrLarge() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *********************************************************************************************************************/
#  define VStdLib_MemClr(pDst, nCnt)                       VStdLib_MemSet((pDst), 0, (nCnt))

# endif /* VSTDLIB_USE_LIBRARY_FUNCTIONS != STD_ON */

# if (VSTDLIB_SUPPORT_LARGE_DATA == STD_ON)

/**********************************************************************************************************************
 *  VStdLib_MemClrLarge()
 *********************************************************************************************************************/
/*! \brief       Initializes memory to zero.
 *  \details     Sets nCnt bytes starting at pDst to zero.
 *  \param[out]  pDst          Pointer to the memory location to be initialized, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to initialize, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *********************************************************************************************************************/
#  define VStdLib_MemClrLarge(pDst, nCnt)                    VStdLib_MemClr((pDst), (nCnt))

/**********************************************************************************************************************
 *  VStdLib_MemSetLarge()
 *********************************************************************************************************************/
/*! \brief       Initializes memory to a specified pattern.
 *  \details     Sets nCnt bytes starting at pDst to the character nPattern.
 *  \param[out]  pDst          Pointer to the memory location to be initialized, must not be NULL.
 *  \param[in]   nPattern      The character to be used to initialize the memory.
 *  \param[in]   nCnt          Number of bytes to initialize, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *********************************************************************************************************************/
#  define VStdLib_MemSetLarge(pDst, nPattern, nCnt)          VStdLib_MemSet((pDst), (nPattern), (nCnt))

/**********************************************************************************************************************
 *  VStdLib_MemCpyLarge()
 *********************************************************************************************************************/
/*! \brief       Copies data from one memory location to another.
 *  \details     Copies nCnt bytes starting at pSrc to another memory location starting at pDst.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyLarge(pDst, pSrc, nCnt)              VStdLib_MemCpy((pDst), (pSrc), (nCnt))

/**********************************************************************************************************************
 *  VStdLib_MemCpy16Large()
 *********************************************************************************************************************/
/*! \brief       Copies data from one memory location to another.
 *  \details     Copies nCnt 16-bit blocks starting at pSrc to another memory location starting at pDst.
 *  \param[out]  pDst          Pointer to the memory location to copy to, 16-bit aligned and not NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, 16-bit aligned and not NULL.
 *  \param[in]   nCnt          Number of 16-bit blocks to copy, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpy16Large(pDst, pSrc, nCnt)            VStdLib_MemCpy16((pDst), (pSrc), (nCnt))

/**********************************************************************************************************************
 *  VStdLib_MemCpy32Large()
 *********************************************************************************************************************/
/*! \brief       Copies data from one memory location to another.
 *  \details     Copies nCnt 32-bit blocks starting at pSrc to another memory location starting at pDst.
 *  \param[out]  pDst          Pointer to the memory location to copy to, 32-bit aligned and not NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, 32-bit aligned and not NULL.
 *  \param[in]   nCnt          Number of 32-bit blocks to copy, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpy32Large(pDst, pSrc, nCnt)            VStdLib_MemCpy32((pDst), (pSrc), (nCnt))

/**********************************************************************************************************************
 *  VStdLib_MemCpyLarge_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location to another.
 *  \details     Uses VStdLib_MemCpy() to copy nCnt bytes starting at pSrc to another memory location starting
 *               at pDst, if nDstSize is greater than or equal to nCnt.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyLarge_s(pDst, nDstSize, pSrc, nCnt)  VStdLib_MemCpy_s((pDst), (nDstSize), (pSrc), (nCnt))

/**********************************************************************************************************************
 *  VStdLib_MemCpyLarge_Return_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location to another.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpy() to
 *               copy nCnt bytes starting at pSrc to another memory location starting at pDst.
 *               Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyLarge_Return_s(pDst, nDstSize, pSrc, nCnt, errorCode) \
    VStdLib_MemCpy_Return_s((pDst), (nDstSize), (pSrc), (nCnt), (errorCode))

/**********************************************************************************************************************
 *  VStdLib_MemCmpLarge()
 *********************************************************************************************************************/
/*! \brief       Compares two buffers for the specified number of bytes and returns whether they are equal or not.
 *  \details     -
 *  \param[in]   pBuf1     Pointer to first buffer for comparison, must not be NULL.
 *  \param[in]   pBuf2     Pointer to second buffer for comparison, must not be NULL.
 *  \param[in]   nCnt      Number of bytes to compare, pBuf1 and pBuf2 must be valid for this amount.
 *  \return      < 0       The first buffer contains a smaller value than the second buffer.
 *  \return      0         The two buffers are equal for the number of compared bytes.
 *  \return      > 0       The first buffer contains a greater value than the second buffer.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pBuf1' and 'pBuf2' have to point to valid memory areas. Each memory area has to be
 *               valid for at least the byte count defined in parameter 'nCnt'.
 *               The memory areas defined by parameters 'pBuf1', 'pBuf2' and 'nCnt' must not be changed by another
 *               context whilethe comparison is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCmpLarge(pBuf1, pBuf2, nCnt)        VStdLib_MemCmp((pBuf1), (pBuf2), (nCnt))

/**********************************************************************************************************************
 *  VStdLib_MemCpySwapEndianLarge()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bytes starting at pSrc to another memory location starting at pDst in the swapped
 *               endianness according to the integer type intType.
 *  \details     Depending on the configuration (VSTDLIB_RUNTIME_OPTIMIZATION) and the passed arguments for parameter
 *               intType and nCnt different memory access sizes are used (see TechRef).
 *               intType value VSTDLIB_INTTYPE_64 is only supported if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') and writable from the calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpySwapEndianLarge(pDst, pSrc, nCnt, intType) \
    VStdLib_MemCpySwapEndian((pDst), (pSrc), (nCnt), (intType))

/**********************************************************************************************************************
 *  VStdLib_MemCpySwapEndianLarge_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location to another in the swapped
 *               endianness according to the integer type intType.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpySwapEndian() to copy and swap nCnt
 *               bytes starting at pSrc to another memory location starting at pDst.
 *               Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType').
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
#  define VStdLib_MemCpySwapEndianLarge_s(pDst, nDstSize, pSrc, nCnt, intType, errorCode) \
    VStdLib_MemCpySwapEndian_s((pDst), (nDstSize), (pSrc), (nCnt), (intType), (errorCode));

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianPlatformToBigLarge()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bytes starting at pSrc (platform endianness) to another memory location starting at pDst
 *               in big endian according to the integer type intType.
 *  \details     Depending on the configuration (VSTDLIB_RUNTIME_OPTIMIZATION) and the passed arguments for parameter 
 *               intType and nCnt different memory access sizes are used (see TechRef).
 *               intType value VSTDLIB_INTTYPE_64 is only supported if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') and writable from the calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianPlatformToBigLarge(pDst, pSrc, nCnt, intType) \
    VStdLib_MemCpyEndianPlatformToBig((pDst), (pSrc), (nCnt), (intType))

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianPlatformToBigLarge_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location (platform endianness) to
 *               another in big endian according to the integer type intType.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpy()/VStdLib_MemCpySwapEndian() to
 *               copy nCnt bytes starting at pSrc to another memory location starting at pDst in big endian.
 *               Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType').
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianPlatformToBigLarge_s(pDst, nDstSize, pSrc, nCnt, intType, errorCode) \
    VStdLib_MemCpyEndianPlatformToBig_s((pDst), (nDstSize), (pSrc), (nCnt), (intType), (errorCode))

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianPlatformToLittleLarge()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bytes starting at pSrc (platform endianness) to another memory location starting at pDst
 *               in little endian according to the integer type intType.
 *  \details     Depending on the configuration (VSTDLIB_RUNTIME_OPTIMIZATION) and the passed arguments for parameter
 *               intType and nCnt different memory access sizes are used (see TechRef).
 *               intType value VSTDLIB_INTTYPE_64 is only supported if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') and writable from the calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianPlatformToLittleLarge(pDst, pSrc, nCnt, intType) \
    VStdLib_MemCpyEndianPlatformToLittle((pDst), (pSrc), (nCnt), (intType))

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianPlatformToLittleLarge_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location (platform endianness) to
 *               another in little endian according to the integer type intType.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpy()/VStdLib_MemCpySwapEndian() to
 *               copy nCnt bytes starting at pSrc to another memory location starting at pDst in little endian.
 *               Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area.
 *               The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') that is writable from the
 *               calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianPlatformToLittleLarge_s(pDst, nDstSize, pSrc, nCnt, intType, errorCode) \
    VStdLib_MemCpyEndianPlatformToLittle_s((pDst), (nDstSize), (pSrc), (nCnt), (intType), (errorCode))

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianBigToPlatformLarge()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bytes starting at pSrc (big endian) to another memory location starting at pDst in the
 *               platform endianness according to the integer type intType.
 *  \details     Depending on the configuration (VSTDLIB_RUNTIME_OPTIMIZATION) and the passed arguments for parameter
 *               intType and nCnt different memory access sizes are used (see TechRef).
 *               intType value VSTDLIB_INTTYPE_64 is only supported if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') and writable from the calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianBigToPlatformLarge(pDst, pSrc, nCnt, intType) \
    VStdLib_MemCpyEndianBigToPlatform((pDst), (pSrc), (nCnt), (intType))

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianBigToPlatformLarge_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location (big endian) to another in the
 *               platform endianness according to the integer type intType.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpy()/VStdLib_MemCpySwapEndian() to
 *               copy nCnt bytes starting at pSrc to another memory location starting at pDst in the platform
 *               endianness Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType').
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianBigToPlatformLarge_s(pDst, nDstSize, pSrc, nCnt, intType, errorCode) \
    VStdLib_MemCpyEndianBigToPlatform_s((pDst), (nDstSize), (pSrc), (nCnt), (intType), (errorCode))

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianLittleToPlatformLarge()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bytes starting at pSrc (little endian) to another memory location starting at pDst in the
 *               platform endianness according to the integer type intType.
 *  \details     Depending on the configuration (VSTDLIB_RUNTIME_OPTIMIZATION) and the passed arguments for parameter
 *               intType and nCnt different memory access sizes are used (see TechRef).
 *               intType value VSTDLIB_INTTYPE_64 is only supported if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') and writable from the calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianLittleToPlatformLarge(pDst, pSrc, nCnt, intType) \
    VStdLib_MemCpyEndianLittleToPlatform((pDst), (pSrc), (nCnt), (intType))

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianLittleToPlatformLarge_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location (little endian) to another in
 *               the platform endianness according to the integer type intType.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpy()/VStdLib_MemCpySwapEndian() to
 *               copy nCnt bytes starting at pSrc to another memory location starting at pDst in the platform
 *               endianness. Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType').
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianLittleToPlatformLarge_s(pDst, nDstSize, pSrc, nCnt, intType, errorCode) \
    VStdLib_MemCpyEndianLittleToPlatform_s((pDst), (nDstSize), (pSrc), (nCnt), (intType), (errorCode))

/**********************************************************************************************************************
 *  VStdLib_MemCheckLarge()
 *********************************************************************************************************************/
/*! \brief       Compares the content of a memory area to a specified pattern.
 *  \details     Compares nCnt bytes of memory starting at pBuf to the character nPattern.
 *  \param[in]   pBuf          Pointer to the memory location to be checked, must not be NULL.
 *  \param[in]   nPattern      The character to be checked for in the memory.
 *  \param[in]   nCnt          Number of bytes to be checked, pBuf must be valid for this amount.
 *  \param[in]   errorCode     Value to be returned, if content of pBuf is not equal to pattern.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Content of pBuf is equal to pattern.
 *  \return      errorCode     Content of pBuf is not equal to pattern.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      VSTDLIB_SUPPORT_LARGE_DATA == STD_ON
 *  \pre         The parameters 'pBuf' and 'nCnt' have to define a valid memory area.
 *               The memory area defined by parameters 'pBuf' and 'nCnt' must not be changed by another context while
 *               the comparison is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
#  define VStdLib_MemCheckLarge(pBuf, nPattern, nCnt, errorCode)  VStdLib_MemCheck((pBuf), (nPattern), (nCnt), (errorCode))

# endif /* VSTDLIB_SUPPORT_LARGE_DATA == STD_ON */

# if (VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_ConvertSint16ToUint8ArrayBigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 16-bit value to an unsigned 8-bit array according to big endian.
 *  \details     -
 *  \param[in]   src   The signed 16-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least two elements that is writable
 *               from the calling context.
 *********************************************************************************************************************/
# define VStdLib_ConvertSint16ToUint8ArrayBigEndian(src, dst)  VStdLib_ConvertUint16ToUint8ArrayBigEndian(((uint16)(src)), (dst))

/**********************************************************************************************************************
 *  VStdLib_ConvertSint16ToUint8ArrayLittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 16-bit value to an unsigned 8-bit array according to little endian.
 *  \details     -
 *  \param[in]   src   The signed 16-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least two elements that is writable
 *               from the calling context.
 *********************************************************************************************************************/
# define VStdLib_ConvertSint16ToUint8ArrayLittleEndian(src, dst)  VStdLib_ConvertUint16ToUint8ArrayLittleEndian(((uint16)(src)), (dst))

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToSint16BigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to a signed 16-bit value according to big endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to a signed 16-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least two elements.
 *               The parameter 'dst' has to point to a signed 16-bit variable that is writable from the calling
 *               context.
 *********************************************************************************************************************/
# define VStdLib_ConvertUint8ArrayToSint16BigEndian(src, dst)  VStdLib_ConvertUint8ArrayToUint16BigEndian((src), ((uint16*)(dst)))

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToSint16LittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to a signed 16-bit value according to little endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to a signed 16-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least two elements.
 *               The parameter 'dst' has to point to a signed 16-bit variable that is writable from the calling
 *               context.
 *********************************************************************************************************************/
# define VStdLib_ConvertUint8ArrayToSint16LittleEndian(src, dst)  VStdLib_ConvertUint8ArrayToUint16LittleEndian((src), ((uint16*)(dst)))

# endif /* VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON */

# if (VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_ConvertSint32ToUint8ArrayBigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 32-bit value to an unsigned 8-bit array according to big endian.
 *  \details     -
 *  \param[in]   src   The signed 32-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least four elements that is writable
 *               from the calling context.
 *********************************************************************************************************************/
# define VStdLib_ConvertSint32ToUint8ArrayBigEndian(src, dst)  VStdLib_ConvertUint32ToUint8ArrayBigEndian(((uint32)(src)), (dst))

/**********************************************************************************************************************
 *  VStdLib_ConvertSint32ToUint8ArrayLittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 32-bit value to an unsigned 8-bit array according to little endian.
 *  \details     -
 *  \param[in]   src   The signed 32-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least four elements that is writable
 *               from the calling context.
 *********************************************************************************************************************/
# define VStdLib_ConvertSint32ToUint8ArrayLittleEndian(src, dst)  VStdLib_ConvertUint32ToUint8ArrayLittleEndian(((uint32)(src)), (dst))

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToSint32BigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to a signed 32-bit value according to big endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to a signed 32-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least two elements.
 *               The parameter 'dst' has to point to a signed 32-bit variable that is writable from the calling
 *               context.
 *********************************************************************************************************************/
# define VStdLib_ConvertUint8ArrayToSint32BigEndian(src, dst)  VStdLib_ConvertUint8ArrayToUint32BigEndian(src, ((uint32*)(dst)))

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToSint32LittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to a signed 32-bit value according to little endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to a signed 32-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least two elements.
 *               The parameter 'dst' has to point to a signed 32-bit variable that is writable from the calling
 *               context.
 *********************************************************************************************************************/
# define VStdLib_ConvertUint8ArrayToSint32LittleEndian(src, dst)  VStdLib_ConvertUint8ArrayToUint32LittleEndian((src), ((uint32*)(dst)))

# endif /* VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON */

# if (defined (PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON))

/**********************************************************************************************************************
 *  VStdLib_ConvertSint64ToUint8ArrayBigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 64-bit value to an unsigned 8-bit array according to big endian.
 *  \details     -
 *  \param[in]   src   The signed 64-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least eight elements that is writable
 *               from the calling context.
 *********************************************************************************************************************/
#  define VStdLib_ConvertSint64ToUint8ArrayBigEndian(src, dst)  VStdLib_ConvertUint64ToUint8ArrayBigEndian(((uint64)(src)), (dst))

/**********************************************************************************************************************
 *  VStdLib_ConvertSint64ToUint8ArrayLittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 64-bit value to an unsigned 8-bit array according to little endian.
 *  \details     -
 *  \param[in]   src   The signed 64-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least eight elements that is writable
 *               from the calling context.
 *********************************************************************************************************************/
#  define VStdLib_ConvertSint64ToUint8ArrayLittleEndian(src, dst)  VStdLib_ConvertUint64ToUint8ArrayLittleEndian(((uint64)(src)), (dst))

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToSint64BigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to a signed 64-bit value according to big endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to a signed 64-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least eight elements.
 *               The parameter 'dst' has to point to a signed 64-bit variable that is writable from the calling
 *               context.
 *********************************************************************************************************************/
#  define VStdLib_ConvertUint8ArrayToSint64BigEndian(src, dst)  VStdLib_ConvertUint8ArrayToUint64BigEndian((src), ((uint64*)(dst)))

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToSint64LittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to a signed 64-bit value according to little endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to a signed 64-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least eight elements.
 *               The parameter 'dst' has to point to a signed 64-bit variable that is writable from the calling
 *               context.
 *********************************************************************************************************************/
#  define VStdLib_ConvertUint8ArrayToSint64LittleEndian(src, dst)  VStdLib_ConvertUint8ArrayToUint64LittleEndian((src), ((uint64*)(dst)))

# endif /* defined (PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON) */

# if (VSTDLIB_USE_16BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_SwapEndianSint16()
 *********************************************************************************************************************/
/*! \brief       Swaps the endianness of the specified signed 16-bit value.
 *  \details     -
 *  \param[in]   value   Signed 16-bit value, whose endianness shall be swapped.
 *  \return      Value in the swapped endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
#  define VStdLib_SwapEndianSint16(value)  ((sint16)VStdLib_SwapEndianUint16(((uint16)(value))))

# endif /* VSTDLIB_USE_16BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON */

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToBigUint16()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 16-bit value from the platform endianness to big endian.
 *  \details     -
 *  \param[in]   value   Unsigned 16-bit value according to the platform endianness, which shall be converted to big
 *                       endian.
 *  \return      Value in big endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
#  define VStdLib_ConvertEndianPlatformToBigUint16(value)  (value)
# else
#  define VStdLib_ConvertEndianPlatformToBigUint16(value)  VStdLib_SwapEndianUint16((value))
# endif

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToBigSint16()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 16-bit value from the platform endianness to big endian.
 *  \details     -
 *  \param[in]   value   Signed 16-bit value according to the platform endianness, which shall be converted to big
 *                       endian.
 *  \return      Value in big endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianPlatformToBigSint16(value)  ((sint16)VStdLib_ConvertEndianPlatformToBigUint16(((uint16)(value))))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToLittleUint16()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 16-bit value from the platform endianness to little endian.
 *  \details     -
 *  \param[in]   value   Unsigned 16-bit value according to the platform endianness, which shall be converted to little
 *                       endian.
 *  \return      Value in little endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
#  define VStdLib_ConvertEndianPlatformToLittleUint16(value)  (value)
# else
#  define VStdLib_ConvertEndianPlatformToLittleUint16(value)  VStdLib_SwapEndianUint16((value))
# endif

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToLittleSint16()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 16-bit value from the platform endianness to little endian.
 *  \details     -
 *  \param[in]   value   Signed 16-bit value according to the platform endianness, which shall be converted to little
 *                       endian.
 *  \return      Value in little endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianPlatformToLittleSint16(value)  ((sint16)VStdLib_ConvertEndianPlatformToLittleUint16(((uint16)(value))))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianBigToPlatformUint16()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 16-bit value from big endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Unsigned 16-bit value according to big endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianBigToPlatformUint16(value)  VStdLib_ConvertEndianPlatformToBigUint16((value))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianBigToPlatformSint16()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 16-bit value from big endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Signed 16-bit value according to big endian, which shall be converted to the platform.
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianBigToPlatformSint16(value)  VStdLib_ConvertEndianPlatformToBigSint16((value))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianLittleToPlatformUint16()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 16-bit value from little endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Unsigned 16-bit value according to little endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianLittleToPlatformUint16(value)  VStdLib_ConvertEndianPlatformToLittleUint16((value))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianLittleToPlatformSint16()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 16-bit value from little endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Signed 16-bit value according to little endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianLittleToPlatformSint16(value)  VStdLib_ConvertEndianPlatformToLittleSint16((value))

# if (VSTDLIB_USE_32BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_SwapEndianSint32()
 *********************************************************************************************************************/
/*! \brief       Swaps the endianness of the specified signed 32-bit value.
 *  \details     -
 *  \param[in]   value   Signed 32-bit value, whose endianness shall be swapped.
 *  \return      Value in the swapped endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
#  define VStdLib_SwapEndianSint32(value)  ((sint32)VStdLib_SwapEndianUint32(((uint32)(value))))

# endif /* VSTDLIB_USE_32BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON */

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToBigUint32()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 32-bit value from the platform endianness to big endian.
 *  \details     -
 *  \param[in]   value   Unsigned 32-bit value according to the platform endianness, which shall be converted to big
 *                       endian.
 *  \return      Value in big endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
#  define VStdLib_ConvertEndianPlatformToBigUint32(value)  (value)
# else
#  define VStdLib_ConvertEndianPlatformToBigUint32(value)  VStdLib_SwapEndianUint32((value))
# endif

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToBigSint32()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 32-bit value from the platform endianness to big endian.
 *  \details     -
 *  \param[in]   value   Signed 32-bit value according to the platform endianness, which shall be converted to big
 *                       endian.
 *  \return      Value in big endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianPlatformToBigSint32(value)  ((sint32)VStdLib_ConvertEndianPlatformToBigUint32(((uint32)(value))))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToLittleUint32()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 32-bit value from the platform endianness to little endian.
 *  \details     -
 *  \param[in]   value   Unsigned 32-bit value according to the platform endianness, which shall be converted to little
 *                       endian.
 *  \return      Value in little endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
#  define VStdLib_ConvertEndianPlatformToLittleUint32(value)  (value)
# else
#  define VStdLib_ConvertEndianPlatformToLittleUint32(value)  VStdLib_SwapEndianUint32((value))
# endif

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToLittleSint32()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 32-bit value from the platform endianness to little endian.
 *  \details     -
 *  \param[in]   value   Signed 32-bit value according to the platform endianness, which shall be converted to little
 *                       endian.
 *  \return      Value in little endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianPlatformToLittleSint32(value)  ((sint32)VStdLib_ConvertEndianPlatformToLittleUint32(((uint32)(value))))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianBigToPlatformUint32()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 32-bit value from big endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Unsigned 32-bit value according to big endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianBigToPlatformUint32(value)  VStdLib_ConvertEndianPlatformToBigUint32((value))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianBigToPlatformSint32()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 32-bit value from big endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Signed 32-bit value according to big endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianBigToPlatformSint32(value)  VStdLib_ConvertEndianPlatformToBigSint32((value))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianLittleToPlatformUint32()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 32-bit value from little endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Unsigned 32-bit value according to little endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianLittleToPlatformUint32(value)  VStdLib_ConvertEndianPlatformToLittleUint32((value))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianLittleToPlatformSint32()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 32-bit value from little endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Signed 32-bit value according to little endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      -
 *  \pre         -
 *********************************************************************************************************************/
# define VStdLib_ConvertEndianLittleToPlatformSint32(value)  VStdLib_ConvertEndianPlatformToLittleSint32((value))

# if defined (PLATFORM_SUPPORT_SINT64_UINT64)
#  if (VSTDLIB_USE_64BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_SwapEndianSint64()
 *********************************************************************************************************************/
/*! \brief       Swaps the endianness of the specified signed 64-bit value.
 *  \details     -
 *  \param[in]   value   Signed 64-bit value, whose endianness shall be swapped.
 *  \return      Value in the swapped endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
#   define VStdLib_SwapEndianSint64(value)  ((sint64)VStdLib_SwapEndianUint64(((uint64)(value))))

#  endif /* VSTDLIB_USE_64BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON */

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToBigUint64()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 64-bit value from the platform endianness to big endian.
 *  \details     -
 *  \param[in]   value   Unsigned 64-bit value according to the platform endianness, which shall be converted to big
 *                       endian.
 *  \return      Value in big endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \pre         -
 *********************************************************************************************************************/
#  if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
#   define VStdLib_ConvertEndianPlatformToBigUint64(value)  (value)
#  else
#   define VStdLib_ConvertEndianPlatformToBigUint64(value)  VStdLib_SwapEndianUint64((value))
#  endif

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToBigSint64()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 64-bit value from the platform endianness to big endian.
 *  \details     -
 *  \param[in]   value   Signed 64-bit value according to the platform endianness, which shall be converted to big
 *                       endian.
 *  \return      Value in big endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \pre         -
 *********************************************************************************************************************/
#  define VStdLib_ConvertEndianPlatformToBigSint64(value)  ((sint64)VStdLib_ConvertEndianPlatformToBigUint64(((uint64)(value))))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToLittleUint64()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 64-bit value from the platform endianness to little endian.
 *  \details     -
 *  \param[in]   value   Unsigned 64-bit value according to the platform endianness, which shall be converted to little
 *                       endian.
 *  \return      Value in little endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \pre         -
 *********************************************************************************************************************/
#  if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
#   define VStdLib_ConvertEndianPlatformToLittleUint64(value)  (value)
#  else
#   define VStdLib_ConvertEndianPlatformToLittleUint64(value)  VStdLib_SwapEndianUint64((value))
#  endif

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianPlatformToLittleSint64()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 64-bit value from the platform endianness to little endian.
 *  \details     -
 *  \param[in]   value   Signed 64-bit value according to the platform endianness, which shall be converted to little
 *                       endian.
 *  \return      Value in little endian.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \pre         -
 *********************************************************************************************************************/
#  define VStdLib_ConvertEndianPlatformToLittleSint64(value)  ((sint64)VStdLib_ConvertEndianPlatformToLittleUint64(((uint64)(value))))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianBigToPlatformUint64()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 64-bit value from big endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Unsigned 64-bit value according to big endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \pre         -
 *********************************************************************************************************************/
#  define VStdLib_ConvertEndianBigToPlatformUint64(value)  VStdLib_ConvertEndianPlatformToBigUint64((value))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianBigToPlatformSint64()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 64-bit value from big endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Signed 64-bit value according to big endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \pre         -
 *********************************************************************************************************************/
#  define VStdLib_ConvertEndianBigToPlatformSint64(value)  VStdLib_ConvertEndianPlatformToBigSint64((value))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianLittleToPlatformUint64()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 64-bit value from little endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Unsigned 64-bit value according to little endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \pre         -
 *********************************************************************************************************************/
#  define VStdLib_ConvertEndianLittleToPlatformUint64(value)  VStdLib_ConvertEndianPlatformToLittleUint64((value))

/**********************************************************************************************************************
 *  VStdLib_ConvertEndianLittleToPlatformSint64()
 *********************************************************************************************************************/
/*! \brief       Converts the specified signed 64-bit value from little endian to the platform endianness.
 *  \details     -
 *  \param[in]   value   Signed 64-bit value according to little endian, which shall be converted to the platform
 *                       endianness.
 *  \return      Value in the platform endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \pre         -
 *********************************************************************************************************************/
#  define VStdLib_ConvertEndianLittleToPlatformSint64(value)  VStdLib_ConvertEndianPlatformToLittleSint64((value))

# endif /* defined (PLATFORM_SUPPORT_SINT64_UINT64) */

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianPlatformToBig()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bytes starting at pSrc (platform endianness) to another memory location starting at pDst
 *               in big endian according to the integer type intType.
 *  \details     Depending on the configuration (VSTDLIB_RUNTIME_OPTIMIZATION) and the passed arguments for parameter
 *               intType and nCnt different memory access sizes are used (see TechRef).
 *               intType value VSTDLIB_INTTYPE_64 is only supported if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpyEndianPlatformToBigLarge() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') and writable from the calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
# if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
#  define VStdLib_MemCpyEndianPlatformToBig(pDst, pSrc, nCnt, intType)  VStdLib_MemCpy((pDst), (pSrc), (nCnt))
# else
#  define VStdLib_MemCpyEndianPlatformToBig(pDst, pSrc, nCnt, intType)  VStdLib_MemCpySwapEndian((pDst), (pSrc), (nCnt), (intType))
# endif

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianPlatformToLittle()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bytes starting at pSrc (platform endianness) to another memory location starting at pDst
 *               in little endian according to the integer type intType.
 *  \details     Depending on the configuration (VSTDLIB_RUNTIME_OPTIMIZATION) and the passed arguments for parameter
 *               intType and nCnt different memory access sizes are used (see TechRef).
 *               intType value VSTDLIB_INTTYPE_64 is only supported if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpyEndianPlatformToLittleLarge() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') and writable from the calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
# if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
#  define VStdLib_MemCpyEndianPlatformToLittle(pDst, pSrc, nCnt, intType) \
    VStdLib_MemCpy((pDst), (pSrc), (nCnt))
# else
#  define VStdLib_MemCpyEndianPlatformToLittle(pDst, pSrc, nCnt, intType) \
    VStdLib_MemCpySwapEndian((pDst), (pSrc), (nCnt), (intType))
# endif

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianBigToPlatform()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bytes starting at pSrc (big endian) to another memory location starting at pDst in the
 *               platform endianness according to the integer type intType.
 *  \details     Depending on the configuration (VSTDLIB_RUNTIME_OPTIMIZATION) and the passed arguments for parameter
 *               intType and nCnt different memory access sizes are used (see TechRef).
 *               intType value VSTDLIB_INTTYPE_64 is only supported if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpyEndianBigToPlatformLarge() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') and writable from the calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianBigToPlatform(pDst, pSrc, nCnt, intType) \
    VStdLib_MemCpyEndianPlatformToBig((pDst), (pSrc), (nCnt), (intType))

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianBigToPlatform_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location (big endian) to another in the
 *               platform endianness according to the integer type intType.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpy()/VStdLib_MemCpySwapEndian() to
 *               copy nCnt bytes starting at pSrc to another memory location starting at pDst in the platform
 *               endianness. Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpyEndianBigToPlatformLarge_s() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType').
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianBigToPlatform_s(pDst, nDstSize, pSrc, nCnt, intType, errorCode) \
    VStdLib_MemCpyEndianPlatformToBig_s((pDst), (nDstSize), (pSrc), (nCnt), (intType), (errorCode))

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianLittleToPlatform()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bytes starting at pSrc (little endian) to another memory location starting at pDst in the
 *               platform endianness according to the integer type intType.
 *  \details     Depending on the configuration (VSTDLIB_RUNTIME_OPTIMIZATION) and the passed arguments for parameter
 *               intType and nCnt different memory access sizes are used (see TechRef).
 *               intType value VSTDLIB_INTTYPE_64 is only supported if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpyEndianLittleToPlatformLarge() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') and writable from the calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianLittleToPlatform(pDst, pSrc, nCnt, intType) \
    VStdLib_MemCpyEndianPlatformToLittle((pDst), (pSrc), (nCnt), (intType))

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianLittleToPlatform_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location (little endian) to another in
 *               the platform endianness according to the integer type intType.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpy()/VStdLib_MemCpySwapEndian() to
 *               copy nCnt bytes starting at pSrc to another memory location starting at pDst in the platform
 *               endianness. Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpyEndianLittleToPlatformLarge_s() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType').
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyEndianLittleToPlatform_s(pDst, nDstSize, pSrc, nCnt, intType, errorCode) \
    VStdLib_MemCpyEndianPlatformToLittle_s((pDst), (nDstSize), (pSrc), (nCnt), (intType), (errorCode))

/* PRQA L:VSTDLIB_FUNCTION_LIKE_MACRO */

# if !defined (VStdLib_MemClrMacro)

/**********************************************************************************************************************
 *  VStdLib_MemClrMacro()
 *********************************************************************************************************************/
/*! \brief       Initializes memory to zero (macro implementation).
 *  \details     Sets nCnt blocks starting at pDst to zero (block-size is given by the type of pDst).
 *  \param[out]  pDst          Any typed pointer to the memory location to be initialized, must be aligned
 *                             corresponding to its type and not be NULL.
 *  \param[in]   nCnt          Number of blocks to initialize, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas  defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *********************************************************************************************************************/
#  define VStdLib_MemClrMacro(pDst, nCnt) \
    { VStdLib_CntType __i; for ( __i = 0u; __i < (nCnt); ++__i) { (pDst)[__i] = 0; } } /* FETA_VSTDLIB_MEMSET_MACRO */

# endif

# if !defined (VStdLib_MemSetMacro)

/**********************************************************************************************************************
 *  VStdLib_MemSetMacro()
 *********************************************************************************************************************/
/*! \brief       Initializes memory to a specified pattern (macro implementation).
 *  \details     Sets nCnt blocks starting at pDst to nPattern (block-size is given by the type of pDst).
 *  \param[out]  pDst          Any typed pointer to the memory location to be initialized, must be aligned
 *                             corresponding to its type and not be NULL.
 *  \param[in]   nPattern      The pattern to be used to initialize the memory (consider the correlation between its
 *                             type and the type of pDst).
 *  \param[in]   nCnt          Number of blocks to initialize, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *********************************************************************************************************************/
#  define VStdLib_MemSetMacro(pDst, nPattern, nCnt) \
    { VStdLib_CntType __i; for ( __i = 0u; __i < (nCnt); ++__i) { (pDst)[__i] = (nPattern); } } /* FETA_VSTDLIB_MEMSET_MACRO */

# endif

# if !defined (VStdLib_MemCpyMacro)

/**********************************************************************************************************************
 *  VStdLib_MemCpyMacro()
 *********************************************************************************************************************/
/*! \brief       Copies data from one memory location to another (macro implementation).
 *  \details     Copies nCnt blocks starting at pSrc to another memory location starting at pDst (block-size is given
 *               by the type of pDst).
 *  \param[out]  pDst          Any typed pointer to the memory location to copy to, must be aligned corresponding
 *                             to its type and not be NULL.
 *  \param[in]   pSrc          Any typed pointer to the memory location to copy from, must be aligned corresponding
 *                             to its type and not be NULL.
 *  \param[in]   nCnt          Number of blocks to copy, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyMacro(pDst, pSrc, nCnt) \
    { VStdLib_CntType __i; for ( __i = 0u; __i < (nCnt); ++__i) { (pDst)[__i] = (pSrc)[__i]; } } /* FETA_VSTDLIB_MEMCPY_MACRO */

# endif

# if !defined (VStdLib_MemCpyMacro_s)

/**********************************************************************************************************************
 *  VStdLib_MemCpyMacro_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location to another (macro
 *               implementation).
 *  \details     Uses VStdLib_MemCpyMacro() to copy nCnt blocks starting at pSrc to another memory location starting
 *               at pDst (block-size is given by the type of pDst), if nDstSize is greater than or equal to nCnt.
 *  \param[out]  pDst          Any typed pointer to the memory location to copy to, must be aligned corresponding
 *                             to its type and not be NULL.
 *  \param[in]   nDstSize      Maximum number of blocks available in the destination  (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Any typed pointer to the memory location to copy from, must be aligned corresponding
 *                             to its type and not be NULL.
 *  \param[in]   nCnt          Number of blocks to copy.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
#  define VStdLib_MemCpyMacro_s(pDst, nDstSize, pSrc, nCnt) \
    { if ((nDstSize) >= (nCnt)) { VStdLib_MemCpyMacro((pDst), (pSrc), (nCnt)); } } /* FETA_VSTDLIB_CALL_MEMCPY_MACRO */

# endif

/**********************************************************************************************************************
 *  GLOBAL FUNCTION PROTOTYPES (FUNCTION API)
 *********************************************************************************************************************/

# define VSTDLIB_START_SEC_CODE
# include "MemMap.h" /* PRQA S 5087 */ /* MD_MSR_MemMap */

# if (VSTDLIB_USE_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_MemSet()
 *********************************************************************************************************************/
/*! \brief       Initializes memory to a specified pattern.
 *  \details     Sets nCnt bytes starting at pDst to the character nPattern.
 *  \param[out]  pDst          Pointer to the memory location to be initialized, must not be NULL.
 *  \param[in]   nPattern      The character to be used to initialize the memory.
 *  \param[in]   nCnt          Number of bytes to initialize, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_LIBRARY_FUNCTIONS == STD_ON.
 *               The compatible definition VStdLib_MemSetLarge() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_MemSet(P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
                                        uint8 nPattern,
                                        VStdLib_CntType nCnt);

/**********************************************************************************************************************
 *  VStdLib_MemCpy()
 *********************************************************************************************************************/
/*! \brief       Copies data from one memory location to another.
 *  \details     Copies nCnt bytes starting at pSrc to another memory location starting at pDst.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_LIBRARY_FUNCTIONS == STD_ON.
 *               The compatible definition VStdLib_MemCpyLarge() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_MemCpy(P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
                                        P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
                                        VStdLib_CntType nCnt);

/**********************************************************************************************************************
 *  VStdLib_MemCpy16()
 *********************************************************************************************************************/
/*! \brief       Copies data from one memory location to another.
 *  \details     Copies nCnt 16-bit blocks starting at pSrc to another memory location starting at pDst.
 *  \param[out]  pDst          Pointer to the memory location to copy to, 16-bit aligned and not NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, 16-bit aligned and not NULL.
 *  \param[in]   nCnt          Number of 16-bit blocks to copy, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_LIBRARY_FUNCTIONS == STD_ON.
 *               The compatible definition VStdLib_MemCpy16Large() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_MemCpy16(P2VAR(uint16, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
                                          P2CONST(uint16, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
                                          VStdLib_CntType nCnt);

/**********************************************************************************************************************
 *  VStdLib_MemCpy32()
 *********************************************************************************************************************/
/*! \brief       Copies data from one memory location to another.
 *  \details     Copies nCnt 32-bit blocks starting at pSrc to another memory location starting at pDst.
 *  \param[out]  pDst          Pointer to the memory location to copy to, 32-bit aligned and not NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, 32-bit aligned and not NULL.
 *  \param[in]   nCnt          Number of 32-bit blocks to copy, pDst must be valid for this amount.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_LIBRARY_FUNCTIONS == STD_ON.
 *               The compatible definition VStdLib_MemCpy32Large() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a valid memory area that is writable from the calling
 *               context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_MemCpy32(P2VAR(uint32, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
                                          P2CONST(uint32, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
                                          VStdLib_CntType nCnt);

# endif /* VSTDLIB_USE_LIBRARY_FUNCTIONS != STD_ON */

/**********************************************************************************************************************
 *  VStdLib_MemCpy_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location to another.
 *  \details     Uses VStdLib_MemCpy() to copy nCnt bytes starting at pSrc to another memory location starting
 *               at pDst, if nDstSize is greater than or equal to nCnt.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpyLarge_s() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_MemCpy_s(P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
                                          VStdLib_CntType nDstSize,
                                          P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
                                          VStdLib_CntType nCnt);

/**********************************************************************************************************************
 *  VStdLib_MemCpy_Return_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location to another.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpy() to
 *               copy nCnt bytes starting at pSrc to another memory location starting at pDst.
 *               Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpyLarge_Return_s() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_MemCpy_Return_s(P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
                                                           VStdLib_CntType nDstSize,
                                                           P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
                                                           VStdLib_CntType nCnt,
                                                           Std_ReturnType errorCode);

/**********************************************************************************************************************
 *  VStdLib_MemCpySwapEndian_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location to another in the swapped
 *               endianness according to the integer type intType.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpySwapEndian() to copy and swap nCnt
 *               bytes starting at pSrc to another memory location starting at pDst.
 *               Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpySwapEndianLarge_s() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType').
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_MemCpySwapEndian_s(P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
                                                              VStdLib_CntType nDstSize,
                                                              P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
                                                              VStdLib_CntType nCnt,
                                                              uint8 intType,
                                                              Std_ReturnType errorCode);

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianPlatformToBig_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location (platform endianness) to
 *               another in big endian according to the integer type intType.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpy()/VStdLib_MemCpySwapEndian() to
 *               copy nCnt bytes starting at pSrc to another memory location starting at pDst in big endian.
 *               Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpyEndianPlatformToBigLarge_s() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType').
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *  \vcaattr     EscalateFindings((The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the calling context))
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_MemCpyEndianPlatformToBig_s(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nCnt,
  uint8 intType,
  Std_ReturnType errorCode);

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianPlatformToLittle_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies data from one memory location (platform endianness) to
 *               another in little endian according to the integer type intType.
 *  \details     If nDstSize is greater than or equal to nCnt, it uses VStdLib_MemCpy()/VStdLib_MemCpySwapEndian() to
 *               copy nCnt bytes starting at pSrc to another memory location starting at pDst in little endian.
 *               Otherwise no copying is performed and the passed errorCode is returned.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize      Maximum number of bytes available in the destination (typically the size of the
 *                             destination object).
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \param[in]   errorCode     Value to be returned, if nCnt exceeds nDstSize.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Copying was performed.
 *  \return      errorCode     nCnt exceeds nDstSize. No copying was performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nDstSize'
 *  \synchronous TRUE
 *  \config      The compatible definition VStdLib_MemCpyEndianPlatformToLittleLarge_s() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the
 *               calling context.
 *               The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType').
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *  \vcaattr     EscalateFindings((The parameters 'pDst' and 'nDstSize' have to define a valid memory area that is writable from the calling context))
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_MemCpyEndianPlatformToLittle_s(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nCnt,
  uint8 intType,
  Std_ReturnType errorCode);

# if (VSTDLIB_USE_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_MemCmp()
 *********************************************************************************************************************/
/*! \brief       Compares two buffers for the specified number of bytes and returns whether they are equal or not.
 *  \details     -
 *  \param[in]   pBuf1     Pointer to first buffer for comparison, must not be NULL.
 *  \param[in]   pBuf2     Pointer to second buffer for comparison, must not be NULL.
 *  \param[in]   nCnt      Number of bytes to compare, pBuf1 and pBuf2 must be valid for this amount.
 *  \return      < 0       The first buffer contains a smaller value than the second buffer.
 *  \return      0         The two buffers are equal for the number of compared bytes.
 *  \return      > 0       The first buffer contains a greater value than the second buffer.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_LIBRARY_FUNCTIONS == STD_ON.
 *               The compatible definition VStdLib_MemCmpLarge() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pBuf1' and 'pBuf2' have to point to valid memory areas. Each memory area has to be
 *               valid for at least the byte count defined in parameter 'nCnt'.
 *               The memory areas defined by parameters 'pBuf1', 'pBuf2' and 'nCnt' must not be changed by another
 *               context while the comparison is being executed.
 *********************************************************************************************************************/
FUNC(sint8, VSTDLIB_CODE) VStdLib_MemCmp(P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pBuf1,
                                         P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pBuf2,
                                         VStdLib_CntType nCnt);

# endif /* VSTDLIB_USE_LIBRARY_FUNCTIONS != STD_ON */

# if (VSTDLIB_USE_MEM_CPY_ENDIAN_CONVERSION_LIBRARY_FUNCTION != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_MemCpySwapEndian()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bytes starting at pSrc to another memory location starting at pDst in the swapped
 *               endianness according to the integer type intType.
 *  \details     Depending on the configuration (VSTDLIB_RUNTIME_OPTIMIZATION) and the passed arguments for parameter
 *               intType and nCnt different memory access sizes are used (see TechRef).
 *               intType value VSTDLIB_INTTYPE_64 is only supported if PLATFORM_SUPPORT_SINT64_UINT64 is defined.
 *  \param[out]  pDst          Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   pSrc          Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nCnt          Number of bytes to copy, pDst must be valid for this amount.
 *  \param[in]   intType       Integer type with which the memory locations are interpreted
 *                             (VSTDLIB_INTTYPE_[8, 16, 32, 64]).
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst' and 'nCnt'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_MEM_CPY_ENDIAN_CONVERSION_LIBRARY_FUNCTION == STD_ON.
 *               The compatible definition VStdLib_MemCpySwapEndianLarge() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pDst' and 'nCnt' have to define a memory area that is valid for a multiple of the
 *               integer type size (parameter 'intType') and writable from the calling context.
 *               The parameter 'pDst' is aligned according to the integer type 'intType'.
 *               The source memory area defined by parameters 'pSrc' and 'nCnt' must not be changed by another context
 *               while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_MemCpySwapEndian(P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
                                                  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
                                                  VStdLib_CntType nCnt,
                                                  uint8 intType);

# endif /* VSTDLIB_USE_MEM_CPY_ENDIAN_CONVERSION_LIBRARY_FUNCTION != STD_ON */

# if(VSTDLIB_USE_BITCPYSAWTOOTH_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_BitCpySawBigToBigEndian()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bits of big endian data from one memory location to another memory location with big
 *               endian data.
 *  \details     -
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetSaw'.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffetSaw' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_BITCPYSAWTOOTH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameters 'pDst', 'nDstBitOffsetSaw' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetSaw' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_BitCpySawBigToBigEndian(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstBitOffsetSaw,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetSaw,
  VStdLib_CntType nCnt);

/**********************************************************************************************************************
 *  VStdLib_BitCpySawBigToLittleEndian()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bits of big endian data from one memory location to another memory location with little
 *               endian data.
 *  \details     -
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetSaw'.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffetSaw' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_BITCPYSAWTOOTH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameters 'pDst', 'nDstBitOffsetSaw' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetSaw' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_BitCpySawBigToLittleEndian(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstBitOffsetSaw,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetSaw,
  VStdLib_CntType nCnt);

/**********************************************************************************************************************
 *  VStdLib_BitCpySawLittleToBigEndian()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bits of little endian data from one memory location to another memory location with big
 *               endian data.
 *  \details     -
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetSaw'.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffetSaw' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_BITCPYSAWTOOTH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameters 'pDst', 'nDstBitOffsetSaw' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetSaw' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_BitCpySawLittleToBigEndian(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstBitOffsetSaw,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetSaw,
  VStdLib_CntType nCnt);

/**********************************************************************************************************************
 *  VStdLib_BitCpySawLittleToLittleEndian()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bits of little endian data from one memory location to another memory location with
 *               little endian data.
 *  \details     -
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetSaw'.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffetSaw' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_BITCPYSAWTOOTH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameters 'pDst', 'nDstBitOffsetSaw' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetSaw' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_BitCpySawLittleToLittleEndian(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstBitOffsetSaw,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetSaw,
  VStdLib_CntType nCnt);

# endif /* VSTDLIB_USE_BITCPYSAWTOOTH_LIBRARY_FUNCTIONS != STD_ON */

/**********************************************************************************************************************
 *  VStdLib_BitCpySawBigToBigEndian_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies nCnt bits of big endian data from one memory location to
 *               another memory location with big endian data.
 *  \details     Uses VStdLib_BitCpySawBigToBigEndian() to copy data, if nDstSize is greater than or equal to the last
 *               byte to copy to.
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize             Maximum number of bytes available in the destination (typically the size of the
 *                                    destination object).
 *  \param[in]   nDstBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to 
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetSaw'.
 *  \param[in]   errorCode            Value to be returned, if 'nCnt' bits starting at 'nDstBitOffsetSaw' exceeds
 *                                    'nDstSize'. Should not be equal to E_OK.
 *  \return      E_OK                 Copying was performed.
 *  \return      errorCode            'nCnt' bits starting at 'nDstBitOffsetSaw'' exceeds 'nDstSize'. No copying was 
 *                                    performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffetSaw' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      -
 *  \pre         The parameters 'pDst', 'nDstBitOffsetSaw' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetSaw' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_BitCpySawBigToBigEndian_s(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  VStdLib_CntType nDstBitOffsetSaw,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetSaw,
  VStdLib_CntType nCnt,
  Std_ReturnType errorCode);

/**********************************************************************************************************************
 *  VStdLib_BitCpySawBigToLittleEndian_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies nCnt bits of big endian data from one memory location to
 *               another memory location with little endian data.
 *  \details     Uses VStdLib_BitCpySawBigToLittleEndian() to copy data, if nDstSize is greater than or equal to the
 *               last byte to copy to.
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize             Maximum number of bytes available in the destination (typically the size of the
 *                                    destination object).
 *  \param[in]   nDstBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to 
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetSaw'.
 *  \param[in]   errorCode            Value to be returned, if 'nCnt' bits starting at 'nDstBitOffsetSaw' exceeds
 *                                    'nDstSize'. Should not be equal to E_OK.
 *  \return      E_OK                 Copying was performed.
 *  \return      errorCode            'nCnt' bits starting at 'nDstBitOffsetSaw' exceeds 'nDstSize'. No copying was 
 *                                    performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffetSaw' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      -
 *  \pre         The parameters 'pDst', 'nDstBitOffsetSaw' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetSaw' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_BitCpySawBigToLittleEndian_s(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  VStdLib_CntType nDstBitOffsetSaw,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetSaw,
  VStdLib_CntType nCnt,
  Std_ReturnType errorCode);

/**********************************************************************************************************************
 *  VStdLib_BitCpySawLittleToBigEndian_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies nCnt bits of little endian data from one memory location to
 *               another memory location with big endian data. 
 *  \details     Uses VStdLib_BitCpySawLittleToBigEndian() to copy data, if nDstSize is greater than or equal to the
 *               last byte to copy to.
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize             Maximum number of bytes available in the destination (typically the size of the
 *                                    destination object).
 *  \param[in]   nDstBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetSaw'.
 *  \param[in]   errorCode            Value to be returned, if 'nCnt' bits starting at 'nDstBitOffsetSaw' exceeds
 *                                    'nDstSize'. Should not be equal to E_OK.
 *  \return      E_OK                 Copying was performed.
 *  \return      errorCode            'nCnt' bits starting at 'nDstBitOffsetSaw' exceeds 'nDstSize'. No copying was 
 *                                    performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffetSaw' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      -
 *  \pre         The parameters 'pDst', 'nDstBitOffsetSaw' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetSaw' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_BitCpySawLittleToBigEndian_s(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  VStdLib_CntType nDstBitOffsetSaw,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetSaw,
  VStdLib_CntType nCnt,
  Std_ReturnType errorCode);

/**********************************************************************************************************************
 *  VStdLib_BitCpySawLittleToLittleEndian_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies nCnt bits of little endian data from one memory location to
 *               another memory location with little endian data.
 *  \details     Uses VStdLib_BitCpySawLittleToLittleEndian() to copy data, if nDstSize is greater than or equal to
 *               the last byte to copy to.
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize             Maximum number of bytes available in the destination (typically the size of the
 *                                    destination object).
 *  \param[in]   nDstBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to 
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetSaw     Bit offset (it can even be greater than 7) in sawtooth numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetSaw'.
 *  \param[in]   errorCode            Value to be returned, if 'nCnt' bits starting at 'nDstBitOffsetSaw' exceeds
 *                                    'nDstSize'. Should not be equal to E_OK.
 *  \return      E_OK                 Copying was performed.
 *  \return      errorCode            'nCnt' bits starting at 'nDstBitOffsetSaw' exceeds 'nDstSize'. No copying was
 *                                    performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffetSaw' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      -
 *  \pre         The parameters 'pDst', 'nDstBitOffsetSaw' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetSaw' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_BitCpySawLittleToLittleEndian_s(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  VStdLib_CntType nDstBitOffsetSaw,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetSaw,
  VStdLib_CntType nCnt,
  Std_ReturnType errorCode);

# if(VSTDLIB_USE_BITCPYMONOTONE_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_BitCpyMonBigToBigEndian()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bits of big endian data from one memory location to another memory location with big
 *               endian data.
 *  \details     -
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetMon'.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_BITCPYMONOTONE_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetMon' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_BitCpyMonBigToBigEndian(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstBitOffsetMon,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetMon,
  VStdLib_CntType nCnt);

/**********************************************************************************************************************
 *  VStdLib_BitCpyMonBigToLittleEndian()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bits of big endian data from one memory location to another memory location with little
 *               endian data.
 *  \details     -
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetMon    Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetMon'.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_BITCPYMONOTONE_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetMon' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_BitCpyMonBigToLittleEndian(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstBitOffsetMon,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetMon,
  VStdLib_CntType nCnt);

/**********************************************************************************************************************
 *  VStdLib_BitCpyMonLittleToBigEndian()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bits of little endian data from one memory location to another memory location with big
 *               endian data.
 *  \details     -
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetMon'.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_BITCPYMONOTONE_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetMon' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_BitCpyMonLittleToBigEndian(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstBitOffsetMon,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetMon,
  VStdLib_CntType nCnt);

/**********************************************************************************************************************
 *  VStdLib_BitCpyMonLittleToLittleEndian()
 *********************************************************************************************************************/
/*! \brief       Copies nCnt bits of little endian data from one memory location to another memory location with
 *               little endian data.
 *  \details     -
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetMon'.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_BITCPYMONOTONE_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetMon' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_BitCpyMonLittleToLittleEndian(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstBitOffsetMon,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetMon,
  VStdLib_CntType nCnt);

# endif /* VSTDLIB_USE_BITCPYMONOTONE_LIBRARY_FUNCTIONS != STD_ON */

/**********************************************************************************************************************
 *  VStdLib_BitCpyMonBigToBigEndian_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies nCnt bits of big endian data from one memory location to
 *               another memory location with big endian data.
 *  \details     Uses VStdLib_BitCpyMonBigToBigEndian() to copy data, if nDstSize is greater than or equal to the last
 *               byte to copy to.
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize             Maximum number of bytes available in the destination (typically the size of the
 *                                    destination object).
 *  \param[in]   nDstBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetMon'.
 *  \param[in]   errorCode            Value to be returned, if 'nCnt' bits starting at 'nDstBitOffsetMon' exceeds
 *                                    'nDstSize'. Should not be equal to E_OK.
 *  \return      E_OK                 Copying was performed.
 *  \return      errorCode            'nCnt' bits starting at 'nDstBitOffsetMon' exceeds 'nDstSize'. No copying was
 *                                    performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      -
 *  \pre         The parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetMon' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_BitCpyMonBigToBigEndian_s(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  VStdLib_CntType nDstBitOffsetMon,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetMon,
  VStdLib_CntType nCnt,
  Std_ReturnType errorCode);

/**********************************************************************************************************************
 *  VStdLib_BitCpyMonBigToLittleEndian_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies nCnt bits of big endian data from one memory location to
 *               another memory location with little endian data.
 *  \details     Uses VStdLib_BitCpyMonBigToLittleEndian() to copy data, if nDstSize is greater than or equal to the
 *               last byte to copy to.
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize             Maximum number of bytes available in the destination (typically the size of the
 *                                    destination object).
 *  \param[in]   nDstBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetMon'.
 *  \param[in]   errorCode            Value to be returned, if 'nCnt' bits starting at 'nDstBitOffsetMon' exceeds
 *                                    'nDstSize'. Should not be equal to E_OK.
 *  \return      E_OK                 Copying was performed.
 *  \return      errorCode            'nCnt' bits starting at 'nDstBitOffsetMon' exceeds 'nDstSize'. No copying was
 *                                    performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      -
 *  \pre         The parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetMon' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_BitCpyMonBigToLittleEndian_s(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  VStdLib_CntType nDstBitOffsetMon,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetMon,
  VStdLib_CntType nCnt,
  Std_ReturnType errorCode);

/**********************************************************************************************************************
 *  VStdLib_BitCpyMonLittleToBigEndian_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies nCnt bits of little endian data from one memory location to
 *               another memory location with big endian data
 *  \details     Uses VStdLib_BitCpyMonLittleToBigEndian() to copy data, if nDstSize is greater than or equal to the
 *               last byte to copy to.
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize             Maximum number of bytes available in the destination (typically the size of the
 *                                    destination object).
 *  \param[in]   nDstBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetMon'.
 *  \param[in]   errorCode            Value to be returned, if 'nCnt' bits starting at 'nDstBitOffsetMon' exceeds
 *                                    'nDstSize'. Should not be equal to E_OK.
 *  \return      E_OK                 Copying was performed.
 *  \return      errorCode            'nCnt' bits starting at 'nDstBitOffsetMon' exceeds 'nDstSize'. No copying was
 *                                    performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      -
 *  \pre         The parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetMon' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_BitCpyMonLittleToBigEndian_s(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  VStdLib_CntType nDstBitOffsetMon,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetMon,
  VStdLib_CntType nCnt,
  Std_ReturnType errorCode);

/**********************************************************************************************************************
 *  VStdLib_BitCpyMonLittleToLittleEndian_s()
 *********************************************************************************************************************/
/*! \brief       Verifies the destination size and copies nCnt bits of little endian data from one memory location to
 *               another memory location with little endian data.
 *  \details     Uses VStdLib_BitCpyMonLittleToLittleEndian() to copy data, if nDstSize is greater than or equal to
 *               the last byte to copy to.
 *  \param[out]  pDst                 Pointer to the memory location to copy to, must not be NULL.
 *  \param[in]   nDstSize             Maximum number of bytes available in the destination (typically the size of the
 *                                    destination object).
 *  \param[in]   nDstBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pDst'. Bits are copied to exactly this bit position.
 *  \param[in]   pSrc                 Pointer to the memory location to copy from, must not be NULL.
 *  \param[in]   nSrcBitOffsetMon     Bit offset (it can even be greater than 7) in monotone numbering is added to
 *                                    'pSrc'. Bits are copied from exactly this bit position.
 *  \param[in]   nCnt                 Number of bits to copy starting at 'nDstBitOffsetMon'.
 *  \param[in]   errorCode            Value to be returned, if 'nCnt' bits starting at 'nDstBitOffsetMon' exceeds
 *                                    'nDstSize'. Should not be equal to E_OK.
 *  \return      E_OK                 Copying was performed.
 *  \return      errorCode            'nCnt' bits starting at 'nDstBitOffsetMon' exceeds 'nDstSize'. No copying was
 *                                    performed.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt'.
 *  \synchronous TRUE
 *  \config      -
 *  \pre         The parameters 'pDst', 'nDstBitOffsetMon' and 'nCnt' have to define a valid memory area that is
 *               writable from the calling context.
 *               The source memory area defined by parameters 'pSrc', 'nSrcBitOffsetMon' and 'nCnt' must not
 *               be changed by another context while the copying is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_BitCpyMonLittleToLittleEndian_s(
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  VStdLib_CntType nDstBitOffsetMon,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nSrcBitOffsetMon,
  VStdLib_CntType nCnt,
  Std_ReturnType errorCode);

# if (VSTDLIB_USE_MEM_CHECK_LIBRARY_FUNCTION != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_MemCheck()
 *********************************************************************************************************************/
/*! \brief       Compares the content of a memory area to a specified pattern.
 *  \details     Compares nCnt bytes of memory starting at pBuf to the character nPattern.
 *  \param[in]   pBuf          Pointer to the memory location to be checked, must not be NULL.
 *  \param[in]   nPattern      The character to be checked for in the memory.
 *  \param[in]   nCnt          Number of bytes to be checked, pBuf must be valid for this amount.
 *  \param[in]   errorCode     Value to be returned, if content of pBuf is not equal to pattern.
 *                             Should not be equal to E_OK.
 *  \return      E_OK          Content of pBuf is equal to pattern.
 *  \return      errorCode     Content of pBuf is not equal to pattern.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_MEMCHECK_FUNCTION == STD_ON.
 *               The compatible definition VStdLib_MemCheckLarge() exists additionally (and solely)
 *               if VSTDLIB_SUPPORT_LARGE_DATA == STD_ON.
 *  \pre         The parameters 'pBuf' and 'nCnt' have to define a valid memory area.
 *               The memory area defined by parameters 'pBuf' and 'nCnt' must not be changed by another context while
 *               the comparison is being executed.
 *               The parameter 'errorCode' must not be E_OK.
 *********************************************************************************************************************/
FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_MemCheck(P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pBuf, 
                                                    uint8 nPattern, 
                                                    VStdLib_CntType nCnt,
                                                    Std_ReturnType errorCode);

# endif /* VSTDLIB_USE_MEM_CHECK_LIBRARY_FUNCTION != STD_ON */

# if (VSTDLIB_VERSION_INFO_API == STD_ON)

/**********************************************************************************************************************
 *  VStdLib_GetVersionInfo()
 *********************************************************************************************************************/
/*! \brief       Returns the version information of this module.
 *  \details     Returns version information, vendor ID and AUTOSAR module ID of the component.
 *  \param[out]  versioninfo   Pointer to where to store the version information, must not be NULL.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      VSTDLIB_VERSION_INFO_API == STD_ON
 *  \pre         The parameter 'versioninfo' has to be valid and reference an object of type Std_VersionInfoType.
 *  \trace       CREQ-VStdLib-VersionInformation
 *********************************************************************************************************************/
FUNC(void, VSTDLIB_CODE) VStdLib_GetVersionInfo(P2VAR(Std_VersionInfoType, AUTOMATIC, VSTDLIB_APPL_VAR) versioninfo);

# endif /* VSTDLIB_VERSION_INFO_API == STD_ON */

# if (VSTDLIB_USE_8BIT_SEARCH_LIBRARY_FUNCTIONS != STD_ON) 

/**********************************************************************************************************************
 *  VStdLib_GetHighestBitPosOne8()
 *********************************************************************************************************************/
/*! \brief       Returns the highest bit position of a set bit in the specified 8-bit value.
 *  \details     -
 *  \param[in]   value              The 8-bit value in which the highest set bit shall be found.
 *  \return      0-7                Bit position of the highest set bit.
 *  \return      VSTDLIB_BITPOS_NA  8-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_8BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetHighestBitPosOne8(uint8 value);

/**********************************************************************************************************************
 *  VStdLib_GetHighestBitPosZero8()
 *********************************************************************************************************************/
/*! \brief       Returns the highest bit position of an unset bit in the specified 8-bit value.
 *  \details     -
 *  \param[in]   value              The 8-bit value in which the highest unset bit shall be found.
 *  \return      0-7                Bit position of the highest unset bit.
 *  \return      VSTDLIB_BITPOS_NA  8-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_8BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetHighestBitPosZero8(uint8 value);

/**********************************************************************************************************************
 *  VStdLib_GetLowestBitPosOne8()
 *********************************************************************************************************************/
/*! \brief       Returns the lowest bit position of a set bit in the specified 8-bit value.
 *  \details     -
 *  \param[in]   value              The 8-bit value in which the lowest set bit shall be found.
 *  \return      0-7                Bit position of the lowest set bit.
 *  \return      VSTDLIB_BITPOS_NA  8-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_8BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetLowestBitPosOne8(uint8 value);

/**********************************************************************************************************************
 *  VStdLib_GetLowestBitPosZero8()
 *********************************************************************************************************************/
/*! \brief       Returns the lowest bit position of an unset bit in the specified 8-bit value.
 *  \details     -
 *  \param[in]   value              The 8-bit value in which the lowest unset bit shall be found.
 *  \return      0-7                Bit position of the lowest unset bit.
 *  \return      VSTDLIB_BITPOS_NA  8-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_8BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetLowestBitPosZero8(uint8 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountLeadingOnes8()
 *********************************************************************************************************************/
/*! \brief       Returns the count of set bits preceding the highest unset bit in the specified 8-bit value.
 *  \details     -
 *  \param[in]   value              The 8-bit value in which the count of leading ones shall be determined.
 *  \return      0-7                Count of leading ones.
 *  \return      VSTDLIB_BITCNT_NA  8-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_8BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountLeadingOnes8(uint8 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountLeadingZeros8()
 *********************************************************************************************************************/
/*! \brief       Returns the count of unset bits preceding the highest set bit in the specified 8-bit value.
 *  \details     -
 *  \param[in]   value              The 8-bit value in which the count of leading zeros shall be determined.
 *  \return      0-7                Count of leading zeros.
 *  \return      VSTDLIB_BITCNT_NA  8-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_8BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountLeadingZeros8(uint8 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountTrailingOnes8()
 *********************************************************************************************************************/
/*! \brief       Returns the count of set bits following the lowest unset bit in the specified 8-bit value.
 *  \details     -
 *  \param[in]   value              The 8-bit value in which the count of trailing ones shall be determined.
 *  \return      0-7                Count of trailing ones.
 *  \return      VSTDLIB_BITCNT_NA  8-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_8BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountTrailingOnes8(uint8 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountTrailingZeros8()
 *********************************************************************************************************************/
/*! \brief       Returns the count of unset bits following the lowest set bit in the specified 8-bit value.
 *  \details     -
 *  \param[in]   value              The 8-bit value in which the count of trailing zeros shall be determined.
 *  \return      0-7                Count of trailing zeros.
 *  \return      VSTDLIB_BITCNT_NA  8-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_8BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountTrailingZeros8(uint8 value);

# endif /* VSTDLIB_USE_8BIT_SEARCH_LIBRARY_FUNCTIONS != STD_ON */

# if (VSTDLIB_USE_16BIT_SEARCH_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_GetHighestBitPosOne16()
 *********************************************************************************************************************/
/*! \brief       Returns the highest bit position of a set bit in the specified 16-bit value.
 *  \details     -
 *  \param[in]   value              The 16-bit value in which the highest set bit shall be found.
 *  \return      0-15               Bit position of the highest set bit.
 *  \return      VSTDLIB_BITPOS_NA  16-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetHighestBitPosOne16(uint16 value);

/**********************************************************************************************************************
 *  VStdLib_GetHighestBitPosZero16()
 *********************************************************************************************************************/
/*! \brief       Returns the highest bit position of an unset bit in the specified 16-bit value.
 *  \details     -
 *  \param[in]   value              The 16-bit value in which the highest unset bit shall be found.
 *  \return      0-15               Bit position of the highest unset bit.
 *  \return      VSTDLIB_BITPOS_NA  16-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetHighestBitPosZero16(uint16 value);

/**********************************************************************************************************************
 *  VStdLib_GetLowestBitPosOne16()
 *********************************************************************************************************************/
/*! \brief       Returns the lowest bit position of a set bit in the specified 16-bit value.
 *  \details     -
 *  \param[in]   value              The 16-bit value in which the lowest set bit shall be found.
 *  \return      0-15               Bit position of the lowest set bit.
 *  \return      VSTDLIB_BITPOS_NA  16-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetLowestBitPosOne16(uint16 value);

/**********************************************************************************************************************
 *  VStdLib_GetLowestBitPosZero16()
 *********************************************************************************************************************/
/*! \brief       Returns the lowest bit position of an unset bit in the specified 16-bit value.
 *  \details     -
 *  \param[in]   value              The 16-bit value in which the lowest unset bit shall be found.
 *  \return      0-15               Bit position of the lowest unset bit.
 *  \return      VSTDLIB_BITPOS_NA  16-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetLowestBitPosZero16(uint16 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountLeadingOnes16()
 *********************************************************************************************************************/
/*! \brief       Returns the count of set bits preceding the highest unset bit in the specified 16-bit value.
 *  \details     -
 *  \param[in]   value              The 16-bit value in which the count of leading ones shall be determined.
 *  \return      0-15               Count of leading ones.
 *  \return      VSTDLIB_BITCNT_NA  16-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountLeadingOnes16(uint16 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountLeadingZeros16()
 *********************************************************************************************************************/
/*! \brief       Returns the count of unset bits preceding the highest set bit in the specified 16-bit value.
 *  \details     -
 *  \param[in]   value              The 16-bit value in which the count of leading zeros shall be determined.
 *  \return      0-15               Count of leading zeros.
 *  \return      VSTDLIB_BITCNT_NA  16-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountLeadingZeros16(uint16 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountTrailingOnes16()
 *********************************************************************************************************************/
/*! \brief       Returns the count of set bits following the lowest unset bit in the specified 16-bit value.
 *  \details     -
 *  \param[in]   value              The 16-bit value in which the count of trailing ones shall be determined.
 *  \return      0-15               Count of trailing ones.
 *  \return      VSTDLIB_BITCNT_NA  16-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountTrailingOnes16(uint16 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountTrailingZeros16()
 *********************************************************************************************************************/
/*! \brief       Returns the count of unset bits following the lowest set bit in the specified 16-bit value.
 *  \details     -
 *  \param[in]   value              The 16-bit value in which the count of trailing zeros shall be determined.
 *  \return      0-15               Count of trailing zeros.
 *  \return      VSTDLIB_BITCNT_NA  16-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountTrailingZeros16(uint16 value);

# endif /* VSTDLIB_USE_16BIT_SEARCH_LIBRARY_FUNCTIONS != STD_ON */

# if (VSTDLIB_USE_32BIT_SEARCH_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_GetHighestBitPosOne32()
 *********************************************************************************************************************/
/*! \brief       Returns the highest bit position of a set bit in the specified 32-bit value.
 *  \details     -
 *  \param[in]   value              The 32-bit value in which the highest set bit shall be found.
 *  \return      0-31               Bit position of the highest set bit.
 *  \return      VSTDLIB_BITPOS_NA  32-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetHighestBitPosOne32(uint32 value);

/**********************************************************************************************************************
 *  VStdLib_GetHighestBitPosZero32()
 *********************************************************************************************************************/
/*! \brief       Returns the highest bit position of an unset bit in the specified 32-bit value.
 *  \details     -
 *  \param[in]   value              The 32-bit value in which the highest unset bit shall be found.
 *  \return      0-31               Bit position of the highest unset bit.
 *  \return      VSTDLIB_BITPOS_NA  32-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetHighestBitPosZero32(uint32 value);

/**********************************************************************************************************************
 *  VStdLib_GetLowestBitPosOne32()
 *********************************************************************************************************************/
/*! \brief       Returns the lowest bit position of a set bit in the specified 32-bit value.
 *  \details     -
 *  \param[in]   value              The 32-bit value in which the lowest set bit shall be found.
 *  \return      0-31               Bit position of the lowest set bit.
 *  \return      VSTDLIB_BITPOS_NA  32-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetLowestBitPosOne32(uint32 value);

/**********************************************************************************************************************
 *  VStdLib_GetLowestBitPosZero32()
 *********************************************************************************************************************/
/*! \brief       Returns the lowest bit position of an unset bit in the specified 32-bit value.
 *  \details     -
 *  \param[in]   value              The 32-bit value in which the lowest unset bit shall be found.
 *  \return      0-31               Bit position of the lowest unset bit.
 *  \return      VSTDLIB_BITPOS_NA  32-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetLowestBitPosZero32(uint32 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountLeadingOnes32()
 *********************************************************************************************************************/
/*! \brief       Returns the count of set bits preceding the highest unset bit in the specified 32-bit value.
 *  \details     -
 *  \param[in]   value              The 32-bit value in which the count of leading ones shall be determined.
 *  \return      0-31               Count of leading ones.
 *  \return      VSTDLIB_BITCNT_NA  32-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountLeadingOnes32(uint32 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountLeadingZeros32()
 *********************************************************************************************************************/
/*! \brief       Returns the count of unset bits preceding the highest set bit in the specified 32-bit value.
 *  \details     -
 *  \param[in]   value              The 32-bit value in which the count of leading zeros shall be determined.
 *  \return      0-31               Count of leading zeros.
 *  \return      VSTDLIB_BITCNT_NA  32-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountLeadingZeros32(uint32 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountTrailingOnes32()
 *********************************************************************************************************************/
/*! \brief       Returns the count of set bits following the lowest unset bit in the specified 32-bit value.
 *  \details     -
 *  \param[in]   value              The 32-bit value in which the count of trailing ones shall be determined.
 *  \return      0-31               Count of trailing ones.
 *  \return      VSTDLIB_BITCNT_NA  32-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountTrailingOnes32(uint32 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountTrailingZeros32()
 *********************************************************************************************************************/
/*! \brief       Returns the count of unset bits following the lowest set bit in the specified 32-bit value.
 *  \details     -
 *  \param[in]   value              The 32-bit value in which the count of trailing zeros shall be determined.
 *  \return      0-31               Count of trailing zeros.
 *  \return      VSTDLIB_BITCNT_NA  32-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountTrailingZeros32(uint32 value);

# endif /* VSTDLIB_USE_32BIT_SEARCH_LIBRARY_FUNCTIONS != STD_ON */

# if ((defined PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_SEARCH_LIBRARY_FUNCTIONS != STD_ON))

/**********************************************************************************************************************
 *  VStdLib_GetHighestBitPosOne64()
 *********************************************************************************************************************/
/*! \brief       Returns the highest bit position of a set bit in the specified 64-bit value.
 *  \details     -
 *  \param[in]   value              The 64-bit value in which the highest set bit shall be found.
 *  \return      0-63               Bit position of the highest set bit.
 *  \return      VSTDLIB_BITPOS_NA  64-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetHighestBitPosOne64(uint64 value);

/**********************************************************************************************************************
 *  VStdLib_GetHighestBitPosZero64()
 *********************************************************************************************************************/
/*! \brief       Returns the highest bit position of an unset bit in the specified 64-bit value.
 *  \details     -
 *  \param[in]   value              The 64-bit value in which the highest unset bit shall be found.
 *  \return      0-63               Bit position of the highest unset bit.
 *  \return      VSTDLIB_BITPOS_NA  64-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetHighestBitPosZero64(uint64 value);

/**********************************************************************************************************************
 *  VStdLib_GetLowestBitPosOne64()
 *********************************************************************************************************************/
/*! \brief       Returns the lowest bit position of a set bit in the specified 64-bit value.
 *  \details     -
 *  \param[in]   value              The 64-bit value in which the lowest set bit shall be found.
 *  \return      0-63               Bit position of the lowest set bit.
 *  \return      VSTDLIB_BITPOS_NA  64-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetLowestBitPosOne64(uint64 value);

/**********************************************************************************************************************
 *  VStdLib_GetLowestBitPosZero64()
 *********************************************************************************************************************/
/*! \brief       Returns the lowest bit position of an unset bit in the specified 64-bit value.
 *  \details     -
 *  \param[in]   value              The 64-bit value in which the lowest unset bit shall be found.
 *  \return      0-63               Bit position of the lowest unset bit.
 *  \return      VSTDLIB_BITPOS_NA  64-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetLowestBitPosZero64(uint64 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountLeadingOnes64()
 *********************************************************************************************************************/
/*! \brief       Returns the count of set bits preceding the highest unset bit in the specified 64-bit value.
 *  \details     -
 *  \param[in]   value              The 64-bit value in which the count of leading ones shall be determined.
 *  \return      0-63               Count of leading ones.
 *  \return      VSTDLIB_BITCNT_NA  64-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountLeadingOnes64(uint64 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountLeadingZeros64()
 *********************************************************************************************************************/
/*! \brief       Returns the count of unset bits preceding the highest set bit in the specified 64-bit value.
 *  \details     -
 *  \param[in]   value              The 64-bit value in which the count of leading zeros shall be determined.
 *  \return      0-63               Count of leading zeros.
 *  \return      VSTDLIB_BITCNT_NA  64-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountLeadingZeros64(uint64 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountTrailingOnes64()
 *********************************************************************************************************************/
/*! \brief       Returns the count of set bits following the lowest unset bit in the specified 64-bit value.
 *  \details     -
 *  \param[in]   value              The 64-bit value in which the count of trailing ones shall be determined.
 *  \return      0-63               Count of trailing ones.
 *  \return      VSTDLIB_BITCNT_NA  64-bit value contains no unset bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountTrailingOnes64(uint64 value);

/**********************************************************************************************************************
 *  VStdLib_GetCountTrailingZeros64()
 *********************************************************************************************************************/
/*! \brief       Returns the count of unset bits following the lowest set bit in the specified 64-bit value.
 *  \details     -
 *  \param[in]   value              The 64-bit value in which the count of trailing zeros shall be determined.
 *  \return      0-63               Count of trailing zeros.
 *  \return      VSTDLIB_BITCNT_NA  64-bit value contains no set bit.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_SEARCH_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
FUNC(uint8, VSTDLIB_CODE) VStdLib_GetCountTrailingZeros64(uint64 value);

# endif /* (defined PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_SEARCH_LIBRARY_FUNCTIONS != STD_ON) */

# if (VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_ConvertUint16ToUint8ArrayBigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 16-bit value to an unsigned 8-bit array according to big endian.
 *  \details     -
 *  \param[in]   src   The unsigned 16-bit value which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least two elements that is writable
 *               from the calling context.
 *  \spec
 *    requires   $lengthOf(dst) >= 2;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint16ToUint8ArrayBigEndian(
  uint16 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

/**********************************************************************************************************************
 *  VStdLib_ConvertUint16ToUint8ArrayLittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 16-bit value to an unsigned 8-bit array according to little endian.
 *  \details     -
 *  \param[in]   src   The unsigned 16-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least two elements that is writable
 *               from the calling context.
 *  \spec
 *    requires   $lengthOf(dst) >= 2;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint16ToUint8ArrayLittleEndian(
  uint16 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint16BigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to an unsigned 16-bit value according to big endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 16-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least two elements.
 *               The parameter 'dst' has to point to an unsigned 16-bit variable that is writable from the calling
 *               context.
 *  \spec
 *    requires   $lengthOf(src) >= 2;
 *    requires   $lengthOf(dst) >= 1;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint16BigEndian(
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint16, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint16LittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to an unsigned 16-bit value according to little endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 16-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least two elements.
 *               The parameter 'dst' has to point to an unsigned 16-bit variable that is writable from the calling
 *               context.
 *  \spec
 *    requires   $lengthOf(src) >= 2;
 *    requires   $lengthOf(dst) >= 1;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint16LittleEndian(
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint16, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

# endif /* VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON */

# if (VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_ConvertUint32ToUint8ArrayBigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 32-bit value to an unsigned 8-bit array according to big endian.
 *  \details     -
 *  \param[in]   src   The unsigned 32-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least four elements that is writable
 *               from the calling context.
 *  \spec
 *    requires   $lengthOf(dst) >= 4;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint32ToUint8ArrayBigEndian(
  uint32 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

/**********************************************************************************************************************
 *  VStdLib_ConvertUint32ToUint8ArrayLittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 32-bit value to an unsigned 8-bit array according to little endian.
 *  \details     -
 *  \param[in]   src   The unsigned 32-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least four elements that is writable
 *               from the calling context.
 *  \spec
 *    requires   $lengthOf(dst) >= 4;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint32ToUint8ArrayLittleEndian(
  uint32 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint32BigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to an unsigned 32-bit value according to big endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 32-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least four elements.
 *               The parameter 'dst' has to point to an unsigned 32-bit variable that is writable from the calling
 *               context.
 *  \spec
 *    requires   $lengthOf(src) >= 4;
 *    requires   $lengthOf(dst) >= 1;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint32BigEndian(
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint32, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint32LittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to an unsigned 32-bit value according to little endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 32-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least four elements.
 *               The parameter 'dst' has to point to an unsigned 32-bit variable that is writable from the calling
 *               context.
 *  \spec
 *    requires   $lengthOf(src) >= 4;
 *    requires   $lengthOf(dst) >= 1;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint32LittleEndian(
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint32, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

# endif /* VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON */

# if (defined (PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON))

/**********************************************************************************************************************
 *  VStdLib_ConvertUint64ToUint8ArrayBigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 64-bit value to an unsigned 8-bit array according to big endian.
 *  \details     -
 *  \param[in]   src   The unsigned 64-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least eight elements that is writable
 *               from the calling context.
 *  \spec
 *    requires   $lengthOf(dst) >= 8;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint64ToUint8ArrayBigEndian(
  uint64 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

/**********************************************************************************************************************
 *  VStdLib_ConvertUint64ToUint8ArrayLittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 64-bit value to an unsigned 8-bit array according to little endian.
 *  \details     -
 *  \param[in]   src   The unsigned 64-bit value, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 8-bit array, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'dst' has to point to an unsigned 8-bit array of at least eight elements that is writable
 *               from the calling context.
 *  \spec
 *    requires   $lengthOf(dst) >= 8;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint64ToUint8ArrayLittleEndian(
  uint64 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint64BigEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to an unsigned 64-bit value according to big endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 64-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least eight elements.
 *               The parameter 'dst' has to point to an unsigned 64-bit variable that is writable from the calling
 *               context.
 *  \spec
 *    requires   $lengthOf(src) >= 8;
 *    requires   $lengthOf(dst) >= 1;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint64BigEndian(
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint64, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint64LittleEndian()
 *********************************************************************************************************************/
/*! \brief       Converts the specified unsigned 8-bit array to an unsigned 64-bit value according to little endian.
 *  \details     -
 *  \param[in]   src   Pointer to an unsigned 8-bit array, which shall be converted.
 *  \param[out]  dst   Pointer to an unsigned 64-bit variable, where the conversion result will be stored.
 *  \context     ANY
 *  \reentrant   TRUE for different memory areas defined by parameter 'dst'
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined. This service is implemented
 *               externally if VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         The parameter 'src' has to point to an unsigned 8-bit array of at least eight elements.
 *               The parameter 'dst' has to point to an unsigned 64-bit variable that is writable from the calling
 *               context.
 *  \spec
 *    requires   $lengthOf(src) >= 8;
 *    requires   $lengthOf(dst) >= 1;
 *  \endspec
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint64LittleEndian(
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint64, AUTOMATIC, VSTDLIB_APPL_VAR) dst);

# endif /* defined (PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON) */

# if (VSTDLIB_USE_16BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_SwapEndianUint16()
 *********************************************************************************************************************/
/*! \brief       Swaps the endianness of the specified unsigned 16-bit value.
 *  \details     -
 *  \param[in]   value   Unsigned 16-bit value, whose endianness shall be swapped.
 *  \return      Value in the swapped endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_16BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(uint16, VSTDLIB_CODE) VStdLib_SwapEndianUint16(uint16 value);

# endif /* VSTDLIB_USE_16BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON */

# if (VSTDLIB_USE_32BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_SwapEndianUint32()
 *********************************************************************************************************************/
/*! \brief       Swaps the endianness of the specified unsigned 32-bit value.
 *  \details     -
 *  \param[in]   value   Unsigned 32-bit value, whose endianness shall be swapped.
 *  \return      Value in the swapped endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is implemented externally if VSTDLIB_USE_32BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(uint32, VSTDLIB_CODE) VStdLib_SwapEndianUint32(uint32 value);

# endif /* VSTDLIB_USE_32BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON */

# if (defined (PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON))

/**********************************************************************************************************************
 *  VStdLib_SwapEndianUint64()
 *********************************************************************************************************************/
/*! \brief       Swaps the endianness of the specified unsigned 64-bit value.
 *  \details     -
 *  \param[in]   value   Unsigned 64-bit value, whose endianness shall be swapped.
 *  \return      Value in the swapped endianness.
 *  \context     ANY
 *  \reentrant   TRUE
 *  \synchronous TRUE
 *  \config      This service is only available if PLATFORM_SUPPORT_SINT64_UINT64 is defined.This service is implemented
 *               externally if VSTDLIB_USE_64BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS == STD_ON.
 *  \pre         -
 *********************************************************************************************************************/
VSTDLIB_LOCAL_INLINE FUNC(uint64, VSTDLIB_CODE) VStdLib_SwapEndianUint64(uint64 value);

# endif /* defined (PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON) */

# define VSTDLIB_STOP_SEC_CODE
# include "MemMap.h" /* PRQA S 5087 */ /* MD_MSR_MemMap */

/**********************************************************************************************************************
 *  GLOBAL FUNCTIONS
 *********************************************************************************************************************/
# define VSTDLIB_START_SEC_CODE
# include "MemMap.h" /* PRQA S 5087 */ /* MD_MSR_MemMap */

# if( VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_ConvertUint16ToUint8ArrayBigEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint16ToUint8ArrayBigEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  uint16 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameter 'dst' */
  if(dst == NULL_PTR)
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert unsigned 16-bit value to big endian byte array */
#  if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, &src, 2u); /* PRQA S 0315, 1340 */ /* MD_MSR_VStdLibCopy, MD_VStdLib_Para2ConstPtr */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    dst[0u] = (uint8)((src & 0xFF00u) >>  8u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[1u] = (uint8)( src & 0x00FFu);         /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
#  endif /* CPU_BYTE_ORDER == HIGH_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_UINT16_TO_ARRAY_BE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

/**********************************************************************************************************************
 *  VStdLib_ConvertUint16ToUint8ArrayLittleEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint16ToUint8ArrayLittleEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  uint16 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameter 'dst' */
  if(dst == NULL_PTR)
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert unsigned 16-bit value to lillte endian byte array */
#  if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, &src, 2u); /* PRQA S 0315, 1340 */ /* MD_MSR_VStdLibCopy, MD_VStdLib_Para2ConstPtr */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    dst[0u] = (uint8)( src & 0x00FFu);         /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[1u] = (uint8)((src & 0xFF00u) >>  8u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
#  endif /* CPU_BYTE_ORDER == LOW_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_UINT16_TO_ARRAY_LE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint16BigEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint16BigEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint16, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameter 'dst' */
  if((src == NULL_PTR) || (dst == NULL_PTR))
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert big endian byte array to unsigned 16-bit value */
#  if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, src, 2u); /* PRQA S 0315 */ /* MD_MSR_VStdLibCopy */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    (*dst) = (uint16)((((uint16)src[0u]) << 8u) |/* SBSW_VSTDLIB_ACCESS_PASSED_INT */
                      ((uint16)src[1u]));
#  endif /* CPU_BYTE_ORDER == HIGH_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_ARRAY_TO_UINT16_BE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint16LittleEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint16LittleEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint16, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameters 'src' and 'dst' */
  if((src == NULL_PTR) || (dst == NULL_PTR))
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert lillte endian byte array to unsigned 16-bit value */
#  if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, src, 2u); /* PRQA S 0315 */ /* MD_MSR_VStdLibCopy */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    (*dst) = (uint16)(((uint16)src[0u]) | /* SBSW_VSTDLIB_ACCESS_PASSED_INT */
                      (((uint16)src[1u]) <<  8u));
#  endif /* CPU_BYTE_ORDER == LOW_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_ARRAY_TO_UINT16_LE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

# endif /* VSTDLIB_USE_16BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON */

# if (VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_ConvertUint32ToUint8ArrayBigEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint32ToUint8ArrayBigEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  uint32 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameter 'dst' */
  if(dst == NULL_PTR)
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert unsigned 32-bit value to big endian byte array */
#  if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, &src, 4u); /* PRQA S 0315, 1340 */ /* MD_MSR_VStdLibCopy, MD_VStdLib_Para2ConstPtr */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    dst[0u] = (uint8)((src & 0xFF000000u) >> 24u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[1u] = (uint8)((src & 0x00FF0000u) >> 16u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[2u] = (uint8)((src & 0x0000FF00u) >>  8u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[3u] = (uint8)( src & 0x000000FFu);         /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
#  endif /* CPU_BYTE_ORDER == HIGH_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_UINT32_TO_ARRAY_BE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

/**********************************************************************************************************************
 *  VStdLib_ConvertUint32ToUint8ArrayLittleEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint32ToUint8ArrayLittleEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  uint32 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameter 'dst' */
  if(dst == NULL_PTR)
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert unsigned 32-bit value to lillte endian byte array */
#  if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, &src, 4u); /* PRQA S 0315, 1340 */ /* MD_MSR_VStdLibCopy, MD_VStdLib_Para2ConstPtr */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    dst[0u] = (uint8)( src & 0x000000FFu);         /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[1u] = (uint8)((src & 0x0000FF00u) >>  8u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[2u] = (uint8)((src & 0x00FF0000u) >> 16u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[3u] = (uint8)((src & 0xFF000000u) >> 24u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
#  endif /* CPU_BYTE_ORDER == LOW_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_UINT32_TO_ARRAY_LE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint32BigEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint32BigEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint32, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameters 'src' and 'dst' */
  if((src == NULL_PTR) || (dst == NULL_PTR))
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert big endian byte array to unsigned 32-bit value */
#  if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, src, 4u); /* PRQA S 0315 */ /* MD_MSR_VStdLibCopy */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    (*dst) = (uint32)((((uint32)src[0u]) << 24u) | /* SBSW_VSTDLIB_ACCESS_PASSED_INT */
                      (((uint32)src[1u]) << 16u) |
                      (((uint32)src[2u]) <<  8u) |
                      ((uint32)src[3u])
                     );
#  endif /* CPU_BYTE_ORDER == HIGH_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_ARRAY_TO_UINT32_BE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint32LittleEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint32LittleEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint32, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameters 'src' and 'dst' */
  if((src == NULL_PTR) || (dst == NULL_PTR))
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert lillte endian byte array to unsigned 32-bit value */
#  if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, src, 4u); /* PRQA S 0315 */ /* MD_MSR_VStdLibCopy */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    (*dst) = (uint32)( ((uint32)src[0u])         | /* SBSW_VSTDLIB_ACCESS_PASSED_INT */
                      (((uint32)src[1u]) <<  8u) |
                      (((uint32)src[2u]) << 16u) |
                      (((uint32)src[3u]) << 24u)
                     );
#  endif /* CPU_BYTE_ORDER == LOW_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_ARRAY_TO_UINT32_LE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

# endif /* VSTDLIB_USE_32BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON */

# if (defined (PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON))

/**********************************************************************************************************************
 *  VStdLib_ConvertUint64ToUint8ArrayBigEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint64ToUint8ArrayBigEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  uint64 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameter 'dst' */
  if(dst == NULL_PTR)
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert unsigned 64-bit value to big endian byte array */
#  if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, &src, 8u); /* PRQA S 0315, 1340 */ /* MD_MSR_VStdLibCopy, MD_VStdLib_Para2ConstPtr */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    dst[0u] = (uint8)((src & 0xFF00000000000000uLL) >> 56u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[1u] = (uint8)((src & 0x00FF000000000000uLL) >> 48u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[2u] = (uint8)((src & 0x0000FF0000000000uLL) >> 40u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[3u] = (uint8)((src & 0x000000FF00000000uLL) >> 32u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[4u] = (uint8)((src & 0x00000000FF000000uLL) >> 24u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[5u] = (uint8)((src & 0x0000000000FF0000uLL) >> 16u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[6u] = (uint8)((src & 0x000000000000FF00uLL) >>  8u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[7u] = (uint8)( src & 0x00000000000000FFuLL);         /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
#  endif /* CPU_BYTE_ORDER == HIGH_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_UINT64_TO_ARRAY_BE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

/**********************************************************************************************************************
 *  VStdLib_ConvertUint64ToUint8ArrayLittleEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint64ToUint8ArrayLittleEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  uint64 src,
  P2VAR(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameter 'dst' */
  if(dst == NULL_PTR)
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert unsigned 64-bit value to lillte endian byte array */
#  if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, &src, 8u); /* PRQA S 0315, 1340 */ /* MD_MSR_VStdLibCopy, MD_VStdLib_Para2ConstPtr */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    dst[0u] = (uint8)( src & 0x00000000000000FFuLL);         /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[1u] = (uint8)((src & 0x000000000000FF00uLL) >>  8u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[2u] = (uint8)((src & 0x0000000000FF0000uLL) >> 16u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[3u] = (uint8)((src & 0x00000000FF000000uLL) >> 24u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[4u] = (uint8)((src & 0x000000FF00000000uLL) >> 32u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[5u] = (uint8)((src & 0x0000FF0000000000uLL) >> 40u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[6u] = (uint8)((src & 0x00FF000000000000uLL) >> 48u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
    dst[7u] = (uint8)((src & 0xFF00000000000000uLL) >> 56u); /* SBSW_VSTDLIB_ACCESS_PASSED_ARRAY */
#  endif /* CPU_BYTE_ORDER == LOW_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_UINT64_TO_ARRAY_LE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint64BigEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint64BigEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint64, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameters 'src' and 'dst' */
  if((src == NULL_PTR) || (dst == NULL_PTR))
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert big endian byte array to unsigned 64-bit value */
#  if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, src, 8u); /* PRQA S 0315 */ /* MD_MSR_VStdLibCopy */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    (*dst) = (uint64)((((uint64)src[0u]) << 56u) | /* SBSW_VSTDLIB_ACCESS_PASSED_INT */
                      (((uint64)src[1u]) << 48u) |
                      (((uint64)src[2u]) << 40u) |
                      (((uint64)src[3u]) << 32u) |
                      (((uint64)src[4u]) << 24u) |
                      (((uint64)src[5u]) << 16u) |
                      (((uint64)src[6u]) <<  8u) |
                       ((uint64)src[7u])
                     );
#  endif /* CPU_BYTE_ORDER == HIGH_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_ARRAY_TO_UINT64_BE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

/**********************************************************************************************************************
 *  VStdLib_ConvertUint8ArrayToUint64LittleEndian()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(void, VSTDLIB_CODE) VStdLib_ConvertUint8ArrayToUint64LittleEndian( /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
  P2CONST(uint8, AUTOMATIC, VSTDLIB_APPL_VAR) src,
  P2VAR(uint64, AUTOMATIC, VSTDLIB_APPL_VAR) dst)
{
  /* ----- Local Variables ---------------------------------------------- */
  uint8 errorId = VSTDLIB_E_NO_ERROR;

  /* ----- Development Error Checks ------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_DETECT == STD_ON)
  /* #10 Check parameters 'src' and 'dst' */
  if((src == NULL_PTR) || (dst == NULL_PTR))
  {
    errorId = VSTDLIB_E_PARAM_POINTER;
  }
  else
#  endif
  {
    /* ----- Implementation ----------------------------------------------- */
    /* #100 Convert lillte endian byte array to unsigned 64-bit value */
#  if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
    /* Optimization possible, if target platform optimized VStdLib_MemCpy() is used */
    VStdLib_MemCpy(dst, src, 8u); /* PRQA S 0315 */ /* MD_MSR_VStdLibCopy */ /* SBSW_VSTDLIB_CALL_MEM_CPY */
#  else
    (*dst) = (uint64)( ((uint64)src[0u])         | /* SBSW_VSTDLIB_ACCESS_PASSED_INT */
                      (((uint64)src[1u]) <<  8u) |
                      (((uint64)src[2u]) << 16u) |
                      (((uint64)src[3u]) << 24u) |
                      (((uint64)src[4u]) << 32u) |
                      (((uint64)src[5u]) << 40u) |
                      (((uint64)src[6u]) << 48u) |
                      (((uint64)src[7u]) << 56u)
                     );
#  endif /* CPU_BYTE_ORDER == LOW_BYTE_FIRST */
  }

  /* ----- Development Error Report --------------------------------------- */
#  if (VSTDLIB_DEV_ERROR_REPORT == STD_ON)
  if(errorId != VSTDLIB_E_NO_ERROR)
  {
    (void)Det_ReportError(VSTDLIB_MODULE_ID, VSTDLIB_INSTANCE_ID_DET, VSTDLIB_SID_CNV_ARRAY_TO_UINT64_LE, errorId);
  }
#  else
  VSTDLIB_DUMMY_STATEMENT(errorId); /* PRQA S 1338, 2983, 3122 */ /* MD_MSR_DummyStmt */
#  endif
}

# endif /* defined (PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_DE_SERIALIZATION_LIBRARY_FUNCTIONS != STD_ON) */

# if (VSTDLIB_USE_16BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_SwapEndianUint16()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(uint16, VSTDLIB_CODE) VStdLib_SwapEndianUint16(uint16 value) /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
{
  /* ----- Implementation ----------------------------------------------- */

  /* #100 Swap endianness */
  return (uint16)(((value & 0xFF00u) >> 8u) | ((value & 0x00FFu) << 8u));
}

# endif /* VSTDLIB_USE_16BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON */

# if (VSTDLIB_USE_32BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON)

/**********************************************************************************************************************
 *  VStdLib_SwapEndianUint32()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(uint32, VSTDLIB_CODE) VStdLib_SwapEndianUint32(uint32 value) /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
{
  /* ----- Implementation ----------------------------------------------- */

  /* #100 Swap endianness */
  return (uint32)(((value & 0xFF000000u) >> 24u) | /* 3 to 0 */
                  ((value & 0x00FF0000u) >>  8u) | /* 2 to 1 */
                  ((value & 0x0000FF00u) <<  8u) | /* 1 to 2 */
                  ((value & 0x000000FFu) << 24u)   /* 0 to 3 */
                 );
}

# endif /* VSTDLIB_USE_32BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON */

# if (defined (PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON))

/**********************************************************************************************************************
 *  VStdLib_SwapEndianUint64()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(uint64, VSTDLIB_CODE) VStdLib_SwapEndianUint64(uint64 value) /* PRQA S 3219 */ /* MD_VStdLib_NotUsedInUnit */
{
  /* ----- Implementation ----------------------------------------------- */

  /* #100 Swap endianness */
  return (uint64)(((value & 0xFF00000000000000uLL) >> 56u) | /* 7 to 0 */
                  ((value & 0x00FF000000000000uLL) >> 40u) | /* 6 to 1 */
                  ((value & 0x0000FF0000000000uLL) >> 24u) | /* 5 to 2 */
                  ((value & 0x000000FF00000000uLL) >>  8u) | /* 4 to 3 */
                  ((value & 0x00000000FF000000uLL) <<  8u) | /* 3 to 4 */
                  ((value & 0x0000000000FF0000uLL) << 24u) | /* 2 to 5 */
                  ((value & 0x000000000000FF00uLL) << 40u) | /* 1 to 6 */
                  ((value & 0x00000000000000FFuLL) << 56u)   /* 0 to 7 */
                 );
}

# endif /* defined (PLATFORM_SUPPORT_SINT64_UINT64) && (VSTDLIB_USE_64BIT_ENDIAN_CONVERSION_LIBRARY_FUNCTIONS != STD_ON) */

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianPlatformToBig_s()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_MemCpyEndianPlatformToBig_s( /* PRQA S 3219, 6060 */ /* MD_VStdLib_NotUsedInUnit, MD_MSR_STPAR */
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nCnt,
  uint8 intType,
  Std_ReturnType errorCode)
{
# if (CPU_BYTE_ORDER == HIGH_BYTE_FIRST)
  /* #10 Call VStdLib_MemCpy_Return_s() */
  VSTDLIB_DUMMY_STATEMENT(intType); /* PRQA S 2983, 3112 */ /* MD_MSR_DummyStmt */
  return VStdLib_MemCpy_Return_s(pDst, nDstSize, pSrc, nCnt, errorCode); /* SBSW_VSTDLIB_CALL_UNMODIFIED */

# else /* CPU_BYTE_ORDER == LOW_BYTE_FIRST) */
  /* #20 Call VStdLib_MemCpySwapEndian_s() */
  return VStdLib_MemCpySwapEndian_s(pDst, nDstSize, pSrc, nCnt, intType, errorCode); /* SBSW_VSTDLIB_CALL_UNMODIFIED */
# endif /* CPU_BYTE_ORDER */
}

/**********************************************************************************************************************
 *  VStdLib_MemCpyEndianPlatformToLittle_s()
 *********************************************************************************************************************/
/*!
 * Internal comment removed.
 *
 *
 *
 *
 *
 */
VSTDLIB_LOCAL_INLINE FUNC(Std_ReturnType, VSTDLIB_CODE) VStdLib_MemCpyEndianPlatformToLittle_s( /* PRQA S 3219, 6060 */ /* MD_VStdLib_NotUsedInUnit, MD_MSR_STPAR */
  P2VAR(void, AUTOMATIC, VSTDLIB_VAR_FAR) pDst,
  VStdLib_CntType nDstSize,
  P2CONST(void, AUTOMATIC, VSTDLIB_VAR_FAR) pSrc,
  VStdLib_CntType nCnt,
  uint8 intType,
  Std_ReturnType errorCode)
{
# if (CPU_BYTE_ORDER == LOW_BYTE_FIRST)
  /* #10 Call VStdLib_MemCpy_Return_s() */
  VSTDLIB_DUMMY_STATEMENT(intType); /* PRQA S 2983, 3112 */ /* MD_MSR_DummyStmt */
  return VStdLib_MemCpy_Return_s(pDst, nDstSize, pSrc, nCnt, errorCode); /* SBSW_VSTDLIB_CALL_UNMODIFIED */

# else /* CPU_BYTE_ORDER == HIGH_BYTE_FIRST) */
  /* #20 Call VStdLib_MemCpySwapEndian_s() */
  return VStdLib_MemCpySwapEndian_s(pDst, nDstSize, pSrc, nCnt, intType, errorCode); /* SBSW_VSTDLIB_CALL_UNMODIFIED */
# endif /* CPU_BYTE_ORDER */
}

# define VSTDLIB_STOP_SEC_CODE
# include "MemMap.h" /* PRQA S 5087 */ /* MD_MSR_MemMap */

/**********************************************************************************************************************
 *  COMPATIBILITY MACROS
 *********************************************************************************************************************/

# define VSTDLIB__COREHLL_VERSION            (0x0308u) /* last core version this component was based on */
# define VSTDLIB__COREHLL_RELEASE_VERSION    (0x00u)
# define VSTDLIB_GENERICASR_VERSION          ((VSTDLIB_SW_MAJOR_VERSION << 8u) | VSTDLIB_SW_MINOR_VERSION)
# define VSTDLIB_GENERICASR_RELEASE_VERSION  VSTDLIB_SW_PATCH_VERSION
# define kVStdMainVersion                    VSTDLIB_SW_MAJOR_VERSION
# define kVStdSubVersion                     VSTDLIB_SW_MINOR_VERSION
# define kVStdReleaseVersion                 VSTDLIB_SW_PATCH_VERSION

# define kVStdErrorIntDisableTooOften        (0x01u)
# define kVStdErrorIntRestoreTooOften        (0x02u)
# define kVStdErrorMemClrInvalidParameter    (0x03u)
# define kVStdErrorMemCpyInvalidParameter    (0x04u)
# define kVStdErrorFunctionNotSupportedByHw  (0x05u)
# define kVStdErrorMemSetInvalidParameter    (0x06u)
# define kVStdErrorUnexpectedLockState       (0x07u)

# define VSTD_HL_DISABLE_SUPPORT_MEM_FCT
# define VSTD_HL_DISABLE_MEM_FCT_MAPPING
# define VSTD_HL_USE_VSTD_MEMCLR
# define VSTD_HL_USE_VSTD_MEMSET
# define VSTD_HL_USE_VSTD_RAMMEMCPY
# define VSTD_HL_USE_VSTD_ROMMEMCPY
# define VSTD_HL_USE_VSTD_WORD_MEMCPY
# define VSTD_HL_USE_VSTD_DWORD_MEMCPY

# define VStdInitPowerOn()

/* PRQA S 3453 VSTDLIB_FUNCTION_LIKE_MACRO */ /* MD_MSR_FctLikeMacro */

# if !defined (VStdLib_MemCpyRom)
#  define VStdLib_MemCpyRom(d, s, c)         VStdLib_MemCpy((d), (s), (c))
# endif

# define VStdMemClr(d, c)                    VStdLib_MemClr((d), (c))
# define VStdMemNearClr(d, c)                VStdLib_MemClr((d), (c))
# define VStdMemFarClr(d, c)                 VStdLib_MemClr((d), (c))
# define VStdMemSet(d, p, c)                 VStdLib_MemSet((d), (p), (c))
# define VStdMemNearSet(d, p, c)             VStdLib_MemSet((d), (p), (c))
# define VStdMemFarSet(d, p, c)              VStdLib_MemSet((d), (p), (c))

# define VStdMemCpy(d, s, c)                 VStdLib_MemCpy((d), (s), (c))
# define VStdMemCpyRom(d, s, c)              VStdLib_MemCpyRom((d), (s), (c))
# define VStdMemCpyRamToRam(d, s, c)         VStdLib_MemCpy((d), (s), (c))
# define VStdMemCpyRomToRam(d, s, c)         VStdLib_MemCpyRom((d), (s), (c))
# define VStdMemCpyRamToNearRam(d, s, c)     VStdLib_MemCpy((d), (s), (c))
# define VStdMemCpyRomToNearRam(d, s, c)     VStdLib_MemCpyRom((d), (s), (c))
# define VStdMemCpyRamToFarRam(d, s, c)      VStdLib_MemCpy((d), (s), (c))
# define VStdMemCpyRomToFarRam(d, s, c)      VStdLib_MemCpyRom((d), (s), (c))
# define VStdMemCpyFarRamToRam(d, s, c)      VStdLib_MemCpy((d), (s), (c))
# define VStdMemCpyFarRamToFarRam(d, s, c)   VStdLib_MemCpy((d), (s), (c))
# define VStdMemCpyFarRomToFarRam(d, s, c)   VStdLib_MemCpyRom((d), (s), (c))
# define VStdRamMemCpy(d, s, c)              VStdLib_MemCpy((d), (s), (c))
# define VStdRomMemCpy(d, s, c)              VStdLib_MemCpyRom((d), (s), (c))

# define VStdMemCpy16(d, s, c)               VStdLib_MemCpy16((d), (s), (c))
# define VStdMemCpy16RamToRam(d, s, c)       VStdLib_MemCpy16((d), (s), (c))
# define VStdMemCpy16RamToNearRam(d, s, c)   VStdLib_MemCpy16((d), (s), (c))
# define VStdMemCpy16NearRamToRam(d, s, c)   VStdLib_MemCpy16((d), (s), (c))
# define VStdMemCpy16RamToFarRam(d, s, c)    VStdLib_MemCpy16((d), (s), (c))
# define VStdMemCpy16FarRamToRam(d, s, c)    VStdLib_MemCpy16((d), (s), (c))
# define VStdRamMemCpy16(d, s, c)            VStdLib_MemCpy16((d), (s), (c))

# define VStdMemCpy32(d, s, c)               VStdLib_MemCpy32((d), (s), (c))
# define VStdMemCpy32RamToRam(d, s, c)       VStdLib_MemCpy32((d), (s), (c))
# define VStdMemCpy32RamToNearRam(d, s, c)   VStdLib_MemCpy32((d), (s), (c))
# define VStdMemCpy32NearRamToRam(d, s, c)   VStdLib_MemCpy32((d), (s), (c))
# define VStdMemCpy32RamToFarRam(d, s, c)    VStdLib_MemCpy32((d), (s), (c))
# define VStdMemCpy32FarRamToRam(d, s, c)    VStdLib_MemCpy32((d), (s), (c))
# define VStdRamMemCpy32(d, s, c)            VStdLib_MemCpy32((d), (s), (c))

# if !defined (VStdLib_MemCpyRomMacro)
#  define VStdLib_MemCpyRomMacro(d, s, c)    VStdLib_MemCpyMacro((d), (s), (c))
# endif

# define VStdMemClr_Macro(d, c)              VStdLib_MemClrMacro((d), (c))
# define VStdMemSet_Macro(d, p, c)           VStdLib_MemSetMacro((d), (p), (c))
# define VStdMemCpy_Macro(d, s, c)           VStdLib_MemCpyMacro((d), (s), (c))
# define VStdMemCpyRom_Macro(d, s, c)        VStdLib_MemCpyRomMacro((d), (s), (c))

/* PRQA L:VSTDLIB_FUNCTION_LIKE_MACRO */

#endif /* VSTDLIB_H */

/**********************************************************************************************************************
 *  END OF FILE: vstdlib.h
 *********************************************************************************************************************/
