text: /*
   * FreeRTOS Kernel V10.4.3
   * Copyright (C) 2020 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.
   *
   * https://www.FreeRTOS.org
   * https://github.com/FreeRTOS
   *
   */
  
  
  #include <stdlib.h>
  
  /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
   * all the API functions to use the MPU wrappers.  That should only be done when
   * task.h is included from an application file. */
  #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  
  #include "FreeRTOS.h"
  #include "list.h"
  
  /* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified
   * because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be
   * defined for the header files above, but not in this file, in order to
   * generate the correct privileged Vs unprivileged linkage and placement. */
  #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021. */
  
  /*-----------------------------------------------------------
  * PUBLIC LIST API documented in list.h
  *----------------------------------------------------------*/
  
  void vListInitialise( List_t * const pxList )
  {
      /* The list structure contains a list item which is used to mark the
       * end of the list.  To initialise the list the list end is inserted
       * as the only list entry. */
      pxList->pxIndex = ( ListItem_t * ) &( pxList->xListEnd ); /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
  
      /* The list end value is the highest possible value in the list to
       * ensure it remains at the end of the list. */
      pxList->xListEnd.xItemValue = portMAX_DELAY;
  
      /* The list end next and previous pointers point to itself so we know
       * when the list is empty. */
      pxList->xListEnd.pxNext = ( ListItem_t * ) &( pxList->xListEnd );     /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
      pxList->xListEnd.pxPrevious = ( ListItem_t * ) &( pxList->xListEnd ); /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
  
      pxList->uxNumberOfItems = ( UBaseType_t ) 0U;
  
      /* Write known values into the list if
       * configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
      listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList );
      listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList );
  }
  /*-----------------------------------------------------------*/
  
  void vListInitialiseItem( ListItem_t * const pxItem )
  {
      /* Make sure the list item is not recorded as being on a list. */
      pxItem->pxContainer = NULL;
  
      /* Write known values into the list item if
       * configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
      listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
      listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
  }
  /*-----------------------------------------------------------*/
  
  void vListInsertEnd( List_t * const pxList,
                       ListItem_t * const pxNewListItem )
  {
      ListItem_t * const pxIndex = pxList->pxIndex;
  
      /* Only effective when configASSERT() is also defined, these tests may catch
       * the list data structures being overwritten in memory.  They will not catch
       * data errors caused by incorrect configuration or use of FreeRTOS. */
      listTEST_LIST_INTEGRITY( pxList );
      listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
  
      /* Insert a new list item into pxList, but rather than sort the list,
       * makes the new list item the last item to be removed by a call to
       * listGET_OWNER_OF_NEXT_ENTRY(). */
      pxNewListItem->pxNext = pxIndex;
      pxNewListItem->pxPrevious = pxIndex->pxPrevious;
  
      /* Only used during decision coverage testing. */
      mtCOVERAGE_TEST_DELAY();
  
      pxIndex->pxPrevious->pxNext = pxNewListItem;
      pxIndex->pxPrevious = pxNewListItem;
  
      /* Remember which list the item is in. */
      pxNewListItem->pxContainer = pxList;
  
      ( pxList->uxNumberOfItems )++;
  }
  /*-----------------------------------------------------------*/
  
  void vListInsert( List_t * const pxList,
                    ListItem_t * const pxNewListItem )
  {
      ListItem_t * pxIterator;
      const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
  
      /* Only effective when configASSERT() is also defined, these tests may catch
       * the list data structures being overwritten in memory.  They will not catch
       * data errors caused by incorrect configuration or use of FreeRTOS. */
      listTEST_LIST_INTEGRITY( pxList );
      listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
  
      /* Insert the new list item into the list, sorted in xItemValue order.
       *
       * If the list already contains a list item with the same item value then the
       * new list item should be placed after it.  This ensures that TCBs which are
       * stored in ready lists (all of which have the same xItemValue value) get a
       * share of the CPU.  However, if the xItemValue is the same as the back marker
       * the iteration loop below will not end.  Therefore the value is checked
       * first, and the algorithm slightly modified if necessary. */
      if( xValueOfInsertion == portMAX_DELAY )
      {
          pxIterator = pxList->xListEnd.pxPrevious;
      }
      else
      {
          /* *** NOTE ***********************************************************
          *  If you find your application is crashing here then likely causes are
          *  listed below.  In addition see https://www.FreeRTOS.org/FAQHelp.html for
          *  more tips, and ensure configASSERT() is defined!
          *  https://www.FreeRTOS.org/a00110.html#configASSERT
          *
          *   1) Stack overflow -
          *      see https://www.FreeRTOS.org/Stacks-and-stack-overflow-checking.html
          *   2) Incorrect interrupt priority assignment, especially on Cortex-M
          *      parts where numerically high priority values denote low actual
          *      interrupt priorities, which can seem counter intuitive.  See
          *      https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html and the definition
          *      of configMAX_SYSCALL_INTERRUPT_PRIORITY on
          *      https://www.FreeRTOS.org/a00110.html
          *   3) Calling an API function from within a critical section or when
          *      the scheduler is suspended, or calling an API function that does
          *      not end in "FromISR" from an interrupt.
          *   4) Using a queue or semaphore before it has been initialised or
          *      before the scheduler has been started (are interrupts firing
          *      before vTaskStartScheduler() has been called?).
          *   5) If the FreeRTOS port supports interrupt nesting then ensure that
          *      the priority of the tick interrupt is at or below
          *      configMAX_SYSCALL_INTERRUPT_PRIORITY.
          **********************************************************************/
  
          for( pxIterator = ( ListItem_t * ) &( pxList->xListEnd ); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext ) /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. *//*lint !e440 The iterator moves to a different value, not xValueOfInsertion. */
          {
              /* There is nothing to do here, just iterating to the wanted
               * insertion position. */
          }
      }
  
      pxNewListItem->pxNext = pxIterator->pxNext;
      pxNewListItem->pxNext->pxPrevious = pxNewListItem;
      pxNewListItem->pxPrevious = pxIterator;
      pxIterator->pxNext = pxNewListItem;
  
      /* Remember which list the item is in.  This allows fast removal of the
       * item later. */
      pxNewListItem->pxContainer = pxList;
  
      ( pxList->uxNumberOfItems )++;
  }
  /*-----------------------------------------------------------*/
  
  UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove )
  {
  /* The list item knows which list it is in.  Obtain the list from the list
   * item. */
      List_t * const pxList = pxItemToRemove->pxContainer;
  
      pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious;
      pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;
  
      /* Only used during decision coverage testing. */
      mtCOVERAGE_TEST_DELAY();
  
      /* Make sure the index is left pointing to a valid item. */
      if( pxList->pxIndex == pxItemToRemove )
      {
          pxList->pxIndex = pxItemToRemove->pxPrevious;
      }
      else
      {
          mtCOVERAGE_TEST_MARKER();
      }
  
      pxItemToRemove->pxContainer = NULL;
      ( pxList->uxNumberOfItems )--;
  
      return pxList->uxNumberOfItems;
  }
  /*-----------------------------------------------------------*/
  