mirror of
https://github.com/FreeRTOS/FreeRTOS-Kernel.git
synced 2025-08-30 23:18:37 -04:00
Add the Labs projects provided in the V10.2.1_191129 zip file.
This commit is contained in:
Richard Barry
parent
46e5937529
commit
e5708b38e9
801 changed files with 356576 additions and 0 deletions
|
|
@ -0,0 +1,547 @@
|
|||
/*
|
||||
* FreeRTOS Kernel V10.2.0
|
||||
* Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://www.FreeRTOS.org
|
||||
* http://aws.amazon.com/freertos
|
||||
*
|
||||
* 1 tab == 4 spaces!
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file atomic.h
|
||||
* @brief FreeRTOS atomic operation support.
|
||||
*
|
||||
* Two implementations of atomic are given in this header file:
|
||||
* 1. Disabling interrupt globally.
|
||||
* 2. ISA native atomic support.
|
||||
* The former is available to all ports (compiler-architecture combination),
|
||||
* while the latter is only available to ports compiling with GCC (version at
|
||||
* least 4.7.0), which also have ISA atomic support.
|
||||
*
|
||||
* User can select which implementation to use by:
|
||||
* setting/clearing configUSE_ATOMIC_INSTRUCTION in FreeRTOSConfig.h.
|
||||
* Define AND set configUSE_ATOMIC_INSTRUCTION to 1 for ISA native atomic support.
|
||||
* Undefine OR clear configUSE_ATOMIC_INSTRUCTION for disabling global interrupt
|
||||
* implementation.
|
||||
*
|
||||
* @see GCC Built-in Functions for Memory Model Aware Atomic Operations
|
||||
* https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
|
||||
*/
|
||||
|
||||
#ifndef ATOMIC_H
|
||||
#define ATOMIC_H
|
||||
|
||||
#ifndef INC_FREERTOS_H
|
||||
#error "include FreeRTOS.h must appear in source files before include atomic.h"
|
||||
#endif
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
/* Needed for __atomic_compare_exchange() weak=false. */
|
||||
#include <stdbool.h>
|
||||
|
||||
/* This branch is for GCC compiler and GCC compiler only. */
|
||||
#ifndef portFORCE_INLINE
|
||||
#define portFORCE_INLINE inline __attribute__((always_inline))
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
/* Port specific definitions -- entering/exiting critical section.
|
||||
* Refer template -- ./lib/FreeRTOS/portable/Compiler/Arch/portmacro.h
|
||||
*
|
||||
* Every call to ATOMIC_EXIT_CRITICAL() must be closely paired with
|
||||
* ATOMIC_ENTER_CRITICAL().
|
||||
*/
|
||||
#if defined( portSET_INTERRUPT_MASK_FROM_ISR )
|
||||
|
||||
/* Nested interrupt scheme is supported in this port. */
|
||||
#define ATOMIC_ENTER_CRITICAL() \
|
||||
UBaseType_t uxCriticalSectionType = portSET_INTERRUPT_MASK_FROM_ISR()
|
||||
|
||||
#define ATOMIC_EXIT_CRITICAL() \
|
||||
portCLEAR_INTERRUPT_MASK_FROM_ISR( uxCriticalSectionType )
|
||||
|
||||
#else
|
||||
|
||||
/* Nested interrupt scheme is NOT supported in this port. */
|
||||
#define ATOMIC_ENTER_CRITICAL() portENTER_CRITICAL()
|
||||
#define ATOMIC_EXIT_CRITICAL() portEXIT_CRITICAL()
|
||||
|
||||
#endif /* portSET_INTERRUPT_MASK_FROM_ISR() */
|
||||
|
||||
/* Port specific definition -- "always inline".
|
||||
* Inline is compiler specific, and may not always get inlined depending on your optimization level.
|
||||
* Also, inline is considered as performance optimization for atomic.
|
||||
* Thus, if portFORCE_INLINE is not provided by portmacro.h, instead of resulting error,
|
||||
* simply define it.
|
||||
*/
|
||||
#ifndef portFORCE_INLINE
|
||||
#define portFORCE_INLINE
|
||||
#endif
|
||||
|
||||
#endif /* configUSE_GCC_BUILTIN_ATOMICS */
|
||||
|
||||
#define ATOMIC_COMPARE_AND_SWAP_SUCCESS 0x1U /**< Compare and swap succeeded, swapped. */
|
||||
#define ATOMIC_COMPARE_AND_SWAP_FAILURE 0x0U /**< Compare and swap failed, did not swap. */
|
||||
|
||||
/*----------------------------- Swap && CAS ------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic compare-and-swap
|
||||
*
|
||||
* @brief Performs an atomic compare-and-swap operation on the specified values.
|
||||
*
|
||||
* @param[in, out] pDestination Pointer to memory location from where value is
|
||||
* to be loaded and checked.
|
||||
* @param[in] ulExchange If condition meets, write this value to memory.
|
||||
* @param[in] ulComparand Swap condition.
|
||||
*
|
||||
* @return Unsigned integer of value 1 or 0. 1 for swapped, 0 for not swapped.
|
||||
*
|
||||
* @note This function only swaps *pDestination with ulExchange, if previous
|
||||
* *pDestination value equals ulComparand.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_CompareAndSwap_u32(
|
||||
uint32_t volatile * pDestination,
|
||||
uint32_t ulExchange,
|
||||
uint32_t ulComparand )
|
||||
{
|
||||
|
||||
uint32_t ulReturnValue = ATOMIC_COMPARE_AND_SWAP_FAILURE;
|
||||
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
if ( __atomic_compare_exchange( pDestination,
|
||||
&ulComparand,
|
||||
&ulExchange,
|
||||
false,
|
||||
__ATOMIC_SEQ_CST,
|
||||
__ATOMIC_SEQ_CST ) )
|
||||
{
|
||||
ulReturnValue = ATOMIC_COMPARE_AND_SWAP_SUCCESS;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
if ( *pDestination == ulComparand )
|
||||
{
|
||||
*pDestination = ulExchange;
|
||||
ulReturnValue = ATOMIC_COMPARE_AND_SWAP_SUCCESS;
|
||||
}
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
#endif
|
||||
|
||||
return ulReturnValue;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Atomic swap (pointers)
|
||||
*
|
||||
* @brief Atomically sets the address pointed to by *ppDestination to the value
|
||||
* of *pExchange.
|
||||
*
|
||||
* @param[in, out] ppDestination Pointer to memory location from where a pointer
|
||||
* value is to be loaded and written back to.
|
||||
* @param[in] pExchange Pointer value to be written to *ppDestination.
|
||||
*
|
||||
* @return The initial value of *ppDestination.
|
||||
*/
|
||||
static portFORCE_INLINE void * Atomic_SwapPointers_p32(
|
||||
void * volatile * ppDestination,
|
||||
void * pExchange )
|
||||
{
|
||||
void * pReturnValue;
|
||||
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
__atomic_exchange( ppDestination, &pExchange, &pReturnValue, __ATOMIC_SEQ_CST );
|
||||
|
||||
#else
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
pReturnValue = *ppDestination;
|
||||
|
||||
*ppDestination = pExchange;
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
#endif
|
||||
|
||||
return pReturnValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Atomic compare-and-swap (pointers)
|
||||
*
|
||||
* @brief Performs an atomic compare-and-swap operation on the specified pointer
|
||||
* values.
|
||||
*
|
||||
* @param[in, out] ppDestination Pointer to memory location from where a pointer
|
||||
* value is to be loaded and checked.
|
||||
* @param[in] pExchange If condition meets, write this value to memory.
|
||||
* @param[in] pComparand Swap condition.
|
||||
*
|
||||
* @return Unsigned integer of value 1 or 0. 1 for swapped, 0 for not swapped.
|
||||
*
|
||||
* @note This function only swaps *ppDestination with pExchange, if previous
|
||||
* *ppDestination value equals pComparand.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_CompareAndSwapPointers_p32(
|
||||
void * volatile * ppDestination,
|
||||
void * pExchange, void * pComparand )
|
||||
{
|
||||
uint32_t ulReturnValue = ATOMIC_COMPARE_AND_SWAP_FAILURE;
|
||||
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
if ( __atomic_compare_exchange( ppDestination,
|
||||
&pComparand,
|
||||
&pExchange,
|
||||
false,
|
||||
__ATOMIC_SEQ_CST,
|
||||
__ATOMIC_SEQ_CST ) )
|
||||
{
|
||||
ulReturnValue = ATOMIC_COMPARE_AND_SWAP_SUCCESS;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
if ( *ppDestination == pComparand )
|
||||
{
|
||||
*ppDestination = pExchange;
|
||||
ulReturnValue = ATOMIC_COMPARE_AND_SWAP_SUCCESS;
|
||||
}
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
#endif
|
||||
|
||||
return ulReturnValue;
|
||||
}
|
||||
|
||||
|
||||
/*----------------------------- Arithmetic ------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic add
|
||||
*
|
||||
* @brief Atomically adds count to the value of the specified pointer points to.
|
||||
*
|
||||
* @param[in,out] pAddend Pointer to memory location from where value is to be
|
||||
* loaded and written back to.
|
||||
* @param[in] ulCount Value to be added to *pAddend.
|
||||
*
|
||||
* @return previous *pAddend value.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_Add_u32(
|
||||
uint32_t volatile * pAddend,
|
||||
uint32_t ulCount )
|
||||
{
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
return __atomic_fetch_add(pAddend, ulCount, __ATOMIC_SEQ_CST);
|
||||
|
||||
#else
|
||||
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
ulCurrent = *pAddend;
|
||||
|
||||
*pAddend += ulCount;
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Atomic subtract
|
||||
*
|
||||
* @brief Atomically subtracts count from the value of the specified pointer
|
||||
* pointers to.
|
||||
*
|
||||
* @param[in,out] pAddend Pointer to memory location from where value is to be
|
||||
* loaded and written back to.
|
||||
* @param[in] ulCount Value to be subtract from *pAddend.
|
||||
*
|
||||
* @return previous *pAddend value.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_Subtract_u32(
|
||||
uint32_t volatile * pAddend,
|
||||
uint32_t ulCount )
|
||||
{
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
return __atomic_fetch_sub(pAddend, ulCount, __ATOMIC_SEQ_CST);
|
||||
|
||||
#else
|
||||
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
ulCurrent = *pAddend;
|
||||
|
||||
*pAddend -= ulCount;
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Atomic increment
|
||||
*
|
||||
* @brief Atomically increments the value of the specified pointer points to.
|
||||
*
|
||||
* @param[in,out] pAddend Pointer to memory location from where value is to be
|
||||
* loaded and written back to.
|
||||
*
|
||||
* @return *pAddend value before increment.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_Increment_u32( uint32_t volatile * pAddend )
|
||||
{
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
return __atomic_fetch_add(pAddend, 1, __ATOMIC_SEQ_CST);
|
||||
|
||||
#else
|
||||
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
ulCurrent = *pAddend;
|
||||
|
||||
*pAddend += 1;
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Atomic decrement
|
||||
*
|
||||
* @brief Atomically decrements the value of the specified pointer points to
|
||||
*
|
||||
* @param[in,out] pAddend Pointer to memory location from where value is to be
|
||||
* loaded and written back to.
|
||||
*
|
||||
* @return *pAddend value before decrement.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_Decrement_u32( uint32_t volatile * pAddend )
|
||||
{
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
return __atomic_fetch_sub(pAddend, 1, __ATOMIC_SEQ_CST);
|
||||
|
||||
#else
|
||||
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
ulCurrent = *pAddend;
|
||||
|
||||
*pAddend -= 1;
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
/*----------------------------- Bitwise Logical ------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic OR
|
||||
*
|
||||
* @brief Performs an atomic OR operation on the specified values.
|
||||
*
|
||||
* @param [in, out] pDestination Pointer to memory location from where value is
|
||||
* to be loaded and written back to.
|
||||
* @param [in] ulValue Value to be ORed with *pDestination.
|
||||
*
|
||||
* @return The original value of *pDestination.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_OR_u32(
|
||||
uint32_t volatile * pDestination,
|
||||
uint32_t ulValue )
|
||||
{
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
return __atomic_fetch_or(pDestination, ulValue, __ATOMIC_SEQ_CST);
|
||||
|
||||
#else
|
||||
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
ulCurrent = *pDestination;
|
||||
|
||||
*pDestination |= ulValue;
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Atomic AND
|
||||
*
|
||||
* @brief Performs an atomic AND operation on the specified values.
|
||||
*
|
||||
* @param [in, out] pDestination Pointer to memory location from where value is
|
||||
* to be loaded and written back to.
|
||||
* @param [in] ulValue Value to be ANDed with *pDestination.
|
||||
*
|
||||
* @return The original value of *pDestination.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_AND_u32(
|
||||
uint32_t volatile * pDestination,
|
||||
uint32_t ulValue )
|
||||
{
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
return __atomic_fetch_and(pDestination, ulValue, __ATOMIC_SEQ_CST);
|
||||
|
||||
#else
|
||||
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
ulCurrent = *pDestination;
|
||||
|
||||
*pDestination &= ulValue;
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Atomic NAND
|
||||
*
|
||||
* @brief Performs an atomic NAND operation on the specified values.
|
||||
*
|
||||
* @param [in, out] pDestination Pointer to memory location from where value is
|
||||
* to be loaded and written back to.
|
||||
* @param [in] ulValue Value to be NANDed with *pDestination.
|
||||
*
|
||||
* @return The original value of *pDestination.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_NAND_u32(
|
||||
uint32_t volatile * pDestination,
|
||||
uint32_t ulValue )
|
||||
{
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
return __atomic_fetch_nand(pDestination, ulValue, __ATOMIC_SEQ_CST);
|
||||
|
||||
#else
|
||||
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
ulCurrent = *pDestination;
|
||||
|
||||
*pDestination = ~(ulCurrent & ulValue);
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Atomic XOR
|
||||
*
|
||||
* @brief Performs an atomic XOR operation on the specified values.
|
||||
*
|
||||
* @param [in, out] pDestination Pointer to memory location from where value is
|
||||
* to be loaded and written back to.
|
||||
* @param [in] ulValue Value to be XORed with *pDestination.
|
||||
*
|
||||
* @return The original value of *pDestination.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_XOR_u32(
|
||||
uint32_t volatile * pDestination,
|
||||
uint32_t ulValue )
|
||||
{
|
||||
#if defined ( configUSE_GCC_BUILTIN_ATOMICS ) && ( configUSE_GCC_BUILTIN_ATOMICS == 1 )
|
||||
|
||||
return __atomic_fetch_xor(pDestination, ulValue, __ATOMIC_SEQ_CST);
|
||||
|
||||
#else
|
||||
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
|
||||
ulCurrent = *pDestination;
|
||||
|
||||
*pDestination ^= ulValue;
|
||||
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ATOMIC_H */
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
/*
|
||||
* Amazon FreeRTOS Common V1.0.0
|
||||
* Copyright (C) 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file iot_atomic.h
|
||||
* @brief Chooses the appropriate atomic operations header.
|
||||
*
|
||||
* On FreeRTOS, this file chooses the atomic header provided with the FreeRTOS
|
||||
* kernel.
|
||||
*/
|
||||
|
||||
#ifndef IOT_ATOMIC_H_
|
||||
#define IOT_ATOMIC_H_
|
||||
|
||||
#include "atomic.h"
|
||||
|
||||
#endif /* ifndef IOT_ATOMIC_H_ */
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
/*
|
||||
* IoT Common V1.1.0
|
||||
* Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file iot_error.h
|
||||
* @brief Provides macros for error checking and function cleanup.
|
||||
*
|
||||
* The macros in this file are generic. They may be customized by each library
|
||||
* by setting the library prefix.
|
||||
*/
|
||||
|
||||
#ifndef IOT_ERROR_H_
|
||||
#define IOT_ERROR_H_
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/**
|
||||
* @brief Declare the status variable and an initial value.
|
||||
*
|
||||
* This macro should be at the beginning of any functions that use cleanup sections.
|
||||
*
|
||||
* @param[in] statusType The type of the status variable for this function.
|
||||
* @param[in] initialValue The initial value to assign to the status variable.
|
||||
*/
|
||||
#define IOT_FUNCTION_ENTRY( statusType, initialValue ) statusType status = initialValue
|
||||
|
||||
/**
|
||||
* @brief Declares the label that begins a cleanup section.
|
||||
*
|
||||
* This macro should be placed at the end of a function and followed by
|
||||
* #IOT_FUNCTION_CLEANUP_END.
|
||||
*/
|
||||
#define IOT_FUNCTION_CLEANUP_BEGIN() iotCleanup:
|
||||
|
||||
/**
|
||||
* @brief Declares the end of a cleanup section.
|
||||
*
|
||||
* This macro should be placed at the end of a function and preceded by
|
||||
* #IOT_FUNCTION_CLEANUP_BEGIN.
|
||||
*/
|
||||
#define IOT_FUNCTION_CLEANUP_END() return status
|
||||
|
||||
/**
|
||||
* @brief Declares an empty cleanup section.
|
||||
*
|
||||
* This macro should be placed at the end of a function to exit on error if no
|
||||
* cleanup is required.
|
||||
*/
|
||||
#define IOT_FUNCTION_EXIT_NO_CLEANUP() IOT_FUNCTION_CLEANUP_BEGIN(); IOT_FUNCTION_CLEANUP_END()
|
||||
|
||||
/**
|
||||
* @brief Jump to the cleanup section.
|
||||
*/
|
||||
#define IOT_GOTO_CLEANUP() goto iotCleanup
|
||||
|
||||
/**
|
||||
* @brief Assign a value to the status variable and jump to the cleanup section.
|
||||
*
|
||||
* @param[in] statusValue The value to assign to the status variable.
|
||||
*/
|
||||
#define IOT_SET_AND_GOTO_CLEANUP( statusValue ) { status = ( statusValue ); IOT_GOTO_CLEANUP(); }
|
||||
|
||||
/**
|
||||
* @brief Jump to the cleanup section if a condition is `false`.
|
||||
*
|
||||
* This macro may be used in place of `assert` to exit a function is a condition
|
||||
* is `false`.
|
||||
*
|
||||
* @param[in] condition The condition to check.
|
||||
*/
|
||||
#define IOT_GOTO_CLEANUP_IF_FALSE( condition ) { if( ( condition ) == false ) { IOT_GOTO_CLEANUP(); } }
|
||||
|
||||
/**
|
||||
* @brief Assign a value to the status variable and jump to the cleanup section
|
||||
* if a condition is `false`.
|
||||
*
|
||||
* @param[in] statusValue The value to assign to the status variable.
|
||||
* @param[in] condition The condition to check.
|
||||
*/
|
||||
#define IOT_SET_AND_GOTO_CLEANUP_IF_FALSE( statusValue, condition ) \
|
||||
if( ( condition ) == false ) \
|
||||
IOT_SET_AND_GOTO_CLEANUP( statusValue )
|
||||
|
||||
/**
|
||||
* @brief Check a condition; if `false`, assign the "Bad parameter" status value
|
||||
* and jump to the cleanup section.
|
||||
*
|
||||
* @param[in] libraryPrefix The library prefix of the status variable.
|
||||
* @param[in] condition The condition to check.
|
||||
*/
|
||||
#define IOT_VALIDATE_PARAMETER( libraryPrefix, condition ) \
|
||||
IOT_SET_AND_GOTO_CLEANUP_IF_FALSE( libraryPrefix ## _BAD_PARAMETER, condition )
|
||||
|
||||
#endif /* ifndef IOT_ERROR_H_ */
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
/*
|
||||
* IoT Common V1.1.0
|
||||
* Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file iot_init.h
|
||||
* @brief Provides function signatures for common initialization and cleanup of
|
||||
* this SDK.
|
||||
*/
|
||||
|
||||
#ifndef IOT_INIT_H_
|
||||
#define IOT_INIT_H_
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdbool.h>
|
||||
|
||||
/**
|
||||
* @brief One-time initialization function for this SDK.
|
||||
*
|
||||
* This function initializes common libraries, such as static memory and task
|
||||
* pool. <b>It must be called once (and only once) before calling any other
|
||||
* function in this SDK.</b> Calling this function more than once without first
|
||||
* calling `IotSdk_Cleanup` may result in a crash.
|
||||
*
|
||||
* @return `true` if initialization succeeded; `false` otherwise. Logs may be
|
||||
* printed in case of failure.
|
||||
*
|
||||
* @warning No thread-safety guarantees are provided for this function.
|
||||
*/
|
||||
bool IotSdk_Init( void );
|
||||
|
||||
/**
|
||||
* @brief One-time deinitialization function for all common libraries.
|
||||
*
|
||||
* This function frees resources taken in `IotSdk_Init`. No other function
|
||||
* in this SDK may be called after calling this function unless `IotSdk_Init`
|
||||
* is called again.
|
||||
*
|
||||
* @warning No thread-safety guarantees are provided for this function.
|
||||
*/
|
||||
void IotSdk_Cleanup( void );
|
||||
|
||||
#endif /* IOT_INIT_H_ */
|
||||
|
|
@ -0,0 +1,956 @@
|
|||
/*
|
||||
* IoT Common V1.1.0
|
||||
* Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file iot_linear_containers.h
|
||||
* @brief Declares and implements doubly-linked lists and queues.
|
||||
*/
|
||||
|
||||
#ifndef IOT_LINEAR_CONTAINERS_H_
|
||||
#define IOT_LINEAR_CONTAINERS_H_
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/**
|
||||
* @defgroup linear_containers_datatypes_listqueue List and queue
|
||||
* @brief Structures that represent a list or queue.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @ingroup linear_containers_datatypes_listqueue
|
||||
* @brief Link member placed in structs of a list or queue.
|
||||
*
|
||||
* All elements in a list or queue must contain one of these members. The macro
|
||||
* #IotLink_Container can be used to calculate the starting address of the
|
||||
* link's container.
|
||||
*/
|
||||
typedef struct IotLink
|
||||
{
|
||||
struct IotLink * pPrevious; /**< @brief Pointer to the previous element. */
|
||||
struct IotLink * pNext; /**< @brief Pointer to the next element. */
|
||||
} IotLink_t;
|
||||
|
||||
/**
|
||||
* @ingroup linear_containers_datatypes_listqueue
|
||||
* @brief Represents a doubly-linked list.
|
||||
*/
|
||||
typedef IotLink_t IotListDouble_t;
|
||||
|
||||
/**
|
||||
* @ingroup linear_containers_datatypes_listqueue
|
||||
* @brief Represents a queue.
|
||||
*/
|
||||
typedef IotLink_t IotDeQueue_t;
|
||||
|
||||
/**
|
||||
* @constantspage{linear_containers,linear containers library}
|
||||
*
|
||||
* @section linear_containers_constants_initializers Linear Containers Initializers
|
||||
* @brief Provides default values for initializing the linear containers data types.
|
||||
*
|
||||
* @snippet this define_linear_containers_initializers
|
||||
*
|
||||
* All user-facing data types of the linear containers library should be initialized
|
||||
* using one of the following.
|
||||
*
|
||||
* @warning Failure to initialize a linear containers data type with the appropriate
|
||||
* initializer may result in a runtime error!
|
||||
* @note The initializers may change at any time in future versions, but their
|
||||
* names will remain the same.
|
||||
*/
|
||||
/* @[define_linear_containers_initializers] */
|
||||
#define IOT_LINK_INITIALIZER { 0 } /**< @brief Initializer for an #IotLink_t. */
|
||||
#define IOT_LIST_DOUBLE_INITIALIZER IOT_LINK_INITIALIZER /**< @brief Initializer for an #IotListDouble_t. */
|
||||
#define IOT_DEQUEUE_INITIALIZER IOT_LINK_INITIALIZER /**< @brief Initializer for an #IotDeQueue_t. */
|
||||
/* @[define_linear_containers_initializers] */
|
||||
|
||||
/**
|
||||
* @def IotContainers_Assert( expression )
|
||||
* @brief Assertion macro for the linear containers library.
|
||||
*
|
||||
* Set @ref IOT_CONTAINERS_ENABLE_ASSERTS to `1` to enable assertions in the linear
|
||||
* containers library.
|
||||
*
|
||||
* @param[in] expression Expression to be evaluated.
|
||||
*/
|
||||
#if IOT_CONTAINERS_ENABLE_ASSERTS == 1
|
||||
#ifndef IotContainers_Assert
|
||||
#ifdef Iot_DefaultAssert
|
||||
#define IotContainers_Assert( expression ) Iot_DefaultAssert( expression )
|
||||
#else
|
||||
#error "Asserts are enabled for containers, but IotContainers_Assert is not defined"
|
||||
#endif
|
||||
#endif
|
||||
#else /* if IOT_CONTAINERS_ENABLE_ASSERTS == 1 */
|
||||
#define IotContainers_Assert( expression )
|
||||
#endif /* if IOT_CONTAINERS_ENABLE_ASSERTS == 1 */
|
||||
|
||||
/**
|
||||
* @brief Calculates the starting address of a containing struct.
|
||||
*
|
||||
* @param[in] type Type of the containing struct.
|
||||
* @param[in] pLink Pointer to a link member.
|
||||
* @param[in] linkName Name of the #IotLink_t in the containing struct.
|
||||
*/
|
||||
#define IotLink_Container( type, pLink, linkName ) \
|
||||
( ( type * ) ( void * ) ( ( ( uint8_t * ) ( pLink ) ) - offsetof( type, linkName ) ) )
|
||||
|
||||
/**
|
||||
* @brief Iterates through all elements of a linear container.
|
||||
*
|
||||
* Container elements must not be freed or removed while iterating.
|
||||
*
|
||||
* @param[in] pStart The first element to iterate from.
|
||||
* @param[out] pLink Pointer to a container element.
|
||||
*/
|
||||
#define IotContainers_ForEach( pStart, pLink ) \
|
||||
for( ( pLink ) = ( pStart )->pNext; \
|
||||
( pLink ) != ( pStart ); \
|
||||
( pLink ) = ( pLink )->pNext )
|
||||
|
||||
/**
|
||||
* @functionspage{linear_containers,linear containers library}
|
||||
* - @functionname{linear_containers_function_link_islinked}
|
||||
* - @functionname{linear_containers_function_list_double_create}
|
||||
* - @functionname{linear_containers_function_list_double_count}
|
||||
* - @functionname{linear_containers_function_list_double_isempty}
|
||||
* - @functionname{linear_containers_function_list_double_peekhead}
|
||||
* - @functionname{linear_containers_function_list_double_peektail}
|
||||
* - @functionname{linear_containers_function_list_double_inserthead}
|
||||
* - @functionname{linear_containers_function_list_double_inserttail}
|
||||
* - @functionname{linear_containers_function_list_double_insertbefore}
|
||||
* - @functionname{linear_containers_function_list_double_insertafter}
|
||||
* - @functionname{linear_containers_function_list_double_insertsorted}
|
||||
* - @functionname{linear_containers_function_list_double_remove}
|
||||
* - @functionname{linear_containers_function_list_double_removehead}
|
||||
* - @functionname{linear_containers_function_list_double_removetail}
|
||||
* - @functionname{linear_containers_function_list_double_removeall}
|
||||
* - @functionname{linear_containers_function_list_double_findfirstmatch}
|
||||
* - @functionname{linear_containers_function_list_double_removefirstmatch}
|
||||
* - @functionname{linear_containers_function_list_double_removeallmatches}
|
||||
* - @functionname{linear_containers_function_queue_create}
|
||||
* - @functionname{linear_containers_function_queue_count}
|
||||
* - @functionname{linear_containers_function_queue_isempty}
|
||||
* - @functionname{linear_containers_function_queue_peekhead}
|
||||
* - @functionname{linear_containers_function_queue_peektail}
|
||||
* - @functionname{linear_containers_function_queue_enqueuehead}
|
||||
* - @functionname{linear_containers_function_queue_dequeuehead}
|
||||
* - @functionname{linear_containers_function_queue_enqueuetail}
|
||||
* - @functionname{linear_containers_function_queue_dequeuetail}
|
||||
* - @functionname{linear_containers_function_queue_remove}
|
||||
* - @functionname{linear_containers_function_queue_removeall}
|
||||
* - @functionname{linear_containers_function_queue_removeallmatches}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @functionpage{IotLink_IsLinked,linear_containers,link_islinked}
|
||||
* @functionpage{IotListDouble_Create,linear_containers,list_double_create}
|
||||
* @functionpage{IotListDouble_Count,linear_containers,list_double_count}
|
||||
* @functionpage{IotListDouble_IsEmpty,linear_containers,list_double_isempty}
|
||||
* @functionpage{IotListDouble_PeekHead,linear_containers,list_double_peekhead}
|
||||
* @functionpage{IotListDouble_PeekTail,linear_containers,list_double_peektail}
|
||||
* @functionpage{IotListDouble_InsertHead,linear_containers,list_double_inserthead}
|
||||
* @functionpage{IotListDouble_InsertTail,linear_containers,list_double_inserttail}
|
||||
* @functionpage{IotListDouble_InsertBefore,linear_containers,list_double_insertbefore}
|
||||
* @functionpage{IotListDouble_InsertAfter,linear_containers,list_double_insertafter}
|
||||
* @functionpage{IotListDouble_InsertSorted,linear_containers,list_double_insertsorted}
|
||||
* @functionpage{IotListDouble_Remove,linear_containers,list_double_remove}
|
||||
* @functionpage{IotListDouble_RemoveHead,linear_containers,list_double_removehead}
|
||||
* @functionpage{IotListDouble_RemoveTail,linear_containers,list_double_removetail}
|
||||
* @functionpage{IotListDouble_RemoveAll,linear_containers,list_double_removeall}
|
||||
* @functionpage{IotListDouble_FindFirstMatch,linear_containers,list_double_findfirstmatch}
|
||||
* @functionpage{IotListDouble_RemoveFirstMatch,linear_containers,list_double_removefirstmatch}
|
||||
* @functionpage{IotListDouble_RemoveAllMatches,linear_containers,list_double_removeallmatches}
|
||||
* @functionpage{IotDeQueue_Create,linear_containers,queue_create}
|
||||
* @functionpage{IotDeQueue_Count,linear_containers,queue_count}
|
||||
* @functionpage{IotDeQueue_IsEmpty,linear_containers,queue_isempty}
|
||||
* @functionpage{IotDeQueue_PeekHead,linear_containers,queue_peekhead}
|
||||
* @functionpage{IotDeQueue_PeekTail,linear_containers,queue_peektail}
|
||||
* @functionpage{IotDeQueue_EnqueueHead,linear_containers,queue_enqueuehead}
|
||||
* @functionpage{IotDeQueue_DequeueHead,linear_containers,queue_dequeuehead}
|
||||
* @functionpage{IotDeQueue_EnqueueTail,linear_containers,queue_enqueuetail}
|
||||
* @functionpage{IotDeQueue_DequeueTail,linear_containers,queue_dequeuetail}
|
||||
* @functionpage{IotDeQueue_Remove,linear_containers,queue_remove}
|
||||
* @functionpage{IotDeQueue_RemoveAll,linear_containers,queue_removeall}
|
||||
* @functionpage{IotDeQueue_RemoveAllMatches,linear_containers,queue_removeallmatches}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Check if an #IotLink_t is linked in a list or queue.
|
||||
*
|
||||
* @param[in] pLink The link to check.
|
||||
*
|
||||
* @return `true` if `pCurrent` is linked in a list or queue; `false` otherwise.
|
||||
*/
|
||||
/* @[declare_linear_containers_link_islinked] */
|
||||
static inline bool IotLink_IsLinked( const IotLink_t * const pLink )
|
||||
/* @[declare_linear_containers_link_islinked] */
|
||||
{
|
||||
bool isLinked = false;
|
||||
|
||||
if( pLink != NULL )
|
||||
{
|
||||
isLinked = ( pLink->pNext != NULL ) && ( pLink->pPrevious != NULL );
|
||||
}
|
||||
|
||||
return isLinked;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Create a new doubly-linked list.
|
||||
*
|
||||
* This function initializes a new doubly-linked list. It must be called on an
|
||||
* uninitialized #IotListDouble_t before calling any other doubly-linked list
|
||||
* function. This function must not be called on an already-initialized
|
||||
* #IotListDouble_t.
|
||||
*
|
||||
* This function will not fail. The function @ref linear_containers_function_list_double_removeall
|
||||
* may be called to destroy a list.
|
||||
*
|
||||
* @param[in] pList Pointer to the memory that will hold the new doubly-linked list.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_create] */
|
||||
static inline void IotListDouble_Create( IotListDouble_t * const pList )
|
||||
/* @[declare_linear_containers_list_double_create] */
|
||||
{
|
||||
/* This function must not be called with a NULL parameter. */
|
||||
IotContainers_Assert( pList != NULL );
|
||||
|
||||
/* An empty list is a link pointing to itself. */
|
||||
pList->pPrevious = pList;
|
||||
pList->pNext = pList;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return the number of elements contained in an #IotListDouble_t.
|
||||
*
|
||||
* @param[in] pList The doubly-linked list with the elements to count.
|
||||
*
|
||||
* @return The number of elements in the doubly-linked list.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_count] */
|
||||
static inline size_t IotListDouble_Count( const IotListDouble_t * const pList )
|
||||
/* @[declare_linear_containers_list_double_count] */
|
||||
{
|
||||
size_t count = 0;
|
||||
|
||||
if( pList != NULL )
|
||||
{
|
||||
/* Get the list head. */
|
||||
const IotLink_t * pCurrent = pList->pNext;
|
||||
|
||||
/* Iterate through the list to count the elements. */
|
||||
while( pCurrent != pList )
|
||||
{
|
||||
count++;
|
||||
pCurrent = pCurrent->pNext;
|
||||
}
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Check if a doubly-linked list is empty.
|
||||
*
|
||||
* @param[in] pList The doubly-linked list to check.
|
||||
*
|
||||
* @return `true` if the list is empty; `false` otherwise.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_isempty] */
|
||||
static inline bool IotListDouble_IsEmpty( const IotListDouble_t * const pList )
|
||||
/* @[declare_linear_containers_list_double_isempty] */
|
||||
{
|
||||
/* An empty list is NULL link, or a link pointing to itself. */
|
||||
return( ( pList == NULL ) || ( pList->pNext == pList ) );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return an #IotLink_t representing the first element in a doubly-linked list
|
||||
* without removing it.
|
||||
*
|
||||
* @param[in] pList The list to peek.
|
||||
*
|
||||
* @return Pointer to an #IotLink_t representing the element at the head of the
|
||||
* list; `NULL` if the list is empty. The macro #IotLink_Container may be used to
|
||||
* determine the address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_peekhead] */
|
||||
static inline IotLink_t * IotListDouble_PeekHead( const IotListDouble_t * const pList )
|
||||
/* @[declare_linear_containers_list_double_peekhead] */
|
||||
{
|
||||
IotLink_t * pHead = NULL;
|
||||
|
||||
if( pList != NULL )
|
||||
{
|
||||
if( IotListDouble_IsEmpty( pList ) == false )
|
||||
{
|
||||
pHead = pList->pNext;
|
||||
}
|
||||
}
|
||||
|
||||
return pHead;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return an #IotLink_t representing the last element in a doubly-linked
|
||||
* list without removing it.
|
||||
*
|
||||
* @param[in] pList The list to peek.
|
||||
*
|
||||
* @return Pointer to an #IotLink_t representing the element at the tail of the
|
||||
* list; `NULL` if the list is empty. The macro #IotLink_Container may be used to
|
||||
* determine the address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_peektail] */
|
||||
static inline IotLink_t * IotListDouble_PeekTail( const IotListDouble_t * const pList )
|
||||
/* @[declare_linear_containers_list_double_peektail] */
|
||||
{
|
||||
IotLink_t * pTail = NULL;
|
||||
|
||||
if( pList != NULL )
|
||||
{
|
||||
if( IotListDouble_IsEmpty( pList ) == false )
|
||||
{
|
||||
pTail = pList->pPrevious;
|
||||
}
|
||||
}
|
||||
|
||||
return pTail;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Insert an element at the head of a doubly-linked list.
|
||||
*
|
||||
* @param[in] pList The doubly-linked list that will hold the new element.
|
||||
* @param[in] pLink Pointer to the new element's link member.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_inserthead] */
|
||||
static inline void IotListDouble_InsertHead( IotListDouble_t * const pList,
|
||||
IotLink_t * const pLink )
|
||||
/* @[declare_linear_containers_list_double_inserthead] */
|
||||
{
|
||||
/* This function must not be called with NULL parameters. */
|
||||
IotContainers_Assert( pList != NULL );
|
||||
IotContainers_Assert( pLink != NULL );
|
||||
|
||||
/* Save current list head. */
|
||||
IotLink_t * pHead = pList->pNext;
|
||||
|
||||
/* Place new element before list head. */
|
||||
pLink->pNext = pHead;
|
||||
pLink->pPrevious = pList;
|
||||
|
||||
/* Assign new list head. */
|
||||
pHead->pPrevious = pLink;
|
||||
pList->pNext = pLink;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Insert an element at the tail of a doubly-linked list.
|
||||
*
|
||||
* @param[in] pList The double-linked list that will hold the new element.
|
||||
* @param[in] pLink Pointer to the new element's link member.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_inserttail] */
|
||||
static inline void IotListDouble_InsertTail( IotListDouble_t * const pList,
|
||||
IotLink_t * const pLink )
|
||||
/* @[declare_linear_containers_list_double_inserttail] */
|
||||
{
|
||||
/* This function must not be called with NULL parameters. */
|
||||
IotContainers_Assert( pList != NULL );
|
||||
IotContainers_Assert( pLink != NULL );
|
||||
|
||||
/* Save current list tail. */
|
||||
IotLink_t * pTail = pList->pPrevious;
|
||||
|
||||
pLink->pNext = pList;
|
||||
pLink->pPrevious = pTail;
|
||||
|
||||
pList->pPrevious = pLink;
|
||||
pTail->pNext = pLink;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Insert an element before another element in a doubly-linked list.
|
||||
*
|
||||
* @param[in] pElement The new element will be placed before this element.
|
||||
* @param[in] pLink Pointer to the new element's link member.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_insertbefore] */
|
||||
static inline void IotListDouble_InsertBefore( IotLink_t * const pElement,
|
||||
IotLink_t * const pLink )
|
||||
/* @[declare_linear_containers_list_double_insertbefore] */
|
||||
{
|
||||
IotListDouble_InsertTail( pElement, pLink );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Insert an element after another element in a doubly-linked list.
|
||||
*
|
||||
* @param[in] pElement The new element will be placed after this element.
|
||||
* @param[in] pLink Pointer to the new element's link member.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_insertafter] */
|
||||
static inline void IotListDouble_InsertAfter( IotLink_t * const pElement,
|
||||
IotLink_t * const pLink )
|
||||
/* @[declare_linear_containers_list_double_insertafter] */
|
||||
{
|
||||
IotListDouble_InsertHead( pElement, pLink );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Insert an element in a sorted doubly-linked list.
|
||||
*
|
||||
* Places an element into a list by sorting it into order. The function
|
||||
* `compare` is used to determine where to place the new element.
|
||||
*
|
||||
* @param[in] pList The list that will hold the new element.
|
||||
* @param[in] pLink Pointer to the new element's link member.
|
||||
* @param[in] compare Determines the order of the list. Returns a negative
|
||||
* value if its first argument is less than its second argument; returns
|
||||
* zero if its first argument is equal to its second argument; returns a
|
||||
* positive value if its first argument is greater than its second argument.
|
||||
* The parameters to this function are #IotLink_t, so the macro #IotLink_Container
|
||||
* may be used to determine the address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_insertsorted] */
|
||||
static inline void IotListDouble_InsertSorted( IotListDouble_t * const pList,
|
||||
IotLink_t * const pLink,
|
||||
int32_t ( *compare )( const IotLink_t * const, const IotLink_t * const ) )
|
||||
/* @[declare_linear_containers_list_double_insertsorted] */
|
||||
{
|
||||
/* This function must not be called with NULL parameters. */
|
||||
IotContainers_Assert( pList != NULL );
|
||||
IotContainers_Assert( pLink != NULL );
|
||||
IotContainers_Assert( compare != NULL );
|
||||
|
||||
/* Insert at head for empty list. */
|
||||
if( IotListDouble_IsEmpty( pList ) == true )
|
||||
{
|
||||
IotListDouble_InsertHead( pList, pLink );
|
||||
}
|
||||
else
|
||||
{
|
||||
bool inserted = false;
|
||||
IotLink_t * pCurrent = pList->pNext;
|
||||
|
||||
/* Iterate through the list to find the correct position. */
|
||||
while( pCurrent != pList )
|
||||
{
|
||||
/* Comparing for '<' preserves the order of insertion. */
|
||||
if( compare( pLink, pCurrent ) < 0 )
|
||||
{
|
||||
IotListDouble_InsertBefore( pCurrent, pLink );
|
||||
inserted = true;
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
pCurrent = pCurrent->pNext;
|
||||
}
|
||||
|
||||
/* New element is greater than all elements in list. Insert at tail. */
|
||||
if( inserted == false )
|
||||
{
|
||||
IotListDouble_InsertTail( pList, pLink );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove a single element from a doubly-linked list.
|
||||
*
|
||||
* @param[in] pLink The element to remove.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_remove] */
|
||||
static inline void IotListDouble_Remove( IotLink_t * const pLink )
|
||||
/* @[declare_linear_containers_list_double_remove] */
|
||||
{
|
||||
/* This function must not be called with a NULL parameter. */
|
||||
IotContainers_Assert( pLink != NULL );
|
||||
|
||||
/* This function must be called on a linked element. */
|
||||
IotContainers_Assert( IotLink_IsLinked( pLink ) == true );
|
||||
|
||||
pLink->pPrevious->pNext = pLink->pNext;
|
||||
pLink->pNext->pPrevious = pLink->pPrevious;
|
||||
pLink->pPrevious = NULL;
|
||||
pLink->pNext = NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove the element at the head of a doubly-linked list.
|
||||
*
|
||||
* @param[in] pList The doubly-linked list that holds the element to remove.
|
||||
*
|
||||
* @return Pointer to an #IotLink_t representing the removed list head; `NULL`
|
||||
* if the list is empty. The macro #IotLink_Container may be used to determine
|
||||
* the address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_removehead] */
|
||||
static inline IotLink_t * IotListDouble_RemoveHead( IotListDouble_t * const pList )
|
||||
/* @[declare_linear_containers_list_double_removehead] */
|
||||
{
|
||||
IotLink_t * pHead = NULL;
|
||||
|
||||
if( IotListDouble_IsEmpty( pList ) == false )
|
||||
{
|
||||
pHead = pList->pNext;
|
||||
IotListDouble_Remove( pHead );
|
||||
}
|
||||
|
||||
return pHead;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove the element at the tail of a doubly-linked list.
|
||||
*
|
||||
* @param[in] pList The doubly-linked list that holds the element to remove.
|
||||
*
|
||||
* @return Pointer to an #IotLink_t representing the removed list tail; `NULL`
|
||||
* if the list is empty. The macro #IotLink_Container may be used to determine
|
||||
* the address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_removetail] */
|
||||
static inline IotLink_t * IotListDouble_RemoveTail( IotListDouble_t * const pList )
|
||||
/* @[declare_linear_containers_list_double_removetail] */
|
||||
{
|
||||
IotLink_t * pTail = NULL;
|
||||
|
||||
if( IotListDouble_IsEmpty( pList ) == false )
|
||||
{
|
||||
pTail = pList->pPrevious;
|
||||
IotListDouble_Remove( pTail );
|
||||
}
|
||||
|
||||
return pTail;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove all elements in a doubly-linked list.
|
||||
*
|
||||
* @param[in] pList The list to empty.
|
||||
* @param[in] freeElement A function to free memory used by each removed list
|
||||
* element. Optional; pass `NULL` to ignore.
|
||||
* @param[in] linkOffset Offset in bytes of a link member in its container, used
|
||||
* to calculate the pointer to pass to `freeElement`. This value should be calculated
|
||||
* with the C `offsetof` macro. This parameter is ignored if `freeElement` is `NULL`
|
||||
* or its value is `0`.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_removeall] */
|
||||
static inline void IotListDouble_RemoveAll( IotListDouble_t * const pList,
|
||||
void ( *freeElement )( void * ),
|
||||
size_t linkOffset )
|
||||
/* @[declare_linear_containers_list_double_removeall] */
|
||||
{
|
||||
/* This function must not be called with a NULL pList parameter. */
|
||||
IotContainers_Assert( pList != NULL );
|
||||
|
||||
/* Get the list head. */
|
||||
IotLink_t * pCurrent = pList->pNext;
|
||||
|
||||
/* Iterate through the list and remove all elements. */
|
||||
while( pCurrent != pList )
|
||||
{
|
||||
/* Save a pointer to the next list element. */
|
||||
IotLink_t * pNext = pCurrent->pNext;
|
||||
|
||||
/* Remove and free the current list element. */
|
||||
IotListDouble_Remove( pCurrent );
|
||||
|
||||
if( freeElement != NULL )
|
||||
{
|
||||
freeElement( ( ( uint8_t * ) pCurrent ) - linkOffset );
|
||||
}
|
||||
|
||||
/* Move the iterating pointer to the next list element. */
|
||||
pCurrent = pNext;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Search a doubly-linked list for the first matching element.
|
||||
*
|
||||
* If a match is found, the matching element is <b>not</b> removed from the list.
|
||||
* See @ref linear_containers_function_list_double_removefirstmatch for the function
|
||||
* that searches and removes.
|
||||
*
|
||||
* @param[in] pList The doubly-linked list to search.
|
||||
* @param[in] pStartPoint An element in `pList`. Only elements between this one and
|
||||
* the list tail are checked. Pass `NULL` to search from the beginning of the list.
|
||||
* @param[in] isMatch Function to determine if an element matches. Pass `NULL` to
|
||||
* search using the address `pMatch`, i.e. `element == pMatch`.
|
||||
* @param[in] pMatch If `isMatch` is `NULL`, each element in the list is compared
|
||||
* to this address to find a match. Otherwise, it is passed as the second argument
|
||||
* to `isMatch`.
|
||||
*
|
||||
* @return Pointer to an #IotLink_t representing the first matched element; `NULL`
|
||||
* if no match is found. The macro #IotLink_Container may be used to determine the
|
||||
* address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_findfirstmatch] */
|
||||
static inline IotLink_t * IotListDouble_FindFirstMatch( const IotListDouble_t * const pList,
|
||||
const IotLink_t * const pStartPoint,
|
||||
bool ( *isMatch )( const IotLink_t * const, void * ),
|
||||
void * pMatch )
|
||||
/* @[declare_linear_containers_list_double_findfirstmatch] */
|
||||
{
|
||||
/* The const must be cast away to match this function's return value. Nevertheless,
|
||||
* this function will respect the const-ness of pStartPoint. */
|
||||
IotLink_t * pCurrent = ( IotLink_t * ) pStartPoint;
|
||||
|
||||
/* This function must not be called with a NULL pList parameter. */
|
||||
IotContainers_Assert( pList != NULL );
|
||||
|
||||
/* Search starting from list head if no start point is given. */
|
||||
if( pStartPoint == NULL )
|
||||
{
|
||||
pCurrent = pList->pNext;
|
||||
}
|
||||
|
||||
/* Iterate through the list to search for matches. */
|
||||
while( pCurrent != pList )
|
||||
{
|
||||
/* Call isMatch if provided. Otherwise, compare pointers. */
|
||||
if( isMatch != NULL )
|
||||
{
|
||||
if( isMatch( pCurrent, pMatch ) == true )
|
||||
{
|
||||
return pCurrent;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if( pCurrent == pMatch )
|
||||
{
|
||||
return pCurrent;
|
||||
}
|
||||
}
|
||||
|
||||
pCurrent = pCurrent->pNext;
|
||||
}
|
||||
|
||||
/* No match found, return NULL. */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Search a doubly-linked list for the first matching element and remove
|
||||
* it.
|
||||
*
|
||||
* An #IotLink_t may be passed as `pList` to start searching after the head of a
|
||||
* doubly-linked list.
|
||||
*
|
||||
* @param[in] pList The doubly-linked list to search.
|
||||
* @param[in] pStartPoint An element in `pList`. Only elements between this one and
|
||||
* the list tail are checked. Pass `NULL` to search from the beginning of the list.
|
||||
* @param[in] isMatch Function to determine if an element matches. Pass `NULL` to
|
||||
* search using the address `pMatch`, i.e. `element == pMatch`.
|
||||
* @param[in] pMatch If `isMatch` is `NULL`, each element in the list is compared
|
||||
* to this address to find a match. Otherwise, it is passed as the second argument
|
||||
* to `isMatch`.
|
||||
*
|
||||
* @return Pointer to an #IotLink_t representing the matched and removed element;
|
||||
* `NULL` if no match is found. The macro #IotLink_Container may be used to determine
|
||||
* the address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_removefirstmatch] */
|
||||
static inline IotLink_t * IotListDouble_RemoveFirstMatch( IotListDouble_t * const pList,
|
||||
const IotLink_t * const pStartPoint,
|
||||
bool ( *isMatch )( const IotLink_t *, void * ),
|
||||
void * pMatch )
|
||||
/* @[declare_linear_containers_list_double_removefirstmatch] */
|
||||
{
|
||||
IotLink_t * pMatchedElement = IotListDouble_FindFirstMatch( pList,
|
||||
pStartPoint,
|
||||
isMatch,
|
||||
pMatch );
|
||||
|
||||
if( pMatchedElement != NULL )
|
||||
{
|
||||
IotListDouble_Remove( pMatchedElement );
|
||||
}
|
||||
|
||||
return pMatchedElement;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove all matching elements from a doubly-linked list.
|
||||
*
|
||||
* @param[in] pList The doubly-linked list to search.
|
||||
* @param[in] isMatch Function to determine if an element matches. Pass `NULL` to
|
||||
* search using the address `pMatch`, i.e. `element == pMatch`.
|
||||
* @param[in] pMatch If `isMatch` is `NULL`, each element in the list is compared
|
||||
* to this address to find a match. Otherwise, it is passed as the second argument
|
||||
* to `isMatch`.
|
||||
* @param[in] freeElement A function to free memory used by each removed list
|
||||
* element. Optional; pass `NULL` to ignore.
|
||||
* @param[in] linkOffset Offset in bytes of a link member in its container, used
|
||||
* to calculate the pointer to pass to `freeElement`. This value should be calculated
|
||||
* with the C `offsetof` macro. This parameter is ignored if `freeElement` is `NULL`
|
||||
* or its value is `0`.
|
||||
*/
|
||||
/* @[declare_linear_containers_list_double_removeallmatches] */
|
||||
static inline void IotListDouble_RemoveAllMatches( IotListDouble_t * const pList,
|
||||
bool ( *isMatch )( const IotLink_t *, void * ),
|
||||
void * pMatch,
|
||||
void ( *freeElement )( void * ),
|
||||
size_t linkOffset )
|
||||
/* @[declare_linear_containers_list_double_removeallmatches] */
|
||||
{
|
||||
IotLink_t * pMatchedElement = NULL, * pNextElement = NULL;
|
||||
|
||||
/* Search the list for all matching elements. */
|
||||
do
|
||||
{
|
||||
pMatchedElement = IotListDouble_FindFirstMatch( pList,
|
||||
pMatchedElement,
|
||||
isMatch,
|
||||
pMatch );
|
||||
|
||||
if( pMatchedElement != NULL )
|
||||
{
|
||||
/* Save pointer to next element. */
|
||||
pNextElement = pMatchedElement->pNext;
|
||||
|
||||
/* Match found; remove and free. */
|
||||
IotListDouble_Remove( pMatchedElement );
|
||||
|
||||
if( freeElement != NULL )
|
||||
{
|
||||
freeElement( ( ( uint8_t * ) pMatchedElement ) - linkOffset );
|
||||
}
|
||||
|
||||
/* Continue search from next element. */
|
||||
pMatchedElement = pNextElement;
|
||||
}
|
||||
} while( pMatchedElement != NULL );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Create a new queue.
|
||||
*
|
||||
* This function initializes a new double-ended queue. It must be called on an uninitialized
|
||||
* #IotDeQueue_t before calling any other queue function. This function must not be
|
||||
* called on an already-initialized #IotDeQueue_t.
|
||||
*
|
||||
* This function will not fail.
|
||||
*
|
||||
* @param[in] pQueue Pointer to the memory that will hold the new queue.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_create] */
|
||||
static inline void IotDeQueue_Create( IotDeQueue_t * const pQueue )
|
||||
/* @[declare_linear_containers_queue_create] */
|
||||
{
|
||||
IotListDouble_Create( pQueue );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return the number of elements contained in an #IotDeQueue_t.
|
||||
*
|
||||
* @param[in] pQueue The queue with the elements to count.
|
||||
*
|
||||
* @return The number of items elements in the queue.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_count] */
|
||||
static inline size_t IotDeQueue_Count( const IotDeQueue_t * const pQueue )
|
||||
/* @[declare_linear_containers_queue_count] */
|
||||
{
|
||||
return IotListDouble_Count( pQueue );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Check if a queue is empty.
|
||||
*
|
||||
* @param[in] pQueue The queue to check.
|
||||
*
|
||||
* @return `true` if the queue is empty; `false` otherwise.
|
||||
*
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_isempty] */
|
||||
static inline bool IotDeQueue_IsEmpty( const IotDeQueue_t * const pQueue )
|
||||
/* @[declare_linear_containers_queue_isempty] */
|
||||
{
|
||||
return IotListDouble_IsEmpty( pQueue );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return an #IotLink_t representing the element at the front of the queue
|
||||
* without removing it.
|
||||
*
|
||||
* @param[in] pQueue The queue to peek.
|
||||
*
|
||||
* @return Pointer to an #IotLink_t representing the element at the head of the
|
||||
* queue; `NULL` if the queue is empty. The macro #IotLink_Container may be used
|
||||
* to determine the address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_peekhead] */
|
||||
static inline IotLink_t * IotDeQueue_PeekHead( const IotDeQueue_t * const pQueue )
|
||||
/* @[declare_linear_containers_queue_peekhead] */
|
||||
{
|
||||
return IotListDouble_PeekHead( pQueue );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return an #IotLink_t representing the element at the back of the queue
|
||||
* without removing it.
|
||||
*
|
||||
* @param[in] pQueue The queue to peek.
|
||||
*
|
||||
* @return Pointer to an #IotLink_t representing the element at the head of the
|
||||
* queue; `NULL` if the queue is empty. The macro #IotLink_Container may be used
|
||||
* to determine the address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_peektail] */
|
||||
static inline IotLink_t * IotDeQueue_PeekTail( const IotDeQueue_t * const pQueue )
|
||||
/* @[declare_linear_containers_queue_peektail] */
|
||||
{
|
||||
return IotListDouble_PeekTail( pQueue );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Add an element at the head of the queue.
|
||||
*
|
||||
* @param[in] pQueue The queue that will hold the new element.
|
||||
* @param[in] pLink Pointer to the new element's link member.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_enqueuehead] */
|
||||
static inline void IotDeQueue_EnqueueHead( IotDeQueue_t * const pQueue,
|
||||
IotLink_t * const pLink )
|
||||
/* @[declare_linear_containers_queue_enqueuehead] */
|
||||
{
|
||||
IotListDouble_InsertHead( pQueue, pLink );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove an element at the head of the queue.
|
||||
*
|
||||
* @param[in] pQueue The queue that holds the element to remove.
|
||||
*
|
||||
* @return Pointer to an #IotLink_t representing the removed queue element; `NULL`
|
||||
* if the queue is empty. The macro #IotLink_Container may be used to determine
|
||||
* the address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_dequeuehead] */
|
||||
static inline IotLink_t * IotDeQueue_DequeueHead( IotDeQueue_t * const pQueue )
|
||||
/* @[declare_linear_containers_queue_dequeuehead] */
|
||||
{
|
||||
return IotListDouble_RemoveHead( pQueue );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Add an element at the tail of the queue.
|
||||
*
|
||||
* @param[in] pQueue The queue that will hold the new element.
|
||||
* @param[in] pLink Pointer to the new element's link member.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_enqueuetail] */
|
||||
static inline void IotDeQueue_EnqueueTail( IotDeQueue_t * const pQueue,
|
||||
IotLink_t * const pLink )
|
||||
/* @[declare_linear_containers_queue_enqueuetail] */
|
||||
{
|
||||
IotListDouble_InsertTail( pQueue, pLink );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove an element at the tail of the queue.
|
||||
*
|
||||
* @param[in] pQueue The queue that holds the element to remove.
|
||||
*
|
||||
* @return Pointer to an #IotLink_t representing the removed queue element; `NULL`
|
||||
* if the queue is empty. The macro #IotLink_Container may be used to determine
|
||||
* the address of the link's container.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_dequeuetail] */
|
||||
static inline IotLink_t * IotDeQueue_DequeueTail( IotDeQueue_t * const pQueue )
|
||||
/* @[declare_linear_containers_queue_dequeuetail] */
|
||||
{
|
||||
return IotListDouble_RemoveTail( pQueue );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove a single element from a queue.
|
||||
*
|
||||
* @param[in] pLink The element to remove.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_remove] */
|
||||
static inline void IotDeQueue_Remove( IotLink_t * const pLink )
|
||||
/* @[declare_linear_containers_queue_remove] */
|
||||
{
|
||||
IotListDouble_Remove( pLink );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove all elements in a queue.
|
||||
*
|
||||
* @param[in] pQueue The queue to empty.
|
||||
* @param[in] freeElement A function to free memory used by each removed queue
|
||||
* element. Optional; pass `NULL` to ignore.
|
||||
* @param[in] linkOffset Offset in bytes of a link member in its container, used
|
||||
* to calculate the pointer to pass to `freeElement`. This value should be calculated
|
||||
* with the C `offsetof` macro. This parameter is ignored if `freeElement` is `NULL`
|
||||
* or its value is `0`.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_removeall] */
|
||||
static inline void IotDeQueue_RemoveAll( IotDeQueue_t * const pQueue,
|
||||
void ( * freeElement )( void * ),
|
||||
size_t linkOffset )
|
||||
/* @[declare_linear_containers_queue_removeall] */
|
||||
{
|
||||
IotListDouble_RemoveAll( pQueue, freeElement, linkOffset );
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove all matching elements from a queue.
|
||||
*
|
||||
* @param[in] pQueue The queue to search.
|
||||
* @param[in] isMatch Function to determine if an element matches. Pass `NULL` to
|
||||
* search using the address `pMatch`, i.e. `element == pMatch`.
|
||||
* @param[in] pMatch If `isMatch` is `NULL`, each element in the queue is compared
|
||||
* to this address to find a match. Otherwise, it is passed as the second argument
|
||||
* to `isMatch`.
|
||||
* @param[in] freeElement A function to free memory used by each removed queue
|
||||
* element. Optional; pass `NULL` to ignore.
|
||||
* @param[in] linkOffset Offset in bytes of a link member in its container, used
|
||||
* to calculate the pointer to pass to `freeElement`. This value should be calculated
|
||||
* with the C `offsetof` macro. This parameter is ignored if `freeElement` is `NULL`
|
||||
* or its value is `0`.
|
||||
*/
|
||||
/* @[declare_linear_containers_queue_removeallmatches] */
|
||||
static inline void IotDeQueue_RemoveAllMatches( IotDeQueue_t * const pQueue,
|
||||
bool ( * isMatch )( const IotLink_t *, void * ),
|
||||
void * pMatch,
|
||||
void ( * freeElement )( void * ),
|
||||
size_t linkOffset )
|
||||
/* @[declare_linear_containers_queue_removeallmatches] */
|
||||
{
|
||||
IotListDouble_RemoveAllMatches( pQueue, isMatch, pMatch, freeElement, linkOffset );
|
||||
}
|
||||
|
||||
#endif /* IOT_LINEAR_CONTAINERS_H_ */
|
||||
|
|
@ -0,0 +1,226 @@
|
|||
/*
|
||||
* IoT Common V1.1.0
|
||||
* Copyright (C) 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file iot_logging.h
|
||||
* @brief Generic logging function header file.
|
||||
*
|
||||
* Declares the generic logging function and the log levels. This file never
|
||||
* needs to be included in source code. The header iot_logging_setup.h should
|
||||
* be included instead.
|
||||
*
|
||||
* @see iot_logging_setup.h
|
||||
*/
|
||||
|
||||
#ifndef IOT_LOGGING_H_
|
||||
#define IOT_LOGGING_H_
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/**
|
||||
* @constantspage{logging,logging library}
|
||||
*
|
||||
* @section logging_constants_levels Log levels
|
||||
* @brief Log levels for the libraries in this SDK.
|
||||
*
|
||||
* Each library should specify a log level by setting @ref LIBRARY_LOG_LEVEL.
|
||||
* All log messages with a level at or below the specified level will be printed
|
||||
* for that library.
|
||||
*
|
||||
* Currently, there are 4 log levels. In the order of lowest to highest, they are:
|
||||
* - #IOT_LOG_NONE <br>
|
||||
* @copybrief IOT_LOG_NONE
|
||||
* - #IOT_LOG_ERROR <br>
|
||||
* @copybrief IOT_LOG_ERROR
|
||||
* - #IOT_LOG_WARN <br>
|
||||
* @copybrief IOT_LOG_WARN
|
||||
* - #IOT_LOG_INFO <br>
|
||||
* @copybrief IOT_LOG_INFO
|
||||
* - #IOT_LOG_DEBUG <br>
|
||||
* @copybrief IOT_LOG_DEBUG
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief No log messages.
|
||||
*
|
||||
* Log messages with this level will be silently discarded. When @ref
|
||||
* LIBRARY_LOG_LEVEL is #IOT_LOG_NONE, logging is disabled and no [logging functions]
|
||||
* (@ref logging_functions) can be called.
|
||||
*/
|
||||
#define IOT_LOG_NONE 0
|
||||
|
||||
/**
|
||||
* @brief Only critical, unrecoverable errors.
|
||||
*
|
||||
* Log messages with this level will be printed when a library encounters an
|
||||
* error from which it cannot easily recover.
|
||||
*/
|
||||
#define IOT_LOG_ERROR 1
|
||||
|
||||
/**
|
||||
* @brief Message about an abnormal but recoverable event.
|
||||
*
|
||||
* Log messages with this level will be printed when a library encounters an
|
||||
* abnormal event that may be indicative of an error. Libraries should continue
|
||||
* execution after logging a warning.
|
||||
*/
|
||||
#define IOT_LOG_WARN 2
|
||||
|
||||
/**
|
||||
* @brief A helpful, informational message.
|
||||
*
|
||||
* Log messages with this level may indicate the normal status of a library
|
||||
* function. They should be used to track how far a program has executed.
|
||||
*/
|
||||
#define IOT_LOG_INFO 3
|
||||
|
||||
/**
|
||||
* @brief Detailed and excessive debug information.
|
||||
*
|
||||
* Log messages with this level are intended for developers. They may contain
|
||||
* excessive information such as internal variables, buffers, or other specific
|
||||
* information.
|
||||
*/
|
||||
#define IOT_LOG_DEBUG 4
|
||||
|
||||
/**
|
||||
* @paramstructs{logging,logging}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @ingroup logging_datatypes_paramstructs
|
||||
* @brief Log message configuration struct.
|
||||
*
|
||||
* @paramfor @ref logging_function_log, @ref logging_function_generic
|
||||
*
|
||||
* By default, log messages print the library name, log level, and a timestring.
|
||||
* This struct can be passed to @ref logging_function_generic to disable one of
|
||||
* the above components in the log message.
|
||||
*
|
||||
* <b>Example:</b>
|
||||
*
|
||||
* @code{c}
|
||||
* IotLog_Generic( IOT_LOG_DEBUG, "SAMPLE", IOT_LOG_DEBUG, NULL, "Hello world!" );
|
||||
* @endcode
|
||||
* The code above prints the following message:
|
||||
* @code
|
||||
* [DEBUG][SAMPLE][2018-01-01 12:00:00] Hello world!
|
||||
* @endcode
|
||||
*
|
||||
* The timestring can be disabled as follows:
|
||||
* @code
|
||||
* IotLogConfig_t logConfig = { .hideLogLevel = false, .hideLibraryName = false, .hideTimestring = true};
|
||||
* IotLog_Generic( IOT_LOG_DEBUG, "SAMPLE", IOT_LOG_DEBUG, &logConfig, "Hello world!" );
|
||||
* @endcode
|
||||
* The resulting log message will be:
|
||||
* @code
|
||||
* [DEBUG][SAMPLE] Hello world!
|
||||
* @endcode
|
||||
*/
|
||||
typedef struct IotLogConfig
|
||||
{
|
||||
bool hideLogLevel; /**< @brief Don't print the log level string for this message. */
|
||||
bool hideLibraryName; /**< @brief Don't print the library name for this message. */
|
||||
bool hideTimestring; /**< @brief Don't print the timestring for this message. */
|
||||
} IotLogConfig_t;
|
||||
|
||||
/**
|
||||
* @functionspage{logging,logging library}
|
||||
*
|
||||
* - @functionname{logging_function_log}
|
||||
* - @functionname{logging_function_printbuffer}
|
||||
* - @functionname{logging_function_generic}
|
||||
* - @functionname{logging_function_genericprintbuffer}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @functionpage{IotLog_Generic,logging,generic}
|
||||
* @functionpage{IotLog_PrintBuffer,logging,genericprintbuffer}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Generic logging function that prints a single message.
|
||||
*
|
||||
* This function is the generic logging function shared across all libraries.
|
||||
* The library-specific logging function @ref logging_function_log is implemented
|
||||
* using this function. Like @ref logging_function_log, this function is only
|
||||
* available when @ref LIBRARY_LOG_LEVEL is #IOT_LOG_NONE.
|
||||
*
|
||||
* In most cases, the library-specific logging function @ref logging_function_log
|
||||
* should be called instead of this function.
|
||||
*
|
||||
* @param[in] libraryLogSetting The log level setting of the library, used to
|
||||
* determine if the log message should be printed. Must be one of the @ref
|
||||
* logging_constants_levels.
|
||||
* @param[in] pLibraryName The library name to print. See @ref LIBRARY_LOG_NAME.
|
||||
* @param[in] messageLevel The log level of the this message. See @ref LIBRARY_LOG_LEVEL.
|
||||
* @param[in] pLogConfig Pointer to a #IotLogConfig_t. Optional; pass `NULL` to ignore.
|
||||
* @param[in] pFormat Format string for the log message.
|
||||
* @param[in] ... Arguments for format specification.
|
||||
*
|
||||
* @return No return value. On errors, it prints nothing.
|
||||
*/
|
||||
/* @[declare_logging_generic] */
|
||||
void IotLog_Generic( int libraryLogSetting,
|
||||
const char * const pLibraryName,
|
||||
int messageLevel,
|
||||
const IotLogConfig_t * const pLogConfig,
|
||||
const char * const pFormat,
|
||||
... );
|
||||
/* @[declare_logging_generic] */
|
||||
|
||||
/**
|
||||
* @brief Generic function to log the contents of a buffer as bytes.
|
||||
*
|
||||
* This function is the generic buffer logging function shared across all libraries.
|
||||
* The library-specific buffer logging function @ref logging_function_printbuffer is
|
||||
* implemented using this function. Like @ref logging_function_printbuffer, this
|
||||
* function is only available when @ref LIBRARY_LOG_LEVEL is #IOT_LOG_DEBUG.
|
||||
*
|
||||
* In most cases, the library-specific buffer logging function @ref
|
||||
* logging_function_printbuffer should be called instead of this function.
|
||||
*
|
||||
* @param[in] pLibraryName The library name to print with the log. See @ref LIBRARY_LOG_NAME.
|
||||
* @param[in] pHeader A message to print before printing the buffer.
|
||||
* @param[in] pBuffer The buffer to print.
|
||||
* @param[in] bufferSize The number of bytes in `pBuffer` to print.
|
||||
*
|
||||
* @return No return value. On errors, it prints nothing.
|
||||
*
|
||||
* @note To conserve memory, this function only allocates enough memory for a
|
||||
* single line of output. Therefore, in multithreaded systems, its output may
|
||||
* appear "fragmented" if other threads are logging simultaneously.
|
||||
*/
|
||||
/* @[declare_logging_genericprintbuffer] */
|
||||
void IotLog_GenericPrintBuffer( const char * const pLibraryName,
|
||||
const char * const pHeader,
|
||||
const uint8_t * const pBuffer,
|
||||
size_t bufferSize );
|
||||
/* @[declare_logging_genericprintbuffer] */
|
||||
|
||||
#endif /* ifndef IOT_LOGGING_H_ */
|
||||
|
|
@ -0,0 +1,220 @@
|
|||
/*
|
||||
* IoT Common V1.1.0
|
||||
* Copyright (C) 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file iot_logging_setup.h
|
||||
* @brief Defines the logging macro #IotLog.
|
||||
*/
|
||||
|
||||
#ifndef IOT_LOGGING_SETUP_H_
|
||||
#define IOT_LOGGING_SETUP_H_
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Logging include. Because it's included here, iot_logging.h never needs
|
||||
* to be included in source. */
|
||||
#include "iot_logging.h"
|
||||
|
||||
/**
|
||||
* @functionpage{IotLog,logging,log}
|
||||
* @functionpage{IotLog_PrintBuffer,logging,printbuffer}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @def IotLog( messageLevel, pLogConfig, ... )
|
||||
* @brief Logging function for a specific library. In most cases, this is the
|
||||
* logging function to call.
|
||||
*
|
||||
* This function prints a single log message. It is available when @ref
|
||||
* LIBRARY_LOG_LEVEL is not #IOT_LOG_NONE. Log messages automatically
|
||||
* include the [log level](@ref logging_constants_levels), [library name]
|
||||
* (@ref LIBRARY_LOG_NAME), and time. An optional @ref IotLogConfig_t may
|
||||
* be passed to this function to hide information for a single log message.
|
||||
*
|
||||
* The logging library must be set up before this function may be called. See
|
||||
* @ref logging_setup_use for more information.
|
||||
*
|
||||
* This logging function also has the following abbreviated forms that can be used
|
||||
* when an #IotLogConfig_t isn't needed.
|
||||
*
|
||||
* Name | Equivalent to
|
||||
* ---- | -------------
|
||||
* #IotLogError | @code{c} IotLog( IOT_LOG_ERROR, NULL, ... ) @endcode
|
||||
* #IotLogWarn | @code{c} IotLog( IOT_LOG_WARN, NULL, ... ) @endcode
|
||||
* #IotLogInfo | @code{c} IotLog( IOT_LOG_INFO, NULL, ... ) @endcode
|
||||
* #IotLogDebug | @code{c} IotLog( IOT_LOG_DEBUG, NULL, ... ) @endcode
|
||||
*
|
||||
* @param[in] messageLevel Log level of this message. Must be one of the
|
||||
* @ref logging_constants_levels.
|
||||
* @param[in] pLogConfig Pointer to an #IotLogConfig_t. Optional; pass `NULL`
|
||||
* to ignore.
|
||||
* @param[in] ... Message and format specification.
|
||||
*
|
||||
* @return No return value. On errors, it prints nothing.
|
||||
*
|
||||
* @note This function may be implemented as a macro.
|
||||
* @see @ref logging_function_generic for the generic (not library-specific)
|
||||
* logging function.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @def IotLog_PrintBuffer( pHeader, pBuffer, bufferSize )
|
||||
* @brief Log the contents of buffer as bytes. Only available when @ref
|
||||
* LIBRARY_LOG_LEVEL is #IOT_LOG_DEBUG.
|
||||
*
|
||||
* This function prints the bytes located at a given memory address. It is
|
||||
* intended for debugging only, and is therefore only available when @ref
|
||||
* LIBRARY_LOG_LEVEL is #IOT_LOG_DEBUG.
|
||||
*
|
||||
* Log messages printed by this function <b>always</b> include the [log level]
|
||||
* (@ref logging_constants_levels), [library name](@ref LIBRARY_LOG_NAME),
|
||||
* and time. In addition, this function may print an optional header `pHeader`
|
||||
* before it prints the contents of the buffer. This function does not have an
|
||||
* #IotLogConfig_t parameter.
|
||||
*
|
||||
* The logging library must be set up before this function may be called. See
|
||||
* @ref logging_setup_use for more information.
|
||||
*
|
||||
* @param[in] pHeader A message to log before the buffer. Optional; pass `NULL`
|
||||
* to ignore.
|
||||
* @param[in] pBuffer Pointer to start of buffer.
|
||||
* @param[in] bufferSize Size of `pBuffer`.
|
||||
*
|
||||
* @return No return value. On errors, it prints nothing.
|
||||
*
|
||||
* @note This function may be implemented as a macro.
|
||||
* @note To conserve memory, @ref logging_function_genericprintbuffer (the underlying
|
||||
* implementation) only allocates enough memory for a single line of output. Therefore,
|
||||
* in multithreaded systems, its output may appear "fragmented" if other threads are
|
||||
* logging simultaneously.
|
||||
* @see @ref logging_function_genericprintbuffer for the generic (not library-specific)
|
||||
* buffer logging function.
|
||||
*
|
||||
* <b>Example</b>
|
||||
* @code{c}
|
||||
* const uint8_t pBuffer[] = { 0x00, 0x01, 0x02, 0x03 };
|
||||
*
|
||||
* IotLog_PrintBuffer( "This buffer contains:",
|
||||
* pBuffer,
|
||||
* 4 );
|
||||
* @endcode
|
||||
* The code above prints something like the following:
|
||||
* @code{c}
|
||||
* [DEBUG][LIB_NAME][2018-01-01 12:00:00] This buffer contains:
|
||||
* 00 01 02 03
|
||||
* @endcode
|
||||
*/
|
||||
|
||||
/**
|
||||
* @def IotLogError( ... )
|
||||
* @brief Abbreviated logging macro for level #IOT_LOG_ERROR.
|
||||
*
|
||||
* Equivalent to:
|
||||
* @code{c}
|
||||
* IotLog( IOT_LOG_ERROR, NULL, ... )
|
||||
* @endcode
|
||||
*/
|
||||
|
||||
/**
|
||||
* @def IotLogWarn( ... )
|
||||
* @brief Abbreviated logging macro for level #IOT_LOG_WARN.
|
||||
*
|
||||
* Equivalent to:
|
||||
* @code{c}
|
||||
* IotLog( IOT_LOG_WARN, NULL, ... )
|
||||
* @endcode
|
||||
*/
|
||||
|
||||
/**
|
||||
* @def IotLogInfo( ... )
|
||||
* @brief Abbreviated logging macro for level #IOT_LOG_INFO.
|
||||
*
|
||||
* Equivalent to:
|
||||
* @code{c}
|
||||
* IotLog( IOT_LOG_INFO, NULL, ... )
|
||||
* @endcode
|
||||
*/
|
||||
|
||||
/**
|
||||
* @def IotLogDebug( ... )
|
||||
* @brief Abbreviated logging macro for level #IOT_LOG_DEBUG.
|
||||
*
|
||||
* Equivalent to:
|
||||
* @code{c}
|
||||
* IotLog( IOT_LOG_DEBUG, NULL, ... )
|
||||
* @endcode
|
||||
*/
|
||||
|
||||
/* Check that LIBRARY_LOG_LEVEL is defined and has a valid value. */
|
||||
#if !defined( LIBRARY_LOG_LEVEL ) || \
|
||||
( LIBRARY_LOG_LEVEL != IOT_LOG_NONE && \
|
||||
LIBRARY_LOG_LEVEL != IOT_LOG_ERROR && \
|
||||
LIBRARY_LOG_LEVEL != IOT_LOG_WARN && \
|
||||
LIBRARY_LOG_LEVEL != IOT_LOG_INFO && \
|
||||
LIBRARY_LOG_LEVEL != IOT_LOG_DEBUG )
|
||||
#error "Please define LIBRARY_LOG_LEVEL as either IOT_LOG_NONE, IOT_LOG_ERROR, IOT_LOG_WARN, IOT_LOG_INFO, or IOT_LOG_DEBUG."
|
||||
/* Check that LIBRARY_LOG_NAME is defined and has a valid value. */
|
||||
#elif !defined( LIBRARY_LOG_NAME )
|
||||
#error "Please define LIBRARY_LOG_NAME."
|
||||
#else
|
||||
/* Define IotLog if the log level is greater than "none". */
|
||||
#if LIBRARY_LOG_LEVEL > IOT_LOG_NONE
|
||||
#define IotLog( messageLevel, pLogConfig, ... ) \
|
||||
IotLog_Generic( LIBRARY_LOG_LEVEL, \
|
||||
LIBRARY_LOG_NAME, \
|
||||
messageLevel, \
|
||||
pLogConfig, \
|
||||
__VA_ARGS__ )
|
||||
|
||||
/* Define the abbreviated logging macros. */
|
||||
#define IotLogError( ... ) IotLog( IOT_LOG_ERROR, NULL, __VA_ARGS__ )
|
||||
#define IotLogWarn( ... ) IotLog( IOT_LOG_WARN, NULL, __VA_ARGS__ )
|
||||
#define IotLogInfo( ... ) IotLog( IOT_LOG_INFO, NULL, __VA_ARGS__ )
|
||||
#define IotLogDebug( ... ) IotLog( IOT_LOG_DEBUG, NULL, __VA_ARGS__ )
|
||||
|
||||
/* If log level is DEBUG, enable the function to print buffers. */
|
||||
#if LIBRARY_LOG_LEVEL >= IOT_LOG_DEBUG
|
||||
#define IotLog_PrintBuffer( pHeader, pBuffer, bufferSize ) \
|
||||
IotLog_GenericPrintBuffer( LIBRARY_LOG_NAME, \
|
||||
pHeader, \
|
||||
pBuffer, \
|
||||
bufferSize )
|
||||
#else
|
||||
#define IotLog_PrintBuffer( pHeader, pBuffer, bufferSize )
|
||||
#endif
|
||||
/* Remove references to IotLog from the source code if logging is disabled. */
|
||||
#else
|
||||
/* @[declare_logging_log] */
|
||||
#define IotLog( messageLevel, pLogConfig, ... )
|
||||
/* @[declare_logging_log] */
|
||||
/* @[declare_logging_printbuffer] */
|
||||
#define IotLog_PrintBuffer( pHeader, pBuffer, bufferSize )
|
||||
/* @[declare_logging_printbuffer] */
|
||||
#define IotLogError( ... )
|
||||
#define IotLogWarn( ... )
|
||||
#define IotLogInfo( ... )
|
||||
#define IotLogDebug( ... )
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif /* ifndef IOT_LOGGING_SETUP_H_ */
|
||||
|
|
@ -0,0 +1,197 @@
|
|||
/*
|
||||
* IoT Common V1.1.0
|
||||
* Copyright (C) 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file iot_static_memory.h
|
||||
* @brief Common functions for managing static buffers. Only used when
|
||||
* @ref IOT_STATIC_MEMORY_ONLY is `1`.
|
||||
*/
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* The functions in this file should only exist in static memory only mode, hence
|
||||
* the check for IOT_STATIC_MEMORY_ONLY in the double inclusion guard. */
|
||||
#if !defined( IOT_STATIC_MEMORY_H_ ) && ( IOT_STATIC_MEMORY_ONLY == 1 )
|
||||
#define IOT_STATIC_MEMORY_H_
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/**
|
||||
* @functionspage{static_memory,static memory component}
|
||||
* - @functionname{static_memory_function_findfree}
|
||||
* - @functionname{static_memory_function_returninuse}
|
||||
* - @functionname{static_memory_function_messagebuffersize}
|
||||
* - @functionname{static_memory_function_mallocmessagebuffer}
|
||||
* - @functionname{static_memory_function_freemessagebuffer}
|
||||
*/
|
||||
|
||||
/*------------------------- Buffer allocation and free ----------------------*/
|
||||
|
||||
/**
|
||||
* @functionpage{IotStaticMemory_FindFree,static_memory,findfree}
|
||||
* @functionpage{IotStaticMemory_ReturnInUse,static_memory,returninuse}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Find a free buffer using the "in-use" flags.
|
||||
*
|
||||
* If a free buffer is found, this function marks the buffer in-use. This function
|
||||
* is common to the static memory implementation.
|
||||
*
|
||||
* @param[in] pInUse The "in-use" flags to search.
|
||||
* @param[in] limit How many flags to check, i.e. the size of `pInUse`.
|
||||
*
|
||||
* @return The index of a free buffer; `-1` if no free buffers are available.
|
||||
*
|
||||
* <b>Example</b>:
|
||||
* @code{c}
|
||||
* // To use this function, first declare two arrays. One provides the statically-allocated
|
||||
* // objects, the other provides flags to determine which objects are in-use.
|
||||
* #define NUMBER_OF_OBJECTS ...
|
||||
* #define OBJECT_SIZE ...
|
||||
* static uint32_t _pInUseObjects[ NUMBER_OF_OBJECTS ] = { 0 };
|
||||
* static uint8_t _pObjects[ NUMBER_OF_OBJECTS ][ OBJECT_SIZE ] = { { 0 } }; // Placeholder for objects.
|
||||
*
|
||||
* // The function to statically allocate objects. Must have the same signature
|
||||
* // as malloc().
|
||||
* void * Iot_MallocObject( size_t size )
|
||||
* {
|
||||
* int32_t freeIndex = -1;
|
||||
* void * pNewObject = NULL;
|
||||
*
|
||||
* // Check that sizes match.
|
||||
* if( size != OBJECT_SIZE )
|
||||
* {
|
||||
* // Get the index of a free object.
|
||||
* freeIndex = IotStaticMemory_FindFree( _pInUseMessageBuffers,
|
||||
* IOT_MESSAGE_BUFFERS );
|
||||
*
|
||||
* if( freeIndex != -1 )
|
||||
* {
|
||||
* pNewBuffer = &( _pMessageBuffers[ freeIndex ][ 0 ] );
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* return pNewBuffer;
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
/* @[declare_static_memory_findfree] */
|
||||
int32_t IotStaticMemory_FindFree( uint32_t * pInUse,
|
||||
size_t limit );
|
||||
/* @[declare_static_memory_findfree] */
|
||||
|
||||
/**
|
||||
* @brief Return an "in-use" buffer.
|
||||
*
|
||||
* This function is common to the static memory implementation.
|
||||
*
|
||||
* @param[in] ptr Pointer to the buffer to return.
|
||||
* @param[in] pPool The pool of buffers that the in-use buffer was allocated from.
|
||||
* @param[in] pInUse The "in-use" flags for pPool.
|
||||
* @param[in] limit How many buffers (and flags) to check while searching for ptr.
|
||||
* @param[in] elementSize The size of a single element in pPool.
|
||||
*
|
||||
* <b>Example</b>:
|
||||
* @code{c}
|
||||
* // To use this function, first declare two arrays. One provides the statically-allocated
|
||||
* // objects, the other provides flags to determine which objects are in-use.
|
||||
* #define NUMBER_OF_OBJECTS ...
|
||||
* #define OBJECT_SIZE ...
|
||||
* static uint32_t _pInUseObjects[ NUMBER_OF_OBJECTS ] = { 0 };
|
||||
* static uint8_t _pObjects[ NUMBER_OF_OBJECTS ][ OBJECT_SIZE ] = { { 0 } }; // Placeholder for objects.
|
||||
*
|
||||
* // The function to free statically-allocated objects. Must have the same signature
|
||||
* // as free().
|
||||
* void Iot_FreeObject( void * ptr )
|
||||
* {
|
||||
* IotStaticMemory_ReturnInUse( ptr,
|
||||
* _pObjects,
|
||||
* _pInUseObjects,
|
||||
* NUMBER_OF_OBJECTS,
|
||||
* OBJECT_SIZE );
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
/* @[declare_static_memory_returninuse] */
|
||||
void IotStaticMemory_ReturnInUse( void * ptr,
|
||||
void * pPool,
|
||||
uint32_t * pInUse,
|
||||
size_t limit,
|
||||
size_t elementSize );
|
||||
/* @[declare_static_memory_returninuse] */
|
||||
|
||||
/*------------------------ Message buffer management ------------------------*/
|
||||
|
||||
/**
|
||||
* @functionpage{Iot_MessageBufferSize,static_memory,messagebuffersize}
|
||||
* @functionpage{Iot_MallocMessageBuffer,static_memory,mallocmessagebuffer}
|
||||
* @functionpage{Iot_FreeMessageBuffer,static_memory,freemessagebuffer}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Get the fixed size of a message buffer.
|
||||
*
|
||||
* The size of the message buffers are known at compile time, but it is a [constant]
|
||||
* (@ref IOT_MESSAGE_BUFFER_SIZE) that may not be visible to all source files.
|
||||
* This function allows other source files to know the size of a message buffer.
|
||||
*
|
||||
* @return The size, in bytes, of a single message buffer.
|
||||
*/
|
||||
/* @[declare_static_memory_messagebuffersize] */
|
||||
size_t Iot_MessageBufferSize( void );
|
||||
/* @[declare_static_memory_messagebuffersize] */
|
||||
|
||||
/**
|
||||
* @brief Get an empty message buffer.
|
||||
*
|
||||
* This function is the analog of [malloc]
|
||||
* (http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html)
|
||||
* for message buffers.
|
||||
*
|
||||
* @param[in] size Requested size for a message buffer.
|
||||
*
|
||||
* @return Pointer to the start of a message buffer. If the `size` argument is larger
|
||||
* than the [fixed size of a message buffer](@ref IOT_MESSAGE_BUFFER_SIZE)
|
||||
* or no message buffers are available, `NULL` is returned.
|
||||
*/
|
||||
/* @[declare_static_memory_mallocmessagebuffer] */
|
||||
void * Iot_MallocMessageBuffer( size_t size );
|
||||
/* @[declare_static_memory_mallocmessagebuffer] */
|
||||
|
||||
/**
|
||||
* @brief Free an in-use message buffer.
|
||||
*
|
||||
* This function is the analog of [free]
|
||||
* (http://pubs.opengroup.org/onlinepubs/9699919799/functions/free.html)
|
||||
* for message buffers.
|
||||
*
|
||||
* @param[in] ptr Pointer to the message buffer to free.
|
||||
*/
|
||||
/* @[declare_static_memory_freemessagebuffer] */
|
||||
void Iot_FreeMessageBuffer( void * ptr );
|
||||
/* @[declare_static_memory_freemessagebuffer] */
|
||||
|
||||
#endif /* if !defined( IOT_STATIC_MEMORY_H_ ) && ( IOT_STATIC_MEMORY_ONLY == 1 ) */
|
||||
|
|
@ -0,0 +1,451 @@
|
|||
/*
|
||||
* IoT Common V1.1.0
|
||||
* Copyright (C) 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file iot_logging.c
|
||||
* @brief Implementation of logging functions from iot_logging.h
|
||||
*/
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
/* Platform clock include. */
|
||||
#include "platform/iot_clock.h"
|
||||
|
||||
/* Logging includes. */
|
||||
#include "iot_logging.h"
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* This implementation assumes the following values for the log level constants.
|
||||
* Ensure that the values have not been modified. */
|
||||
#if IOT_LOG_NONE != 0
|
||||
#error "IOT_LOG_NONE must be 0."
|
||||
#endif
|
||||
#if IOT_LOG_ERROR != 1
|
||||
#error "IOT_LOG_ERROR must be 1."
|
||||
#endif
|
||||
#if IOT_LOG_WARN != 2
|
||||
#error "IOT_LOG_WARN must be 2."
|
||||
#endif
|
||||
#if IOT_LOG_INFO != 3
|
||||
#error "IOT_LOG_INFO must be 3."
|
||||
#endif
|
||||
#if IOT_LOG_DEBUG != 4
|
||||
#error "IOT_LOG_DEBUG must be 4."
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @def IotLogging_Puts( message )
|
||||
* @brief Function the logging library uses to print a line.
|
||||
*
|
||||
* This function can be set by using a define. By default, the standard library
|
||||
* [puts](http://pubs.opengroup.org/onlinepubs/9699919799/functions/puts.html)
|
||||
* function is used.
|
||||
*/
|
||||
#ifndef IotLogging_Puts
|
||||
#define IotLogging_Puts puts
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Provide default values for undefined memory allocation functions based on
|
||||
* the usage of dynamic memory allocation.
|
||||
*/
|
||||
#if IOT_STATIC_MEMORY_ONLY == 1
|
||||
/* Static memory allocation header. */
|
||||
#include "iot_static_memory.h"
|
||||
|
||||
/**
|
||||
* @brief Allocate a new logging buffer. This function must have the same
|
||||
* signature as [malloc](http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html).
|
||||
*/
|
||||
#ifndef IotLogging_Malloc
|
||||
#define IotLogging_Malloc Iot_MallocMessageBuffer
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Free a logging buffer. This function must have the same signature
|
||||
* as [free](http://pubs.opengroup.org/onlinepubs/9699919799/functions/free.html).
|
||||
*/
|
||||
#ifndef IotLogging_Free
|
||||
#define IotLogging_Free Iot_FreeMessageBuffer
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Get the size of a logging buffer. Statically-allocated buffers
|
||||
* should all have the same size.
|
||||
*/
|
||||
#ifndef IotLogging_StaticBufferSize
|
||||
#define IotLogging_StaticBufferSize Iot_MessageBufferSize
|
||||
#endif
|
||||
#else /* if IOT_STATIC_MEMORY_ONLY == 1 */
|
||||
#ifndef IotLogging_Malloc
|
||||
#include <stdlib.h>
|
||||
#define IotLogging_Malloc malloc
|
||||
#endif
|
||||
|
||||
#ifndef IotLogging_Free
|
||||
#include <stdlib.h>
|
||||
#define IotLogging_Free free
|
||||
#endif
|
||||
#endif /* if IOT_STATIC_MEMORY_ONLY == 1 */
|
||||
|
||||
/**
|
||||
* @brief A guess of the maximum length of a timestring.
|
||||
*
|
||||
* There's no way for this logging library to know the length of a timestring
|
||||
* before it's generated. Therefore, the logging library will assume a maximum
|
||||
* length of any timestring it may get. This value should be generous enough
|
||||
* to accommodate the vast majority of timestrings.
|
||||
*
|
||||
* @see @ref platform_clock_function_gettimestring
|
||||
*/
|
||||
#define MAX_TIMESTRING_LENGTH ( 64 )
|
||||
|
||||
/**
|
||||
* @brief The longest string in #_pLogLevelStrings (below), plus 3 to accommodate
|
||||
* `[]` and a null-terminator.
|
||||
*/
|
||||
#define MAX_LOG_LEVEL_LENGTH ( 8 )
|
||||
|
||||
/**
|
||||
* @brief How many bytes @ref logging_function_genericprintbuffer should output on
|
||||
* each line.
|
||||
*/
|
||||
#define BYTES_PER_LINE ( 16 )
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Lookup table for log levels.
|
||||
*
|
||||
* Converts one of the @ref logging_constants_levels to a string.
|
||||
*/
|
||||
static const char * const _pLogLevelStrings[ 5 ] =
|
||||
{
|
||||
"", /* IOT_LOG_NONE */
|
||||
"ERROR", /* IOT_LOG_ERROR */
|
||||
"WARN ", /* IOT_LOG_WARN */
|
||||
"INFO ", /* IOT_LOG_INFO */
|
||||
"DEBUG" /* IOT_LOG_DEBUG */
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if !defined( IOT_STATIC_MEMORY_ONLY ) || ( IOT_STATIC_MEMORY_ONLY == 0 )
|
||||
static bool _reallocLoggingBuffer( void ** pOldBuffer,
|
||||
size_t newSize,
|
||||
size_t oldSize )
|
||||
{
|
||||
bool status = false;
|
||||
|
||||
/* Allocate a new, larger buffer. */
|
||||
void * pNewBuffer = IotLogging_Malloc( newSize );
|
||||
|
||||
/* Ensure that memory allocation succeeded. */
|
||||
if( pNewBuffer != NULL )
|
||||
{
|
||||
/* Copy the data from the old buffer to the new buffer. */
|
||||
( void ) memcpy( pNewBuffer, *pOldBuffer, oldSize );
|
||||
|
||||
/* Free the old buffer and update the pointer. */
|
||||
IotLogging_Free( *pOldBuffer );
|
||||
*pOldBuffer = pNewBuffer;
|
||||
|
||||
status = true;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
#endif /* if !defined( IOT_STATIC_MEMORY_ONLY ) || ( IOT_STATIC_MEMORY_ONLY == 0 ) */
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotLog_Generic( int libraryLogSetting,
|
||||
const char * const pLibraryName,
|
||||
int messageLevel,
|
||||
const IotLogConfig_t * const pLogConfig,
|
||||
const char * const pFormat,
|
||||
... )
|
||||
{
|
||||
int requiredMessageSize = 0;
|
||||
size_t bufferSize = 0,
|
||||
bufferPosition = 0, timestringLength = 0;
|
||||
char * pLoggingBuffer = NULL;
|
||||
va_list args;
|
||||
|
||||
/* If the library's log level setting is lower than the message level,
|
||||
* return without doing anything. */
|
||||
if( ( messageLevel == 0 ) || ( messageLevel > libraryLogSetting ) )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if( ( pLogConfig == NULL ) || ( pLogConfig->hideLogLevel == false ) )
|
||||
{
|
||||
/* Add length of log level if requested. */
|
||||
bufferSize += MAX_LOG_LEVEL_LENGTH;
|
||||
}
|
||||
|
||||
/* Estimate the amount of buffer needed for this log message. */
|
||||
if( ( pLogConfig == NULL ) || ( pLogConfig->hideLibraryName == false ) )
|
||||
{
|
||||
/* Add size of library name if requested. Add 2 to accommodate "[]". */
|
||||
bufferSize += strlen( pLibraryName ) + 2;
|
||||
}
|
||||
|
||||
if( ( pLogConfig == NULL ) || ( pLogConfig->hideTimestring == false ) )
|
||||
{
|
||||
/* Add length of timestring if requested. */
|
||||
bufferSize += MAX_TIMESTRING_LENGTH;
|
||||
}
|
||||
|
||||
/* Add 64 as an initial (arbitrary) guess for the length of the message. */
|
||||
bufferSize += 64;
|
||||
|
||||
/* In static memory mode, check that the log message will fit in the a
|
||||
* static buffer. */
|
||||
#if IOT_STATIC_MEMORY_ONLY == 1
|
||||
if( bufferSize >= IotLogging_StaticBufferSize() )
|
||||
{
|
||||
/* If the static buffers are likely too small to fit the log message,
|
||||
* return. */
|
||||
return;
|
||||
}
|
||||
|
||||
/* Otherwise, update the buffer size to the size of a static buffer. */
|
||||
bufferSize = IotLogging_StaticBufferSize();
|
||||
#endif
|
||||
|
||||
/* Allocate memory for the logging buffer. */
|
||||
pLoggingBuffer = ( char * ) IotLogging_Malloc( bufferSize );
|
||||
|
||||
if( pLoggingBuffer == NULL )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/* Print the message log level if requested. */
|
||||
if( ( pLogConfig == NULL ) || ( pLogConfig->hideLogLevel == false ) )
|
||||
{
|
||||
/* Ensure that message level is valid. */
|
||||
if( ( messageLevel >= IOT_LOG_NONE ) && ( messageLevel <= IOT_LOG_DEBUG ) )
|
||||
{
|
||||
/* Add the log level string to the logging buffer. */
|
||||
requiredMessageSize = snprintf( pLoggingBuffer + bufferPosition,
|
||||
bufferSize - bufferPosition,
|
||||
"[%s]",
|
||||
_pLogLevelStrings[ messageLevel ] );
|
||||
|
||||
/* Check for encoding errors. */
|
||||
if( requiredMessageSize <= 0 )
|
||||
{
|
||||
IotLogging_Free( pLoggingBuffer );
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* Update the buffer position. */
|
||||
bufferPosition += ( size_t ) requiredMessageSize;
|
||||
}
|
||||
}
|
||||
|
||||
/* Print the library name if requested. */
|
||||
if( ( pLogConfig == NULL ) || ( pLogConfig->hideLibraryName == false ) )
|
||||
{
|
||||
/* Add the library name to the logging buffer. */
|
||||
requiredMessageSize = snprintf( pLoggingBuffer + bufferPosition,
|
||||
bufferSize - bufferPosition,
|
||||
"[%s]",
|
||||
pLibraryName );
|
||||
|
||||
/* Check for encoding errors. */
|
||||
if( requiredMessageSize <= 0 )
|
||||
{
|
||||
IotLogging_Free( pLoggingBuffer );
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* Update the buffer position. */
|
||||
bufferPosition += ( size_t ) requiredMessageSize;
|
||||
}
|
||||
|
||||
/* Print the timestring if requested. */
|
||||
if( ( pLogConfig == NULL ) || ( pLogConfig->hideTimestring == false ) )
|
||||
{
|
||||
/* Add the opening '[' enclosing the timestring. */
|
||||
pLoggingBuffer[ bufferPosition ] = '[';
|
||||
bufferPosition++;
|
||||
|
||||
/* Generate the timestring and add it to the buffer. */
|
||||
if( IotClock_GetTimestring( pLoggingBuffer + bufferPosition,
|
||||
bufferSize - bufferPosition,
|
||||
×tringLength ) == true )
|
||||
{
|
||||
/* If the timestring was successfully generated, add the closing "]". */
|
||||
bufferPosition += timestringLength;
|
||||
pLoggingBuffer[ bufferPosition ] = ']';
|
||||
bufferPosition++;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Sufficient memory for a timestring should have been allocated. A timestring
|
||||
* probably failed to generate due to a clock read error; remove the opening '['
|
||||
* from the logging buffer. */
|
||||
bufferPosition--;
|
||||
pLoggingBuffer[ bufferPosition ] = '\0';
|
||||
}
|
||||
}
|
||||
|
||||
/* Add a padding space between the last closing ']' and the message, unless
|
||||
* the logging buffer is empty. */
|
||||
if( bufferPosition > 0 )
|
||||
{
|
||||
pLoggingBuffer[ bufferPosition ] = ' ';
|
||||
bufferPosition++;
|
||||
}
|
||||
|
||||
va_start( args, pFormat );
|
||||
|
||||
/* Add the log message to the logging buffer. */
|
||||
requiredMessageSize = vsnprintf( pLoggingBuffer + bufferPosition,
|
||||
bufferSize - bufferPosition,
|
||||
pFormat,
|
||||
args );
|
||||
|
||||
va_end( args );
|
||||
|
||||
/* If the logging buffer was too small to fit the log message, reallocate
|
||||
* a larger logging buffer. */
|
||||
if( ( size_t ) requiredMessageSize >= bufferSize - bufferPosition )
|
||||
{
|
||||
#if IOT_STATIC_MEMORY_ONLY == 1
|
||||
|
||||
/* There's no point trying to allocate a larger static buffer. Return
|
||||
* immediately. */
|
||||
IotLogging_Free( pLoggingBuffer );
|
||||
|
||||
return;
|
||||
#else
|
||||
if( _reallocLoggingBuffer( ( void ** ) &pLoggingBuffer,
|
||||
( size_t ) requiredMessageSize + bufferPosition + 1,
|
||||
bufferSize ) == false )
|
||||
{
|
||||
/* If buffer reallocation failed, return. */
|
||||
IotLogging_Free( pLoggingBuffer );
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* Reallocation successful, update buffer size. */
|
||||
bufferSize = ( size_t ) requiredMessageSize + bufferPosition + 1;
|
||||
|
||||
/* Add the log message to the buffer. Now that the buffer has been
|
||||
* reallocated, this should succeed. */
|
||||
va_start( args, pFormat );
|
||||
requiredMessageSize = vsnprintf( pLoggingBuffer + bufferPosition,
|
||||
bufferSize - bufferPosition,
|
||||
pFormat,
|
||||
args );
|
||||
va_end( args );
|
||||
#endif /* if IOT_STATIC_MEMORY_ONLY == 1 */
|
||||
}
|
||||
|
||||
/* Check for encoding errors. */
|
||||
if( requiredMessageSize <= 0 )
|
||||
{
|
||||
IotLogging_Free( pLoggingBuffer );
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* Print the logging buffer to stdout. */
|
||||
IotLogging_Puts( pLoggingBuffer );
|
||||
|
||||
/* Free the logging buffer. */
|
||||
IotLogging_Free( pLoggingBuffer );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotLog_GenericPrintBuffer( const char * const pLibraryName,
|
||||
const char * const pHeader,
|
||||
const uint8_t * const pBuffer,
|
||||
size_t bufferSize )
|
||||
{
|
||||
size_t i = 0, offset = 0;
|
||||
|
||||
/* Allocate memory to hold each line of the log message. Since each byte
|
||||
* of pBuffer is printed in 4 characters (2 digits, a space, and a null-
|
||||
* terminator), the size of each line is 4 * BYTES_PER_LINE. */
|
||||
char * pMessageBuffer = IotLogging_Malloc( 4 * BYTES_PER_LINE );
|
||||
|
||||
/* Exit if no memory is available. */
|
||||
if( pMessageBuffer == NULL )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/* Print pHeader before printing pBuffer. */
|
||||
if( pHeader != NULL )
|
||||
{
|
||||
IotLog_Generic( IOT_LOG_DEBUG,
|
||||
pLibraryName,
|
||||
IOT_LOG_DEBUG,
|
||||
NULL,
|
||||
pHeader );
|
||||
}
|
||||
|
||||
/* Print each byte in pBuffer. */
|
||||
for( i = 0; i < bufferSize; i++ )
|
||||
{
|
||||
/* Print a line if BYTES_PER_LINE is reached. But don't print a line
|
||||
* at the beginning (when i=0). */
|
||||
if( ( i % BYTES_PER_LINE == 0 ) && ( i != 0 ) )
|
||||
{
|
||||
IotLogging_Puts( pMessageBuffer );
|
||||
|
||||
/* Reset offset so that pMessageBuffer is filled from the beginning. */
|
||||
offset = 0;
|
||||
}
|
||||
|
||||
/* Print a single byte into pMessageBuffer. */
|
||||
( void ) snprintf( pMessageBuffer + offset, 4, "%02x ", pBuffer[ i ] );
|
||||
|
||||
/* Move the offset where the next character is printed. */
|
||||
offset += 3;
|
||||
}
|
||||
|
||||
/* Print the final line of bytes. This line isn't printed by the for-loop above. */
|
||||
IotLogging_Puts( pMessageBuffer );
|
||||
|
||||
/* Free memory used by this function. */
|
||||
IotLogging_Free( pMessageBuffer );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
Loading…
Add table
Add a link
Reference in a new issue