Sync to ETL 20.44.2

Author: John Wellbelove

library.json

@@ -1,6 +1,6 @@
 {
   "name": "Embedded Template Library ETL",
-  "version": "20.44.1",
+  "version": "20.44.2",
   "authors": {
     "name": "John Wellbelove",
     "email": "[email protected]"

library.properties

@@ -1,5 +1,5 @@
 name=Embedded Template Library ETL
-version=20.44.1
+version=20.44.2
 author= John Wellbelove <[email protected]>
 maintainer=John Wellbelove <[email protected]>
 license=MIT

src/etl/absolute.h

@@ -31,6 +31,7 @@ SOFTWARE.
 #ifndef ETL_ABSOLUTE_INCLUDED
 #define ETL_ABSOLUTE_INCLUDED
 
+#include "platform.h"
 #include "type_traits.h"
 #include "integral_limits.h"
 

src/etl/basic_string.h

@@ -560,6 +560,7 @@ namespace etl
     //*********************************************************************
     reference operator [](size_type i)
     {
+      ETL_ASSERT_CHECK_INDEX_OPERATOR(i < size(), ETL_ERROR(string_out_of_bounds));
       return p_buffer[i];
     }
 
@@ -570,6 +571,7 @@ namespace etl
     //*********************************************************************
     const_reference operator [](size_type i) const
     {
+      ETL_ASSERT_CHECK_INDEX_OPERATOR(i < size(), ETL_ERROR(string_out_of_bounds));
       return p_buffer[i];
     }
 
@@ -603,6 +605,7 @@ namespace etl
     //*********************************************************************
     reference front()
     {
+      ETL_ASSERT_CHECK_EXTRA(size() > 0, ETL_ERROR(string_out_of_bounds));
       return p_buffer[0];
     }
 
@@ -612,6 +615,7 @@ namespace etl
     //*********************************************************************
     const_reference front() const
     {
+      ETL_ASSERT_CHECK_EXTRA(size() > 0, ETL_ERROR(string_out_of_bounds));
       return p_buffer[0];
     }
 
@@ -621,7 +625,8 @@ namespace etl
     //*********************************************************************
     reference back()
     {
-      return p_buffer[current_size - 1];
+      ETL_ASSERT_CHECK_EXTRA(size() > 0, ETL_ERROR(string_out_of_bounds));
+      return p_buffer[size() - 1];
     }
 
     //*********************************************************************
@@ -630,7 +635,8 @@ namespace etl
     //*********************************************************************
     const_reference back() const
     {
-      return p_buffer[current_size - 1];
+      ETL_ASSERT_CHECK_EXTRA(size() > 0, ETL_ERROR(string_out_of_bounds));
+      return p_buffer[size() - 1];
     }
 
     //*********************************************************************
@@ -764,7 +770,7 @@ namespace etl
       set_truncated(n > CAPACITY);
 
 #if ETL_HAS_ERROR_ON_STRING_TRUNCATION
-      ETL_ASSERT(is_truncated == false, ETL_ERROR(string_truncation));
+      ETL_ASSERT(is_truncated() == false, ETL_ERROR(string_truncation));
 #endif
 #endif
 
@@ -912,7 +918,7 @@ namespace etl
       set_truncated(n > free_space);
 
 #if ETL_HAS_ERROR_ON_STRING_TRUNCATION
-      ETL_ASSERT(is_truncated == false, ETL_ERROR(string_truncation));
+      ETL_ASSERT(is_truncated() == false, ETL_ERROR(string_truncation));
 #endif
 #endif
 
@@ -932,6 +938,8 @@ namespace etl
     //*********************************************************************
     iterator insert(const_iterator position, T value)
     {
+      ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(string_out_of_bounds));
+
       // Quick hack, as iterators are pointers.
       iterator insert_position = to_iterator(position);
 
@@ -984,6 +992,8 @@ namespace etl
     //*********************************************************************
     iterator insert(const_iterator position, size_type n, T value)
     {
+      ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(string_out_of_bounds));
+
       iterator position_ = to_iterator(position);
 
       if (n == 0)
@@ -1071,6 +1081,9 @@ namespace etl
     template <typename TIterator>
     iterator insert(const_iterator position, TIterator first, TIterator last)
     {
+      ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(string_out_of_bounds));
+      ETL_ASSERT_CHECK_EXTRA(first <= last, ETL_ERROR(string_iterator));
+      
       iterator position_ = to_iterator(position);
 
       if (first == last)
@@ -1307,6 +1320,8 @@ namespace etl
     //*********************************************************************
     etl::ibasic_string<T>& erase(size_type position, size_type length_ = npos)
     {
+      ETL_ASSERT_CHECK_EXTRA(position <= size(), ETL_ERROR(string_out_of_bounds));
+
       // Limit the length.
       length_ = etl::min(length_, size() - position);
 
@@ -1322,6 +1337,8 @@ namespace etl
     //*********************************************************************
     iterator erase(iterator i_element)
     {
+      ETL_ASSERT_CHECK_EXTRA(cbegin() <= i_element && i_element < cend(), ETL_ERROR(string_out_of_bounds));
+
       etl::mem_move(i_element + 1, end(), i_element);
       p_buffer[--current_size] = 0;
 
@@ -1335,6 +1352,8 @@ namespace etl
     //*********************************************************************
     iterator erase(const_iterator i_element)
     {
+      ETL_ASSERT_CHECK_EXTRA(cbegin() <= i_element && i_element < cend(), ETL_ERROR(string_out_of_bounds));
+      
       iterator i_element_(to_iterator(i_element));
 
       etl::mem_move(i_element + 1, end(), i_element_);
@@ -1353,6 +1372,8 @@ namespace etl
     //*********************************************************************
     iterator erase(const_iterator first, const_iterator last)
     {
+      ETL_ASSERT_CHECK_EXTRA(cbegin() <= first && first <= last && last <= cend(), ETL_ERROR(string_out_of_bounds));
+
       iterator first_ = to_iterator(first);
       iterator last_  = to_iterator(last);
 
@@ -2753,15 +2774,19 @@ namespace etl
       set_truncated((count > free_space) || this->is_truncated() || truncated);
 
 #if ETL_HAS_ERROR_ON_STRING_TRUNCATION
-      ETL_ASSERT(is_truncated == false, ETL_ERROR(string_truncation));
+      ETL_ASSERT(is_truncated() == false, ETL_ERROR(string_truncation));
 #endif
+#else
+      (void)truncated;
 #endif
 
 #if ETL_HAS_STRING_CLEAR_AFTER_USE
       if (secure)
       {
         set_secure();
       }
+#else
+      (void)secure;
 #endif
 
       // Limit the actual distance to the capacity.
@@ -2799,15 +2824,19 @@ namespace etl
 #if ETL_HAS_STRING_TRUNCATION_CHECKS
       set_truncated(truncated);
 #if ETL_HAS_ERROR_ON_STRING_TRUNCATION
-      ETL_ASSERT(is_truncated == false, ETL_ERROR(string_truncation));
+      ETL_ASSERT(is_truncated() == false, ETL_ERROR(string_truncation));
 #endif
+#else
+      (void)truncated;
 #endif
 
 #if ETL_HAS_STRING_CLEAR_AFTER_USE
       if (secure)
       {
         set_secure();
       }
+#else
+      (void)secure;
 #endif
 
       cleanup();

src/etl/callback_timer_deferred_locked.h

@@ -29,6 +29,7 @@ SOFTWARE.
 #ifndef ETL_CALLBACK_TIMER_DEFERRED_LOCKED_INCLUDED
 #define ETL_CALLBACK_TIMER_DEFERRED_LOCKED_INCLUDED
 
+#include "platform.h"
 #include "callback_timer_locked.h"
 #include "etl/nullptr.h"
 #include "etl/optional.h"

src/etl/fsm.h

@@ -172,6 +172,19 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Exception for call to receive/start/etc. while receive/start/etc. is already happening.
+  /// A call like that could result in an infinite loop or landing in an incorrect state.
+  //***************************************************************************
+  class fsm_reentrant_transition_forbidden : public etl::fsm_exception
+  {
+  public:
+    fsm_reentrant_transition_forbidden(string_type file_name_, numeric_type line_number_)
+      : etl::fsm_exception(ETL_ERROR_TEXT("fsm:reentrant calls to start/receive/etc. forbidden", ETL_FSM_FILE_ID"G"), file_name_, line_number_)
+    {
+    }
+  };
+
   namespace private_fsm
   {
     template <typename T = void>
@@ -209,6 +222,47 @@ namespace etl
       : etl::integral_constant<bool, (TState0::STATE_ID == Id) && private_fsm::check_ids<Id + 1, TRest...>::value> 
     {
     };   
+
+    //***************************************************************************
+    /// RAII detection mechanism to catch reentrant calls to methods that might
+    /// transition the state machine to a different state.
+    /// This is not a mutex.
+    //***************************************************************************
+    class fsm_reentrancy_guard
+    {
+    public:
+      //*******************************************
+      /// Constructor.
+      /// Checks if another method has locked reentrancy.
+      //*******************************************
+      fsm_reentrancy_guard(bool& transition_guard_flag)
+        : is_locked(transition_guard_flag)
+      {
+        ETL_ASSERT(!is_locked, ETL_ERROR(etl::fsm_reentrant_transition_forbidden));
+        is_locked = true;
+      }
+
+      //*******************************************
+      /// Destructor.
+      /// Releases lock on reentrancy.
+      //*******************************************
+      ~fsm_reentrancy_guard() ETL_NOEXCEPT
+      {
+        is_locked = false;
+      }
+      
+    private:
+      // Reference to the flag signifying a lock on the state machine.
+      bool& is_locked;
+      
+      // Copy & move semantics disabled since this is a guard.
+      fsm_reentrancy_guard(fsm_reentrancy_guard const&) ETL_DELETE;
+      fsm_reentrancy_guard& operator= (fsm_reentrancy_guard const&) ETL_DELETE;
+#if ETL_USING_CPP11
+      fsm_reentrancy_guard(fsm_reentrancy_guard&&) ETL_DELETE;
+      fsm_reentrancy_guard& operator= (fsm_reentrancy_guard&&) ETL_DELETE;
+#endif
+    };
   }
 
   class ifsm_state;
@@ -417,6 +471,7 @@ namespace etl
       , p_state(ETL_NULLPTR)
       , state_list(ETL_NULLPTR)
       , number_of_states(0U)
+      , is_processing_state_change(false)
     {
     }
 
@@ -467,6 +522,8 @@ namespace etl
     //*******************************************
     virtual void start(bool call_on_enter_state = true)
     {
+      private_fsm::fsm_reentrancy_guard transition_lock(is_processing_state_change);
+
       // Can only be started once.
       if (!is_started())
       {
@@ -497,6 +554,8 @@ namespace etl
     //*******************************************
     void receive(const etl::imessage& message) ETL_OVERRIDE
     {
+      private_fsm::fsm_reentrancy_guard transition_lock(is_processing_state_change);
+
       if (is_started())
       {
         etl::fsm_state_id_t next_state_id = p_state->process_event(message);
@@ -514,6 +573,8 @@ namespace etl
     //*******************************************
     etl::fsm_state_id_t transition_to(etl::fsm_state_id_t new_state_id)
     {
+      private_fsm::fsm_reentrancy_guard transition_lock(is_processing_state_change);
+
       if (is_started())
       {
         return process_state_change(new_state_id);
@@ -576,6 +637,8 @@ namespace etl
     //*******************************************
     virtual void reset(bool call_on_exit_state = false)
     {
+      private_fsm::fsm_reentrancy_guard transition_lock(is_processing_state_change);
+
       if (is_started() && call_on_exit_state)
       {
         p_state->on_exit_state();
@@ -655,6 +718,7 @@ namespace etl
     etl::ifsm_state*    p_state;          ///< A pointer to the current state.
     etl::ifsm_state**   state_list;       ///< The list of added states.
     etl::fsm_state_id_t number_of_states; ///< The number of states.
+    bool is_processing_state_change;      ///< Whether a method call that could potentially trigger a state change is active
   };
 
   //*************************************************************************************************