diff --git a/basic_intrusive_forward_list.h b/basic_intrusive_forward_list.h
index ce1342bcc..ab92b8835 100644
--- a/basic_intrusive_forward_list.h
+++ b/basic_intrusive_forward_list.h
@@ -45,9 +45,38 @@ SOFTWARE.
 #include "nullptr.h"
 #include "type_traits.h"
 #include "basic_intrusive_forward_list_node.h"
+#include "error_handler.h"
 
 namespace etl
 {
+  //***************************************************************************
+  /// Exception for the intrusive_forward_list.
+  ///\ingroup intrusive_forward_list
+  //***************************************************************************
+  class basic_intrusive_forward_list_exception : public exception
+  {
+  public:
+
+    basic_intrusive_forward_list_exception(string_type what, string_type file_name, numeric_type line_number)
+      : exception(what, file_name, line_number)
+    {
+    }
+  };
+
+  //***************************************************************************
+  /// Empty exception for the intrusive_forward_list.
+  ///\ingroup intrusive_forward_list
+  //***************************************************************************
+  class basic_intrusive_forward_list_empty : public basic_intrusive_forward_list_exception
+  {
+  public:
+
+    basic_intrusive_forward_list_empty(string_type file_name, numeric_type line_number)
+      : basic_intrusive_forward_list_exception(ETL_ERROR_TEXT("basic_intrusive_forward_list:empty", ETL_FILE"A"), file_name, line_number)
+    {
+    }
+  };
+
   //***************************************************************************
   /// An intrusive forward list.
   ///\ingroup basic_intrusive_forward_list
@@ -400,10 +429,8 @@ namespace etl
     //*************************************************************************
     void pop_front()
     {
-      if (!empty())
-      {
-        remove_node_after(start_node);
-      }
+      ETL_ASSERT(!empty(), ETL_ERROR(basic_intrusive_forward_list_empty));
+      remove_node_after(start_node);
     }
 
     //*************************************************************************
diff --git a/bitset.h b/bitset.h
index 76861847f..f3b06881e 100644
--- a/bitset.h
+++ b/bitset.h
@@ -138,10 +138,8 @@ namespace etl
     //*************************************************************************
     bitset<N>& set(const char* text)
     {
-      if (ETL_ASSERT(text != 0, ETL_ERROR(bitset_nullptr)))
-      {
-        ibitset::set(text);
-      }
+      ETL_ASSERT(text != 0, ETL_ERROR(bitset_nullptr));
+      ibitset::set(text);
 
       return *this;
     }
diff --git a/error_handler.h b/error_handler.h
index c1940c592..9db4b08ae 100644
--- a/error_handler.h
+++ b/error_handler.h
@@ -94,16 +94,22 @@ namespace etl
 ///\ingroup error_handler
 //***************************************************************************
 #if defined(ETL_NO_CHECKS)
-  #define ETL_ASSERT(b, e) (true)                                                // Does nothing. Evaluates to 'true'.
+  #define ETL_ASSERT(b, e)                                                          // Does nothing.
 #elif defined(ETL_THROW_EXCEPTIONS)
-  #define ETL_ASSERT(b, e) (((b) ?  true : throw((e))), true)                    // Throws an exception if the condition fails. Evaluates to 'true'.
-#elif defined(ETL_LOG_ERRORS)
-  #define ETL_ASSERT(b, e) (((b) ?  true : etl::error_handler::error((e))), (b)) // Logs the error if the condition fails. Evaluates to the result of the condition.
+  #if defined(ETL_LOG_ERRORS)
+    #define ETL_ASSERT(b, e) {if (b) {etl::error_handler::error((e)); throw((e);)}} // If the condition fails, calls the error handler then throws an exception.
+  #else
+    #define ETL_ASSERT(b, e) {if (b) {throw((e));}}                                 // If the condition fails, throws an exception.
+  #endif
 #else
   #if defined(NDEBUG)
-    #define ETL_ASSERT(b, e) (true)                                                // Does nothing. Evaluates to 'true'.
+    #define ETL_ASSERT(b, e)                                                        // Does nothing.
   #else
-    #define ETL_ASSERT(b, e) ((assert((b))), true)                                 // Asserts if the condition fails. Evaluates to 'true'.
+    #if defined(ETL_LOG_ERRORS)
+      #define ETL_ASSERT(b, e) {etl::error_handler::error((e)); assert((b));}       // If the condition fails, calls the error handler then asserts.
+    #else
+      #define ETL_ASSERT(b, e) assert((b))                                          // If the condition fails, asserts.
+    #endif
   #endif
 #endif
 
diff --git a/ideque.h b/ideque.h
index 0eb6fdd83..76b3319cd 100644
--- a/ideque.h
+++ b/ideque.h
@@ -492,18 +492,17 @@ namespace etl
     //*************************************************************************
     void assign(size_type n, const value_type& value)
     {
-      if (ETL_ASSERT(n <= MAX_SIZE, ETL_ERROR(deque_full)))
-      {
-        initialise();
+      ETL_ASSERT(n <= MAX_SIZE, ETL_ERROR(deque_full));
 
-        _begin.index = 0;
-        _end.index = 0;
+      initialise();
 
-        while (n > 0)
-        {
-          create_element_back(value);
-          --n;
-        }
+      _begin.index = 0;
+      _end.index = 0;
+
+      while (n > 0)
+      {
+        create_element_back(value);
+        --n;
       }
     }
 
@@ -711,43 +710,42 @@ namespace etl
     {
       iterator position(insert_position.index, *this, p_buffer);
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(deque_full)))
+      ETL_ASSERT(!full(), ETL_ERROR(deque_full));
+
+      if (insert_position == begin())
       {
-        if (insert_position == begin())
-        {
-          create_element_front(value);
-          position = _begin;
-        }
-        else if (insert_position == end())
+        create_element_front(value);
+        position = _begin;
+      }
+      else if (insert_position == end())
+      {
+        create_element_back(value);
+        position = _end - 1;
+      }
+      else
+      {
+        // Are we closer to the front?
+        if (std::distance(_begin, position) < std::distance(position, _end - 1))
         {
-          create_element_back(value);
-          position = _end - 1;
+          // Construct the _begin.
+          create_element_front(*_begin);
+
+          // Move the values.
+          std::copy(_begin + 1, position, _begin);
+
+          // Write the new value.
+          *--position = value;
         }
         else
         {
-          // Are we closer to the front?
-          if (std::distance(_begin, position) < std::distance(position, _end - 1))
-          {
-            // Construct the _begin.
-            create_element_front(*_begin);
-
-            // Move the values.
-            std::copy(_begin + 1, position, _begin);
-
-            // Write the new value.
-            *--position = value;
-          }
-          else
-          {
-            // Construct the _end.
-            create_element_back(*(_end - 1));
+          // Construct the _end.
+          create_element_back(*(_end - 1));
             
-            // Move the values.
-            std::copy_backward(position, _end - 2, _end - 1);
+          // Move the values.
+          std::copy_backward(position, _end - 2, _end - 1);
 
-            // Write the new value.
-            *position = value;
-          }
+          // Write the new value.
+          *position = value;
         }
       }
 
@@ -765,99 +763,98 @@ namespace etl
     {
       iterator position;
 
-      if (ETL_ASSERT((current_size + n) <= MAX_SIZE, ETL_ERROR(deque_full)))
+      ETL_ASSERT((current_size + n) <= MAX_SIZE, ETL_ERROR(deque_full));
+
+      if (insert_position == begin())
       {
-        if (insert_position == begin())
+        for (size_t i = 0; i < n; ++i)
         {
-          for (size_t i = 0; i < n; ++i)
-          {
-            create_element_front(value);
-          }
+          create_element_front(value);
+        }
           
-          position = _begin;
+        position = _begin;
+      }
+      else if (insert_position == end())
+      {
+        for (size_t i = 0; i < n; ++i)
+        {
+          create_element_back(value);
         }
-        else if (insert_position == end())
+
+        position = _end - n;
+      }
+      else
+      {
+        // Non-const insert iterator.
+        position = iterator(insert_position.index, *this, p_buffer);
+
+        // Are we closer to the front?
+        if (distance(_begin, insert_position) <= difference_type(current_size / 2))
         {
-          for (size_t i = 0; i < n; ++i)
+          size_t insert_index  = std::distance(begin(), position);
+          size_t n_insert      = n;
+          size_t n_move        = std::distance(begin(), position);
+          size_t n_create_copy = std::min(n_insert, n_move);
+          size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
+          size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
+          size_t n_copy_old    = n_move - n_create_copy;
+
+          // Remember the original start.
+          iterator from = _begin + n_create_copy - 1;
+          iterator to;
+
+          // Create new.
+          for (size_t i = 0; i < n_create_new; ++i)
           {
-            create_element_back(value);
+            create_element_front(value);
+          }
+
+          // Create copy.
+          for (size_t i = 0; i < n_create_copy; ++i)
+          {
+            create_element_front(*from--);
           }
 
-          position = _end - n;
+          // Copy old.
+          from = position - n_copy_old;
+          to   = _begin + n_create_copy;
+          etl::copy_n(from, n_copy_old, to);
+
+          // Copy new.
+          to = position - n_create_copy;
+          std::fill_n(to, n_copy_new, value);
+
+          position = _begin + n_move;
         }
         else
         {
-          // Non-const insert iterator.
-          position = iterator(insert_position.index, *this, p_buffer);
-
-          // Are we closer to the front?
-          if (distance(_begin, insert_position) <= difference_type(current_size / 2))
+          size_t insert_index  = std::distance(begin(), position);
+          size_t n_insert      = n;
+          size_t n_move        = std::distance(position, end());
+          size_t n_create_copy = std::min(n_insert, n_move);
+          size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
+          size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
+          size_t n_copy_old    = n_move - n_create_copy;
+
+          // Create new.
+          for (size_t i = 0; i < n_create_new; ++i)
           {
-            size_t insert_index  = std::distance(begin(), position);
-            size_t n_insert      = n;
-            size_t n_move        = std::distance(begin(), position);
-            size_t n_create_copy = std::min(n_insert, n_move);
-            size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
-            size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
-            size_t n_copy_old    = n_move - n_create_copy;
-
-            // Remember the original start.
-            iterator from = _begin + n_create_copy - 1;
-            iterator to;
-
-            // Create new.
-            for (size_t i = 0; i < n_create_new; ++i)
-            {
-              create_element_front(value);
-            }
-
-            // Create copy.
-            for (size_t i = 0; i < n_create_copy; ++i)
-            {
-              create_element_front(*from--);
-            }
-
-            // Copy old.
-            from = position - n_copy_old;
-            to   = _begin + n_create_copy;
-            etl::copy_n(from, n_copy_old, to);
-
-            // Copy new.
-            to = position - n_create_copy;
-            std::fill_n(to, n_copy_new, value);
-
-            position = _begin + n_move;
+            create_element_back(value);
           }
-          else
+
+          // Create copy.
+          const_iterator from = position + n_copy_old;
+
+          for (size_t i = 0; i < n_create_copy; ++i)
           {
-            size_t insert_index  = std::distance(begin(), position);
-            size_t n_insert      = n;
-            size_t n_move        = std::distance(position, end());
-            size_t n_create_copy = std::min(n_insert, n_move);
-            size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
-            size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
-            size_t n_copy_old    = n_move - n_create_copy;
-
-            // Create new.
-            for (size_t i = 0; i < n_create_new; ++i)
-            {
-              create_element_back(value);
-            }
-
-            // Create copy.
-            const_iterator from = position + n_copy_old;
-
-            for (size_t i = 0; i < n_create_copy; ++i)
-            {
-              create_element_back(*from++);
-            }
-
-            // Copy old.
-            std::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
-
-            // Copy new.
-            std::fill_n(position, n_copy_new, value);
+            create_element_back(*from++);
           }
+
+          // Copy old.
+          std::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
+
+          // Copy new.
+          std::fill_n(position, n_copy_new, value);
         }
       }
 
@@ -879,93 +876,92 @@ namespace etl
 
       difference_type n = std::distance(range_begin, range_end);
 
-      if (ETL_ASSERT((current_size + n) <= MAX_SIZE, ETL_ERROR(deque_full)))
+      ETL_ASSERT((current_size + n) <= MAX_SIZE, ETL_ERROR(deque_full));
+
+      if (insert_position == begin())
       {
-        if (insert_position == begin())
-        {
-          create_element_front(n, range_begin);
+        create_element_front(n, range_begin);
 
-          position = _begin;
-        }
-        else if (insert_position == end())
+        position = _begin;
+      }
+      else if (insert_position == end())
+      {
+        for (difference_type i = 0; i < n; ++i)
         {
-          for (difference_type i = 0; i < n; ++i)
-          {
-            create_element_back(*range_begin++);
-          }
+          create_element_back(*range_begin++);
+        }
+
+        position = _end - n;
+      }
+      else
+      {
+        // Non-const insert iterator.
+        position = iterator(insert_position.index, *this, p_buffer);
 
-          position = _end - n;
+        // Are we closer to the front?
+        if (distance(_begin, insert_position) < difference_type(current_size / 2))
+        {
+          size_t insert_index  = std::distance(begin(), position);
+          size_t n_insert      = n;
+          size_t n_move        = std::distance(begin(), position);
+          size_t n_create_copy = std::min(n_insert, n_move);
+          size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
+          size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
+          size_t n_copy_old    = n_move - n_create_copy;
+
+          // Remember the original start.
+          iterator from;
+          iterator to;
+
+          // Create new.
+          create_element_front(n_create_new, range_begin);
+
+          // Create copy.
+          create_element_front(n_create_copy, _begin + n_create_new);
+
+          // Copy old.
+          from = position - n_copy_old;
+          to   = _begin + n_create_copy;
+          etl::copy_n(from, n_copy_old, to);
+
+          // Copy new.
+          to = position - n_create_copy;
+          range_begin += n_create_new;
+          etl::copy_n(range_begin, n_copy_new, to);
+
+          position = _begin + n_move;
         }
         else
         {
-          // Non-const insert iterator.
-          position = iterator(insert_position.index, *this, p_buffer);
-
-          // Are we closer to the front?
-          if (distance(_begin, insert_position) < difference_type(current_size / 2))
+          size_t insert_index  = std::distance(begin(), position);
+          size_t n_insert      = n;
+          size_t n_move        = std::distance(position, end());
+          size_t n_create_copy = std::min(n_insert, n_move);
+          size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
+          size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
+          size_t n_copy_old    = n_move - n_create_copy;
+
+          // Create new.
+          TIterator item = range_begin + (n - n_create_new);
+          for (size_t i = 0; i < n_create_new; ++i)
           {
-            size_t insert_index  = std::distance(begin(), position);
-            size_t n_insert      = n;
-            size_t n_move        = std::distance(begin(), position);
-            size_t n_create_copy = std::min(n_insert, n_move);
-            size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
-            size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
-            size_t n_copy_old    = n_move - n_create_copy;
-
-            // Remember the original start.
-            iterator from;
-            iterator to;
-
-            // Create new.
-            create_element_front(n_create_new, range_begin);
-
-            // Create copy.
-            create_element_front(n_create_copy, _begin + n_create_new);
-
-            // Copy old.
-            from = position - n_copy_old;
-            to   = _begin + n_create_copy;
-            etl::copy_n(from, n_copy_old, to);
-
-            // Copy new.
-            to = position - n_create_copy;
-            range_begin += n_create_new;
-            etl::copy_n(range_begin, n_copy_new, to);
-
-            position = _begin + n_move;
+            create_element_back(*item++);
           }
-          else
+
+          // Create copy.
+          const_iterator from = position + n_copy_old;
+
+          for (size_t i = 0; i < n_create_copy; ++i)
           {
-            size_t insert_index  = std::distance(begin(), position);
-            size_t n_insert      = n;
-            size_t n_move        = std::distance(position, end());
-            size_t n_create_copy = std::min(n_insert, n_move);
-            size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
-            size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
-            size_t n_copy_old    = n_move - n_create_copy;
-
-            // Create new.
-            TIterator item = range_begin + (n - n_create_new);
-            for (size_t i = 0; i < n_create_new; ++i)
-            {
-              create_element_back(*item++);
-            }
-
-            // Create copy.
-            const_iterator from = position + n_copy_old;
-
-            for (size_t i = 0; i < n_create_copy; ++i)
-            {
-              create_element_back(*from++);
-            }
-
-            // Copy old.
-            std::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
-
-            // Copy new.
-            item = range_begin;
-            etl::copy_n(item, n_copy_new, position);
+            create_element_back(*from++);
           }
+
+          // Copy old.
+          std::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
+
+          // Copy new.
+          item = range_begin;
+          etl::copy_n(item, n_copy_new, position);
         }
       }
 
@@ -981,32 +977,31 @@ namespace etl
     {
       iterator position(erase_position.index, *this, p_buffer);
 
-      if (ETL_ASSERT(distance(position) <= difference_type(current_size), ETL_ERROR(deque_out_of_bounds)))
+      ETL_ASSERT(distance(position) <= difference_type(current_size), ETL_ERROR(deque_out_of_bounds));
+
+      if (position == _begin)
       {
-        if (position == _begin)
+        destroy_element_front();
+        position = begin();
+      }
+      else if (position == _end - 1)
+      {
+        destroy_element_back();
+        position = end();
+      }
+      else
+      {
+        // Are we closer to the front?
+        if (distance(_begin, position) < difference_type(current_size / 2))
         {
+          std::copy_backward(_begin, position, position + 1);
           destroy_element_front();
-          position = begin();
-        }
-        else if (position == _end - 1)
-        {
-          destroy_element_back();
-          position = end();
+          ++position;
         }
         else
         {
-          // Are we closer to the front?
-          if (distance(_begin, position) < difference_type(current_size / 2))
-          {
-            std::copy_backward(_begin, position, position + 1);
-            destroy_element_front();
-            ++position;
-          }
-          else
-          {
-            std::copy(position + 1, _end, position);
-            destroy_element_back();
-          }
+          std::copy(position + 1, _end, position);
+          destroy_element_back();
         }
       }
 
@@ -1023,57 +1018,56 @@ namespace etl
     {
       iterator position(range_begin.index, *this, p_buffer);
 
-      if (ETL_ASSERT((distance(range_begin) <= difference_type(current_size)) && (distance(range_end) <= difference_type(current_size)), ETL_ERROR(deque_out_of_bounds)))
-      {
-        // How many to erase?
-        size_t length = std::distance(range_begin, range_end);
+      ETL_ASSERT((distance(range_begin) <= difference_type(current_size)) && (distance(range_end) <= difference_type(current_size)), ETL_ERROR(deque_out_of_bounds));
+
+      // How many to erase?
+      size_t length = std::distance(range_begin, range_end);
 
-        // At the beginning?
-        if (position == _begin)
+      // At the beginning?
+      if (position == _begin)
+      {
+        for (size_t i = 0; i < length; ++i)
         {
-          for (size_t i = 0; i < length; ++i)
-          {
-            destroy_element_front();
-          }
+          destroy_element_front();
+        }
 
-          position = begin();
+        position = begin();
+      }
+      // At the end?
+      else if (position == _end - length)
+      {
+        for (size_t i = 0; i < length; ++i)
+        {
+          destroy_element_back();
         }
-        // At the end?
-        else if (position == _end - length)
+
+        position = end();
+      }
+      else
+      {         
+        // Copy the smallest number of items.
+        // Are we closer to the front?
+        if (distance(_begin, position) < difference_type(current_size / 2))
         {
+          // Move the items.
+          std::copy_backward(_begin, position, position + length);
+            
           for (size_t i = 0; i < length; ++i)
           {
-            destroy_element_back();
+            destroy_element_front();
           }
 
-          position = end();
+          position += length;
         }
         else
-        {         
-          // Copy the smallest number of items.
-          // Are we closer to the front?
-          if (distance(_begin, position) < difference_type(current_size / 2))
-          {
-            // Move the items.
-            std::copy_backward(_begin, position, position + length);
+        // Must be closer to the back.
+        {
+          // Move the items.
+          std::copy(position + length, _end, position);
             
-            for (size_t i = 0; i < length; ++i)
-            {
-              destroy_element_front();
-            }
-
-            position += length;
-          }
-          else
-          // Must be closer to the back.
+          for (size_t i = 0; i < length; ++i)
           {
-            // Move the items.
-            std::copy(position + length, _end, position);
-            
-            for (size_t i = 0; i < length; ++i)
-            {
-              destroy_element_back();
-            }
+            destroy_element_back();
           }
         }
       }
@@ -1088,10 +1082,8 @@ namespace etl
     //*************************************************************************
     void push_back(parameter_t item)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(deque_full)))
-      {
-        create_element_back(item);
-      } 
+      ETL_ASSERT(!full(), ETL_ERROR(deque_full));
+      create_element_back(item);
     }
 
     //*************************************************************************
@@ -1103,10 +1095,8 @@ namespace etl
     {
       reference r = *_end;
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(deque_full)))
-      {
-        create_element_back();
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(deque_full));
+      create_element_back();
 
       return r;
     }
@@ -1116,10 +1106,8 @@ namespace etl
     //*************************************************************************
     void pop_back()
     {
-      if (!empty())
-      {
-        destroy_element_back();
-      }
+      ETL_ASSERT(!empty(), ETL_ERROR(deque_empty));
+      destroy_element_back();
     }
 
     //*************************************************************************
@@ -1129,10 +1117,8 @@ namespace etl
     //*************************************************************************
     void push_front(parameter_t item)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(deque_full)))
-      {
-        create_element_front(item);
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(deque_full));
+      create_element_front(item);
     }
 
     //*************************************************************************
@@ -1142,10 +1128,8 @@ namespace etl
     //*************************************************************************
     reference push_front()
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(deque_full)))
-      {
-        create_element_front();
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(deque_full));
+      create_element_front();
 
       return *_begin;
     }
@@ -1155,10 +1139,8 @@ namespace etl
     //*************************************************************************
     void pop_front()
     {
-      if (!empty())
-      {
-        destroy_element_front();
-      }
+      ETL_ASSERT(!empty(), ETL_ERROR(deque_empty));
+      destroy_element_front();
     }
 
     //*************************************************************************
@@ -1169,25 +1151,24 @@ namespace etl
     //*************************************************************************
     void resize(size_t new_size, const value_type& value = value_type())
     {
-      if (ETL_ASSERT(new_size <= MAX_SIZE, ETL_ERROR(deque_out_of_bounds)))
+      ETL_ASSERT(new_size <= MAX_SIZE, ETL_ERROR(deque_out_of_bounds));
+
+      // Make it smaller?
+      if (new_size < current_size)
       {
-        // Make it smaller?
-        if (new_size < current_size)
+        while (current_size > new_size)
         {
-          while (current_size > new_size)
-          {
-            destroy_element_back();
-          }
+          destroy_element_back();
         }
-        // Make it larger?
-        else if (new_size > current_size)
-        {
-          size_t count = new_size - current_size;
+      }
+      // Make it larger?
+      else if (new_size > current_size)
+      {
+        size_t count = new_size - current_size;
 
-          for (size_t i = 0; i < count; ++i)
-          {
-            create_element_back(value);
-          }
+        for (size_t i = 0; i < count; ++i)
+        {
+          create_element_back(value);
         }
       }
     }
diff --git a/iflat_map.h b/iflat_map.h
index 9163d9ef1..ff91ac5ba 100644
--- a/iflat_map.h
+++ b/iflat_map.h
@@ -300,12 +300,10 @@ namespace etl
       if (i_element == end())
       {
         // At the end.
-        if (ETL_ASSERT(!buffer.full(), ETL_ERROR(flat_map_full)))
-        {
-          buffer.push_back(value);
-          result.first  = end() - 1;
-          result.second = true;
-        }
+        ETL_ASSERT(!buffer.full(), ETL_ERROR(flat_map_full));
+        buffer.push_back(value);
+        result.first  = end() - 1;
+        result.second = true;
       }
       else
       {
@@ -321,12 +319,10 @@ namespace etl
         else
         {
           // A new one.
-          if (ETL_ASSERT(!buffer.full(), ETL_ERROR(flat_map_full)))
-          {
-            buffer.insert(i_element, value);
-            result.first  = i_element;
-            result.second = true;
-          }
+          ETL_ASSERT(!buffer.full(), ETL_ERROR(flat_map_full));
+          buffer.insert(i_element, value);
+          result.first  = i_element;
+          result.second = true;
         }
       }
 
diff --git a/iflat_multimap.h b/iflat_multimap.h
index 7260391d8..171710e0f 100644
--- a/iflat_multimap.h
+++ b/iflat_multimap.h
@@ -246,22 +246,21 @@ namespace etl
 
       iterator i_element = lower_bound(value.first);
 
-      if (ETL_ASSERT(!buffer.full(), ETL_ERROR(flat_multimap_full)))
+      ETL_ASSERT(!buffer.full(), ETL_ERROR(flat_multimap_full));
+
+      if (i_element == end())
+      {
+        // At the end.
+        buffer.push_back(value);
+        result.first = end() - 1;
+        result.second = true;
+      }
+      else
       {
-        if (i_element == end())
-        {
-          // At the end.
-          buffer.push_back(value);
-          result.first = end() - 1;
-          result.second = true;
-        }
-        else
-        {
-          // Not at the end.
-          buffer.insert(i_element, value);
-          result.first = i_element;
-          result.second = true;
-        }
+        // Not at the end.
+        buffer.insert(i_element, value);
+        result.first = i_element;
+        result.second = true;
       }
 
       return result;
diff --git a/iflat_multiset.h b/iflat_multiset.h
index 257633699..72b488bf2 100644
--- a/iflat_multiset.h
+++ b/iflat_multiset.h
@@ -221,26 +221,25 @@ namespace etl
     {
       std::pair<iterator, bool> result(end(), false);
 
-      if (ETL_ASSERT(!buffer.full(), ETL_ERROR(flat_multiset_full)))
+      ETL_ASSERT(!buffer.full(), ETL_ERROR(flat_multiset_full));
+
+      iterator i_element = std::lower_bound(begin(), end(), value, TKeyCompare());
+
+      if (i_element == end())
       {
-        iterator i_element = std::lower_bound(begin(), end(), value, TKeyCompare());
-
-        if (i_element == end())
-        {
-          // At the end.
-          buffer.push_back(value);
-          result.first = end() - 1;
-          result.second = true;
-        }
-        else
-        {
-          // Not at the end.
-          buffer.insert(i_element, value);
-          result.first = i_element;
-          result.second = true;
-        }
+        // At the end.
+        buffer.push_back(value);
+        result.first = end() - 1;
+        result.second = true;
       }
-
+      else
+      {
+        // Not at the end.
+        buffer.insert(i_element, value);
+        result.first = i_element;
+        result.second = true;
+      }
+      
       return result;
     }
 
diff --git a/iflat_set.h b/iflat_set.h
index 47b27829f..8904344df 100644
--- a/iflat_set.h
+++ b/iflat_set.h
@@ -220,32 +220,31 @@ namespace etl
     {
       std::pair<iterator, bool> result(end(), false);
 
-	    if (ETL_ASSERT(!buffer.full(), ETL_ERROR(flat_set_full)))
-      {
-        iterator i_element = std::lower_bound(begin(), end(), value, TKeyCompare());
+      ETL_ASSERT(!buffer.full(), ETL_ERROR(flat_set_full));
+
+      iterator i_element = std::lower_bound(begin(), end(), value, TKeyCompare());
 
-        if (i_element == end())
+      if (i_element == end())
+      {
+        // At the end. Doesn't exist.
+        buffer.push_back(value);
+        result.first = end() - 1;
+        result.second = true;
+      }
+      else
+      {
+        // Not at the end.
+        // Does not exist already?
+        if (*i_element != value)
         {
-          // At the end. Doesn't exist.
-          buffer.push_back(value);
-          result.first = end() - 1;
+          buffer.insert(i_element, value);
+          result.first = i_element;
           result.second = true;
         }
         else
         {
-          // Not at the end.
-          // Does not exist already?
-          if (*i_element != value)
-          {
-            buffer.insert(i_element, value);
-            result.first = i_element;
-            result.second = true;
-          }
-          else
-          {
-            result.first = i_element;
-            result.second = false;
-          }
+          result.first = i_element;
+          result.second = false;
         }
       }
 
diff --git a/iforward_list.h b/iforward_list.h
index 9f65bc418..76138a866 100644
--- a/iforward_list.h
+++ b/iforward_list.h
@@ -374,14 +374,13 @@ namespace etl
       // Add all of the elements.
       while (first != last)
       {
-        if (ETL_ASSERT(!full(), ETL_ERROR(forward_list_iterator)))
-        {
-          Data_Node& data_node = allocate_data_node(*first++);
-          join(p_last_node, &data_node);
-          data_node.next = nullptr;
-          p_last_node = &data_node;
-          ++current_size;
-        }
+        ETL_ASSERT(!full(), ETL_ERROR(forward_list_iterator));
+
+        Data_Node& data_node = allocate_data_node(*first++);
+        join(p_last_node, &data_node);
+        data_node.next = nullptr;
+        p_last_node = &data_node;
+        ++current_size;
       }
     }
 
@@ -390,21 +389,20 @@ namespace etl
     //*************************************************************************
     void assign(size_t n, parameter_t value)
     {
-      if (ETL_ASSERT(n <= MAX_SIZE, ETL_ERROR(forward_list_full)))
-      {
-        initialise();
+      ETL_ASSERT(n <= MAX_SIZE, ETL_ERROR(forward_list_full));
 
-        Node* p_last_node = &start_node;
+      initialise();
 
-        // Add all of the elements.
-        while (current_size < n)
-        {
-          Data_Node& data_node = allocate_data_node(value);
-          join(p_last_node, &data_node);
-          data_node.next = nullptr;
-          p_last_node = &data_node;
-          ++current_size;
-        }
+      Node* p_last_node = &start_node;
+        
+      // Add all of the elements.
+      while (current_size < n)
+      {
+        Data_Node& data_node = allocate_data_node(value);
+        join(p_last_node, &data_node);
+        data_node.next = nullptr;
+        p_last_node = &data_node;
+        ++current_size;
       }
     }
 
@@ -413,11 +411,10 @@ namespace etl
     //*************************************************************************
     void push_front()
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)))
-      {
-        Data_Node& data_node = allocate_data_node(T());
-        insert_node_after(start_node, data_node);
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(forward_list_full));
+
+      Data_Node& data_node = allocate_data_node(T());
+      insert_node_after(start_node, data_node);
     }
 
     //*************************************************************************
@@ -425,11 +422,10 @@ namespace etl
     //*************************************************************************
     void push_front(parameter_t value)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)))
-      {
-        Data_Node& data_node = allocate_data_node(value);
-        insert_node_after(start_node, data_node);
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(forward_list_full));
+
+      Data_Node& data_node = allocate_data_node(value);
+      insert_node_after(start_node, data_node);
     }
 
     //*************************************************************************
@@ -437,10 +433,8 @@ namespace etl
     //*************************************************************************
     void pop_front()
     {
-      if (!empty())
-      {
-        remove_node_after(start_node);
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(forward_list_empty));
+      remove_node_after(start_node);
     }
 
     //*************************************************************************
@@ -458,33 +452,32 @@ namespace etl
     //*************************************************************************
     void resize(size_t n, T value)
     {
-      if (ETL_ASSERT(n <= MAX_SIZE, ETL_ERROR(forward_list_full)))
+      ETL_ASSERT(n <= MAX_SIZE, ETL_ERROR(forward_list_full));
+
+      size_t i = 0;
+      iterator i_node = begin();
+      iterator i_last_node;
+
+      // Find where we're currently at.
+      while ((i < n) && (i_node != end()))
       {
-        size_t i = 0;
-        iterator i_node = begin();
-        iterator i_last_node;
+        ++i;
+        i_last_node = i_node;
+        ++i_node;
+      }
 
-        // Find where we're currently at.
-        while ((i < n) && (i_node != end()))
+      if (i_node != end())
+      {
+        // Reduce.
+        erase_after(i_node, end());
+      }
+      else if (i_node == end())
+      {
+        // Increase.
+        while (i < n)
         {
+          i_last_node = insert_after(i_last_node, value);
           ++i;
-          i_last_node = i_node;
-          ++i_node;
-        }
-
-        if (i_node != end())
-        {
-          // Reduce.
-          erase_after(i_node, end());
-        }
-        else if (i_node == end())
-        {
-          // Increase.
-          while (i < n)
-          {
-            i_last_node = insert_after(i_last_node, value);
-            ++i;
-          }
         }
       }
     }
@@ -494,13 +487,12 @@ namespace etl
     //*************************************************************************
     iterator insert_after(iterator position, parameter_t value)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)))
-      {
-        Data_Node& data_node = allocate_data_node(value);
-        insert_node_after(*position.p_node, data_node);
+      ETL_ASSERT(!full(), ETL_ERROR(forward_list_full));
 
-        return iterator(data_node);
-      }
+      Data_Node& data_node = allocate_data_node(value);
+      insert_node_after(*position.p_node, data_node);
+
+      return iterator(data_node);
     }
 
     //*************************************************************************
@@ -508,14 +500,13 @@ namespace etl
     //*************************************************************************
     void insert_after(iterator position, size_t n, parameter_t value)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)))
+      ETL_ASSERT(!full(), ETL_ERROR(forward_list_full));
+
+      for (size_t i = 0; !full() && (i < n); ++i)
       {
-        for (size_t i = 0; !full() && (i < n); ++i)
-        {
-          // Set up the next free node.
-          Data_Node& data_node = allocate_data_node(value);
-          insert_node(*position.p_node, data_node);
-        }
+        // Set up the next free node.
+        Data_Node& data_node = allocate_data_node(value);
+        insert_node(*position.p_node, data_node);
       }
     }
 
diff --git a/ilist.h b/ilist.h
index 0ea57fb9a..15793ead0 100644
--- a/ilist.h
+++ b/ilist.h
@@ -495,11 +495,10 @@ namespace etl
     //*************************************************************************
     void push_front()
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(list_full)))
-      {
-        Data_Node& data_node = allocate_data_node(T());
-        insert_node(get_head(), data_node);
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(list_full));
+
+      Data_Node& data_node = allocate_data_node(T());
+      insert_node(get_head(), data_node);
     }
 
     //*************************************************************************
@@ -507,11 +506,10 @@ namespace etl
     //*************************************************************************
     void push_front(parameter_t value)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(list_full)))
-      {
-        Node& data_node = allocate_data_node(value);
-        insert_node(get_head(), data_node);
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(list_full));
+
+      Node& data_node = allocate_data_node(value);
+      insert_node(get_head(), data_node);
     }
 
     //*************************************************************************
@@ -519,11 +517,10 @@ namespace etl
     //*************************************************************************
     void pop_front()
     {
-      if (!empty())
-      {
-    	  Node& node = get_head();
-        remove_node(node);
-      }
+      ETL_ASSERT(!empty(), ETL_ERROR(list_empty));
+
+      Node& node = get_head();
+      remove_node(node);
     }
 
     //*************************************************************************
@@ -531,11 +528,10 @@ namespace etl
     //*************************************************************************
     void push_back()
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(list_full)))
-      {
-        Data_Node& data_node = allocate_data_node(T());
-        insert_node(terminal_node, data_node);
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(list_full));
+
+      Data_Node& data_node = allocate_data_node(T());
+      insert_node(terminal_node, data_node);
     }
 
     //*************************************************************************
@@ -543,11 +539,10 @@ namespace etl
     //*************************************************************************
     void push_back(parameter_t value)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(list_full)))
-      {
-        Data_Node& data_node = allocate_data_node(value);
-        insert_node(terminal_node, data_node);
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(list_full));
+
+      Data_Node& data_node = allocate_data_node(value);
+      insert_node(terminal_node, data_node);
     }
 
     //*************************************************************************
@@ -555,11 +550,10 @@ namespace etl
     //*************************************************************************
     void pop_back()
     {
-      if (!empty())
-      {
-      	Node& node = get_tail();
-        remove_node(node);
-      }
+      ETL_ASSERT(!empty(), ETL_ERROR(list_empty));
+
+    	Node& node = get_tail();
+      remove_node(node);
     }
 
     //*************************************************************************
@@ -567,13 +561,12 @@ namespace etl
     //*************************************************************************
     iterator insert(iterator position, const value_type& value)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(list_full)))
-      {
-        Data_Node& data_node = allocate_data_node(value);
-        insert_node(*position.p_node, data_node);
+      ETL_ASSERT(!full(), ETL_ERROR(list_full));
 
-        return iterator(data_node);
-      }
+      Data_Node& data_node = allocate_data_node(value);
+      insert_node(*position.p_node, data_node);
+
+      return iterator(data_node);
     }
 
     //*************************************************************************
@@ -583,12 +576,11 @@ namespace etl
     {
       for (size_t i = 0; i < n; ++i)
       {
-        if (ETL_ASSERT(!full(), ETL_ERROR(list_full)))
-        {
-          // Set up the next free node and insert.
-          Data_Node& data_node = allocate_data_node(value);
-          insert_node(*position.p_node, data_node);
-        }
+        ETL_ASSERT(!full(), ETL_ERROR(list_full));
+
+        // Set up the next free node and insert.
+        Data_Node& data_node = allocate_data_node(value);
+        insert_node(*position.p_node, data_node);
       }
     }
 
@@ -600,12 +592,11 @@ namespace etl
     {
       while (first != last)
       {
-        if (ETL_ASSERT(!full(), ETL_ERROR(list_full)))
-        {
-          // Set up the next free node and insert.
-          Data_Node& data_node = allocate_data_node(*first++);
-          insert_node(*position.p_node, data_node);
-        }
+        ETL_ASSERT(!full(), ETL_ERROR(list_full));
+
+        // Set up the next free node and insert.
+        Data_Node& data_node = allocate_data_node(*first++);
+        insert_node(*position.p_node, data_node);
       }
     }
 
@@ -661,20 +652,19 @@ namespace etl
     //*************************************************************************
     void resize(size_t n, parameter_t value)
     {
-      if (ETL_ASSERT(n <= MAX_SIZE, ETL_ERROR(list_full)))
+      ETL_ASSERT(n <= MAX_SIZE, ETL_ERROR(list_full));
+
+      // Smaller?
+      if (n < size())
       {
-        // Smaller?
-        if (n < size())
-        {
-          iterator i_start = end();
-          std::advance(i_start, -difference_type(size() - n));
-          erase(i_start, end());
-        }
-        // Larger?
-        else if (n > size())
-        {
-          insert(end(), n - size(), value);
-        }
+        iterator i_start = end();
+        std::advance(i_start, -difference_type(size() - n));
+        erase(i_start, end());
+      }
+      // Larger?
+      else if (n > size())
+      {
+        insert(end(), n - size(), value);
       }
     }
 
diff --git a/imap.h b/imap.h
index 7c2330de4..b2fc7dc41 100644
--- a/imap.h
+++ b/imap.h
@@ -691,15 +691,14 @@ namespace etl
       Node* inserted_node = nullptr;
       bool inserted = false;
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(map_full)))
-      {
-        // Get next available free node
-        Data_Node& node = allocate_data_node(value);
+      ETL_ASSERT(!full(), ETL_ERROR(map_full));
 
-        // Obtain the inserted node (might be nullptr if node was a duplicate)
-        inserted_node = insert_node(root_node, node);
-        inserted = inserted_node == &node;
-      }
+      // Get next available free node
+      Data_Node& node = allocate_data_node(value);
+
+      // Obtain the inserted node (might be nullptr if node was a duplicate)
+      inserted_node = insert_node(root_node, node);
+      inserted = inserted_node == &node;
 
       // Insert node into tree and return iterator to new node location in tree
       return std::make_pair(iterator(*this, inserted_node), inserted);
@@ -716,14 +715,13 @@ namespace etl
       // Default to no inserted node
       Node* inserted_node = nullptr;
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(map_full)))
-      {
-        // Get next available free node
-        Data_Node& node = allocate_data_node(value);
+      ETL_ASSERT(!full(), ETL_ERROR(map_full));
 
-        // Obtain the inserted node (might be nullptr if node was a duplicate)
-        inserted_node = insert_node(root_node, node);
-      }
+      // Get next available free node
+      Data_Node& node = allocate_data_node(value);
+
+      // Obtain the inserted node (might be nullptr if node was a duplicate)
+      inserted_node = insert_node(root_node, node);
 
       // Insert node into tree and return iterator to new node location in tree
       return iterator(*this, inserted_node);
@@ -740,14 +738,13 @@ namespace etl
       // Default to no inserted node
       Node* inserted_node = nullptr;
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(map_full)))
-      {
-        // Get next available free node
-        Data_Node& node = allocate_data_node(value);
+      ETL_ASSERT(!full(), ETL_ERROR(map_full));
 
-        // Obtain the inserted node (might be nullptr if node was a duplicate)
-        inserted_node = insert_node(root_node, node);
-      }
+      // Get next available free node
+      Data_Node& node = allocate_data_node(value);
+
+      // Obtain the inserted node (might be nullptr if node was a duplicate)
+      inserted_node = insert_node(root_node, node);
 
       // Insert node into tree and return iterator to new node location in tree
       return iterator(*this, inserted_node);
diff --git a/imultimap.h b/imultimap.h
index c740a7a65..0d0842f5f 100644
--- a/imultimap.h
+++ b/imultimap.h
@@ -656,14 +656,13 @@ namespace etl
       // Default to no inserted node
       Node* inserted_node = nullptr;
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(multimap_full)))
-      {
-        // Get next available free node
-        Data_Node& node = allocate_data_node(value);
+      ETL_ASSERT(!full(), ETL_ERROR(multimap_full));
 
-        // Obtain the inserted node (might be nullptr if node was a duplicate)
-        inserted_node = insert_node(root_node, node);
-      }
+      // Get next available free node
+      Data_Node& node = allocate_data_node(value);
+
+      // Obtain the inserted node (might be nullptr if node was a duplicate)
+      inserted_node = insert_node(root_node, node);
 
       // Insert node into tree and return iterator to new node location in tree
       return iterator(*this, inserted_node);
diff --git a/imultiset.h b/imultiset.h
index efd9d3eaa..7002f0e64 100644
--- a/imultiset.h
+++ b/imultiset.h
@@ -637,15 +637,14 @@ namespace etl
       // Default to no inserted node
       Node* inserted_node = nullptr;
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(multiset_full)))
-      {
-        // Get next available free node
-        Data_Node& node = allocate_data_node(value);
+      ETL_ASSERT(!full(), ETL_ERROR(multiset_full));
 
-        // Obtain the inserted node (might be nullptr if node was a duplicate)
-        inserted_node = insert_node(root_node, node);
-      }
+      // Get next available free node
+      Data_Node& node = allocate_data_node(value);
 
+      // Obtain the inserted node (might be nullptr if node was a duplicate)
+      inserted_node = insert_node(root_node, node);
+      
       // Insert node into tree and return iterator to new node location in tree
       return iterator(*this, inserted_node);
     }
diff --git a/intrusive_forward_list.h b/intrusive_forward_list.h
index 0c41cc9d6..0abf45bc9 100644
--- a/intrusive_forward_list.h
+++ b/intrusive_forward_list.h
@@ -60,6 +60,20 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Empty exception for the intrusive_forward_list.
+  ///\ingroup intrusive_forward_list
+  //***************************************************************************
+  class intrusive_forward_list_empty : public intrusive_forward_list_exception
+  {
+  public:
+
+    intrusive_forward_list_empty(string_type file_name, numeric_type line_number)
+      : intrusive_forward_list_exception(ETL_ERROR_TEXT("intrusive_forward_list:empty", ETL_FILE"A"), file_name, line_number)
+    { 
+    }
+  };
+
   //***************************************************************************
   /// Iterator exception for the intrusive_forward_list.
   ///\ingroup intrusive_forward_list
@@ -69,7 +83,7 @@ namespace etl
   public:
 
     intrusive_forward_list_iterator_exception(string_type file_name, numeric_type line_number)
-      : intrusive_forward_list_exception("intrusive_forward_list: iterator", file_name, line_number)
+      : intrusive_forward_list_exception(ETL_ERROR_TEXT("intrusive_forward_list:iterator", ETL_FILE"B"), file_name, line_number)
     {
     }
   };
@@ -83,7 +97,7 @@ namespace etl
   public:
 
     intrusive_forward_list_index_exception(string_type file_name, numeric_type line_number)
-      : intrusive_forward_list_exception("intrusive_forward_list:bounds", file_name, line_number)
+      : intrusive_forward_list_exception(ETL_ERROR_TEXT("intrusive_forward_list:bounds", ETL_FILE"C"), file_name, line_number)
     {
     }
   };
@@ -440,10 +454,8 @@ namespace etl
     //*************************************************************************
     void pop_front()
     {
-      if (!empty())
-      {
-        remove_node_after(start_node);
-      }
+      ETL_ASSERT(!empty(), ETL_ERROR(intrusive_forward_list_empty));
+      remove_node_after(start_node);
     }
 
     //*************************************************************************
diff --git a/ipool.h b/ipool.h
index 33a730c5e..abd46356d 100644
--- a/ipool.h
+++ b/ipool.h
@@ -324,21 +324,16 @@ namespace etl
 	  T* allocate()
 	  {
 #if defined(_DEBUG) || defined(DEBUG)
-      if (ETL_ASSERT(items_allocated < MAX_SIZE && !in_use_flags.test(next_free), ETL_ERROR(pool_no_allocation)))
+      ETL_ASSERT(items_allocated < MAX_SIZE && !in_use_flags.test(next_free), ETL_ERROR(pool_no_allocation));
 #else
-      if (ETL_ASSERT(items_allocated < MAX_SIZE, ETL_ERROR(pool_no_allocation)))
+      ETL_ASSERT(items_allocated < MAX_SIZE, ETL_ERROR(pool_no_allocation));
 #endif
-	    {
-		    T* result = new(&p_buffer[next_free]) T();
-		    in_use_flags.set(next_free);
-		    next_free = in_use_flags.find_first(false);
-		    ++items_allocated;
-		    return result;
-	    }
-      else
-      {
-        return nullptr;
-      }
+
+      T* result = new(&p_buffer[next_free]) T();
+		  in_use_flags.set(next_free);
+		  next_free = in_use_flags.find_first(false);
+		  ++items_allocated;
+		  return result;
 	  }
 
     //*************************************************************************
@@ -350,21 +345,16 @@ namespace etl
     T* allocate(const T& initial)
     {
 #if defined(_DEBUG) || defined(DEBUG)
-      if (ETL_ASSERT(items_allocated < MAX_SIZE && !in_use_flags.test(next_free), ETL_ERROR(pool_no_allocation)))
+      ETL_ASSERT(items_allocated < MAX_SIZE && !in_use_flags.test(next_free), ETL_ERROR(pool_no_allocation));
 #else
-      if (ETL_ASSERT(items_allocated < MAX_SIZE, ETL_ERROR(pool_no_allocation)))
+      ETL_ASSERT(items_allocated < MAX_SIZE, ETL_ERROR(pool_no_allocation));
 #endif
-      {
-        T* result = new(&p_buffer[next_free]) T(initial);
-        in_use_flags.set(next_free);
-        next_free = in_use_flags.find_first(false);
-        ++items_allocated;
-        return result;
-      }
-      else
-      {
-        return nullptr;
-      }
+
+      T* result = new(&p_buffer[next_free]) T(initial);
+      in_use_flags.set(next_free);
+      next_free = in_use_flags.find_first(false);
+      ++items_allocated;
+      return result;
     }
     
     //*************************************************************************
@@ -387,21 +377,20 @@ namespace etl
     void release(const T* const p_object)
     {
       // Does it belong to me?
-      if (ETL_ASSERT(is_in_pool(p_object), ETL_ERROR(pool_object_not_in_pool)))
-      {
+      ETL_ASSERT(is_in_pool(p_object), ETL_ERROR(pool_object_not_in_pool));
+
     	// Where is it in the buffer?
-        typename std::iterator_traits<T*>::difference_type distance = p_object - p_buffer;
-        size_t index = static_cast<size_t>(distance);
+      typename std::iterator_traits<T*>::difference_type distance = p_object - p_buffer;
+      size_t index = static_cast<size_t>(distance);
 
-        // Check that it hasn't already been released.
-        if (in_use_flags.test(index))
-        {
-          // Destroy the object and mark as available.
-          p_object->~T();
-          in_use_flags.reset(index);
-          --items_allocated;
-          next_free = index;
-        }
+      // Check that it hasn't already been released.
+      if (in_use_flags.test(index))
+      {
+        // Destroy the object and mark as available.
+        p_object->~T();
+        in_use_flags.reset(index);
+        --items_allocated;
+        next_free = index;
       }
     }
 
diff --git a/ipriority_queue.h b/ipriority_queue.h
index 97747f599..4b8b8cf5a 100644
--- a/ipriority_queue.h
+++ b/ipriority_queue.h
@@ -102,15 +102,14 @@ namespace etl
     //*************************************************************************
     void push(parameter_t value)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(priority_queue_full)))
-      {
-        // Put element at end
-        container.push_back(value);
-        // Pre-increment size
-        ++current_size;
-        // Make elements in container into heap
-        std::push_heap(container.begin(), container.end(), TCompare());
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(priority_queue_full));
+
+      // Put element at end
+      container.push_back(value);
+      // Pre-increment size
+      ++current_size;
+      // Make elements in container into heap
+      std::push_heap(container.begin(), container.end(), TCompare());
     }
 
     //*************************************************************************
@@ -122,7 +121,7 @@ namespace etl
       current_size = 0;
     }
 
-    //*********************************************************************
+    //*************************************************************************
     /// Assigns values to the priority queue.
     /// If ETL_THROW_EXCEPTIONS is defined, emits priority_queue_full if
     /// priority queue does not have enough free space.
@@ -130,7 +129,7 @@ namespace etl
     /// iterators are reversed.
     ///\param first The iterator to the first element.
     ///\param last  The iterator to the last element + 1.
-    //*********************************************************************
+    //*************************************************************************
     template <typename TIterator>
     void assign(TIterator first, TIterator last)
     {
diff --git a/iqueue.h b/iqueue.h
index 99df6294d..86ab1bf6a 100644
--- a/iqueue.h
+++ b/iqueue.h
@@ -114,12 +114,11 @@ namespace etl
     //*************************************************************************
     void push(parameter_t value)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(queue_full)))
-      {
-        new(&p_buffer[in]) T(value);
-        in = (in == (MAX_SIZE - 1)) ? 0 : in + 1;
-        ++current_size;
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(queue_full));
+
+      new(&p_buffer[in]) T(value);
+      in = (in == (MAX_SIZE - 1)) ? 0 : in + 1;
+      ++current_size;
     }
 
     //*************************************************************************
@@ -134,12 +133,11 @@ namespace etl
     {
       const size_type next = in;
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(queue_full)))
-      {
-        new(&p_buffer[in]) T();
-        in = (in == (MAX_SIZE - 1)) ? 0 : in + 1;
-        ++current_size;
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(queue_full));
+
+      new(&p_buffer[in]) T();
+      in = (in == (MAX_SIZE - 1)) ? 0 : in + 1;
+      ++current_size;
 
       return p_buffer[next];
     }
@@ -166,12 +164,11 @@ namespace etl
     //*************************************************************************
     void pop()
     {
-      if ETL_ASSERT(!empty(), ETL_ERROR(queue_empty))
-      {
-        p_buffer[out].~T();
-        out = (out == (MAX_SIZE - 1)) ? 0 : out + 1;
-        --current_size;
-      }
+      ETL_ASSERT(!empty(), ETL_ERROR(queue_empty));
+
+      p_buffer[out].~T();
+      out = (out == (MAX_SIZE - 1)) ? 0 : out + 1;
+      --current_size;
     }
 
   protected:
diff --git a/iset.h b/iset.h
index d28e7581d..1accb7126 100644
--- a/iset.h
+++ b/iset.h
@@ -633,15 +633,14 @@ namespace etl
       Node* inserted_node = nullptr;
       bool inserted = false;
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(set_full)))
-      {
-        // Get next available free node
-        Data_Node& node = allocate_data_node(value);
+      ETL_ASSERT(!full(), ETL_ERROR(set_full));
 
-        // Obtain the inserted node (might be nullptr if node was a duplicate)
-        inserted_node = insert_node(root_node, node);
-        inserted = inserted_node == &node;
-      }
+      // Get next available free node
+      Data_Node& node = allocate_data_node(value);
+
+      // Obtain the inserted node (might be nullptr if node was a duplicate)
+      inserted_node = insert_node(root_node, node);
+      inserted = inserted_node == &node;
 
       // Insert node into tree and return iterator to new node location in tree
       return std::make_pair(iterator(*this, inserted_node), inserted);
@@ -658,14 +657,13 @@ namespace etl
       // Default to no inserted node
       Node* inserted_node = nullptr;
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(set_full)))
-      {
-        // Get next available free node
-        Data_Node& node = allocate_data_node(value);
+      ETL_ASSERT(!full(), ETL_ERROR(set_full));
 
-        // Obtain the inserted node (might be nullptr if node was a duplicate)
-        inserted_node = insert_node(root_node, node);
-      }
+      // Get next available free node
+      Data_Node& node = allocate_data_node(value);
+
+      // Obtain the inserted node (might be nullptr if node was a duplicate)
+      inserted_node = insert_node(root_node, node);
 
       // Insert node into tree and return iterator to new node location in tree
       return iterator(*this, inserted_node);
@@ -682,14 +680,13 @@ namespace etl
       // Default to no inserted node
       Node* inserted_node = nullptr;
 
-      if (ETL_ASSERT(!full(), ETL_ERROR(set_full)))
-      {
-        // Get next available free node
-        Data_Node& node = allocate_data_node(value);
+      ETL_ASSERT(!full(), ETL_ERROR(set_full));
 
-        // Obtain the inserted node (might be nullptr if node was a duplicate)
-        inserted_node = insert_node(root_node, node);
-      }
+      // Get next available free node
+      Data_Node& node = allocate_data_node(value);
+
+      // Obtain the inserted node (might be nullptr if node was a duplicate)
+      inserted_node = insert_node(root_node, node);
 
       // Insert node into tree and return iterator to new node location in tree
       return iterator(*this, inserted_node);
diff --git a/istack.h b/istack.h
index 559f64733..f8ba95636 100644
--- a/istack.h
+++ b/istack.h
@@ -86,11 +86,10 @@ namespace etl
     //*************************************************************************
     void push(parameter_t value)
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(stack_full)))
-      {
-        top_index = current_size++;
-        new(&p_buffer[top_index]) T(value);
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(stack_full));
+
+      top_index = current_size++;
+      new(&p_buffer[top_index]) T(value);
     }
 
     //*************************************************************************
@@ -102,11 +101,10 @@ namespace etl
     //*************************************************************************
     reference push()
     {
-      if (ETL_ASSERT(!full(), ETL_ERROR(stack_full)))
-      {
-        top_index = current_size++;
-        new(&p_buffer[top_index]) T();
-      }
+      ETL_ASSERT(!full(), ETL_ERROR(stack_full));
+
+      top_index = current_size++;
+      new(&p_buffer[top_index]) T();
 
       return p_buffer[top_index];
     }
@@ -139,12 +137,11 @@ namespace etl
     //*************************************************************************
     void pop()
     {
-      if (!empty())
-      {
-        p_buffer[top_index].~T();
-        --top_index;
-        --current_size;
-      }
+      ETL_ASSERT(!empty(), ETL_ERROR(stack_empty));
+
+      p_buffer[top_index].~T();
+      --top_index;
+      --current_size;
     }
 
   protected:
diff --git a/ivector.h b/ivector.h
index 033cfcde4..4a0090e85 100644
--- a/ivector.h
+++ b/ivector.h
@@ -193,25 +193,24 @@ namespace etl
     //*********************************************************************
     void resize(size_t new_size)
     {
-      if (ETL_ASSERT(new_size <= MAX_SIZE, ETL_ERROR(vector_full)))
+      ETL_ASSERT(new_size <= MAX_SIZE, ETL_ERROR(vector_full));
+
+      // Size up or size down?
+      if (new_size > current_size)
       {
-        // Size up or size down?
-        if (new_size > current_size)
+        for (size_t i = current_size; i < new_size; ++i)
         {
-          for (size_t i = current_size; i < new_size; ++i)
+          while (current_size < new_size)
           {
-            while (current_size < new_size)
-            {
-              create_element();
-            }
+            create_element();
           }
         }
-        else if (new_size < current_size)
+      }
+      else if (new_size < current_size)
+      {
+        while (current_size > new_size)
         {
-          while (current_size > new_size)
-          {
-            destroy_element();
-          }
+          destroy_element();
         }
       }
     }
@@ -225,23 +224,22 @@ namespace etl
     //*********************************************************************
     void resize(size_t new_size, T value)
     {
-      if (ETL_ASSERT(new_size <= MAX_SIZE, ETL_ERROR(vector_full)))
+      ETL_ASSERT(new_size <= MAX_SIZE, ETL_ERROR(vector_full));
+
+      // Size up?
+      if (new_size > current_size)
       {
-        // Size up?
-        if (new_size > current_size)
+        while (current_size < new_size)
         {
-          while (current_size < new_size)
-          {
-            create_element(value);
-          }
+          create_element(value);
         }
-        // Size down?
-        else if (new_size < current_size)
+      }
+      // Size down?
+      else if (new_size < current_size)
+      {
+        while (current_size > new_size)
         {
-          while (current_size > new_size)
-          {
-            destroy_element();
-          }
+          destroy_element();
         }
       }
     }
@@ -380,13 +378,12 @@ namespace etl
     {
       initialise();
 
-      if (ETL_ASSERT(n <= MAX_SIZE, ETL_ERROR(vector_full)))
+      ETL_ASSERT(n <= MAX_SIZE, ETL_ERROR(vector_full));
+
+      while (n > 0)
       {
-        while (n > 0)
-        {
-          create_element(value);
-          --n;
-        }
+        create_element(value);
+        --n;
       }
     }
 
@@ -404,10 +401,8 @@ namespace etl
     //*************************************************************************
     void push_back()
     {
-      if (ETL_ASSERT(current_size != MAX_SIZE, ETL_ERROR(vector_full)))
-      {
-        create_element();
-      }
+      ETL_ASSERT(current_size != MAX_SIZE, ETL_ERROR(vector_full));
+      create_element();
     }
 
     //*********************************************************************
@@ -417,10 +412,8 @@ namespace etl
     //*********************************************************************
     void push_back(parameter_t value)
     {
-      if (ETL_ASSERT(current_size != MAX_SIZE, ETL_ERROR(vector_full)))
-      {
-        create_element(value);
-      }
+      ETL_ASSERT(current_size != MAX_SIZE, ETL_ERROR(vector_full));
+      create_element(value);
     }
 
     //*************************************************************************
@@ -429,10 +422,8 @@ namespace etl
     //*************************************************************************
     void pop_back()
     {
-      if (current_size > 0)
-      {
-        destroy_element();
-      }
+      ETL_ASSERT(current_size > 0, ETL_ERROR(vector_empty));
+      destroy_element();
     }
 
     //*********************************************************************
@@ -443,15 +434,14 @@ namespace etl
     //*********************************************************************
     iterator insert(iterator position, parameter_t value)
     {
-      if (ETL_ASSERT((current_size) + 1 <= MAX_SIZE, ETL_ERROR(vector_full)))
-      {
-        create_element(value);
+      ETL_ASSERT((current_size)+1 <= MAX_SIZE, ETL_ERROR(vector_full));
 
-        if (position != end())
-        {
-          std::copy_backward(position, end() - 1, end());
-          *position = value;
-        }
+      create_element(value);
+
+      if (position != end())
+      {
+        std::copy_backward(position, end() - 1, end());
+        *position = value;
       }
 
       return position;
@@ -466,54 +456,53 @@ namespace etl
     //*********************************************************************
     void insert(iterator position, size_t n, parameter_t value)
     {
-      if (ETL_ASSERT((current_size) + 1 <= MAX_SIZE, ETL_ERROR(vector_full)))
+      ETL_ASSERT((current_size)+1 <= MAX_SIZE, ETL_ERROR(vector_full));
+
+      if (position == end())
       {
-        if (position == end())
+        while (n > 0)
         {
-          while (n > 0)
-          {
-            create_element(value);
-            --n;
-          }
+          create_element(value);
+          --n;
         }
-        else
+      }
+      else
+      {
+        size_t insert_index  = std::distance(begin(), position);
+        size_t n_insert      = n;
+        size_t n_move        = std::distance(position, end());
+        size_t n_create_copy = std::min(n_insert, n_move);
+        size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
+        size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
+        size_t n_copy_old    = (size() > n_insert) ? size() - n_insert : 0;
+
+        // Create copy (backwards).
+        size_t from = size() - 1;
+        size_t to   = from + n_insert;
+
+        for (size_t i = 0; i < n_create_copy; ++i)
         {
-          size_t insert_index  = std::distance(begin(), position);
-          size_t n_insert      = n;
-          size_t n_move        = std::distance(position, end());
-          size_t n_create_copy = std::min(n_insert, n_move);
-          size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
-          size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
-          size_t n_copy_old    = (size() > n_insert) ? size() - n_insert : 0;
-
-          // Create copy (backwards).
-          size_t from = size() - 1;
-          size_t to   = from + n_insert;
-
-          for (size_t i = 0; i < n_create_copy; ++i)
-          {
-            create_element_at(to--, p_buffer[from--]);
-          }
+          create_element_at(to--, p_buffer[from--]);
+        }
 
-          // Copy old.
-          from = insert_index;
-          to   = from + n_insert;
-          etl::copy_n(&p_buffer[from], n_copy_old, &p_buffer[to]);
+        // Copy old.
+        from = insert_index;
+        to   = from + n_insert;
+        etl::copy_n(&p_buffer[from], n_copy_old, &p_buffer[to]);
 
-          // Copy new.
-          to = insert_index;
-          std::fill_n(&p_buffer[to], n_copy_new, value);
+        // Copy new.
+        to = insert_index;
+        std::fill_n(&p_buffer[to], n_copy_new, value);
 
-          // Create new.
-          to = size();
+        // Create new.
+        to = size();
 
-          for (size_t i = 0; i < n_create_new; ++i)
-          {
-            create_element_at(to++, value);
-          }
-
-          current_size += n_insert;
+        for (size_t i = 0; i < n_create_new; ++i)
+        {
+          create_element_at(to++, value);
         }
+
+        current_size += n_insert;
       }
     }
 
@@ -529,55 +518,54 @@ namespace etl
     {
       size_t count = std::distance(first, last);
 
-      if (ETL_ASSERT((current_size) + count <= MAX_SIZE, ETL_ERROR(vector_full)))
+      ETL_ASSERT((current_size)+count <= MAX_SIZE, ETL_ERROR(vector_full));
+
+      if (position == end())
       {
-        if (position == end())
+        while (first != last)
         {
-          while (first != last)
-          {
-            create_element(*first);
-            ++first;
-          }
+          create_element(*first);
+          ++first;
         }
-        else
+      }
+      else
+      {
+        size_t insert_index  = std::distance(begin(), position);
+        size_t n_insert      = count;
+        size_t n_move        = std::distance(position, end());
+        size_t n_create_copy = std::min(n_insert, n_move);
+        size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
+        size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
+        size_t n_copy_old    = (size() > n_insert) ? size() - n_insert : 0;
+
+        // Create copy (backwards).
+        size_t from = size() - 1;
+        size_t to   = from + n_insert;
+
+        for (size_t i = 0; i < n_create_copy; ++i)
         {
-          size_t insert_index  = std::distance(begin(), position);
-          size_t n_insert      = count;
-          size_t n_move        = std::distance(position, end());
-          size_t n_create_copy = std::min(n_insert, n_move);
-          size_t n_create_new  = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
-          size_t n_copy_new    = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
-          size_t n_copy_old    = (size() > n_insert) ? size() - n_insert : 0;
-
-          // Create copy (backwards).
-          size_t from = size() - 1;
-          size_t to   = from + n_insert;
-
-          for (size_t i = 0; i < n_create_copy; ++i)
-          {
-            create_element_at(to--, p_buffer[from--]);
-          }
-
-          // Copy old.
-          from = insert_index;
-          to   = from + n_insert;
-          etl::copy_n(&p_buffer[from], n_copy_old, &p_buffer[to]);
+          create_element_at(to--, p_buffer[from--]);
+        }
 
-          // Copy new.
-          to = insert_index;
-          etl::copy_n(first, n_copy_new, &p_buffer[to]);
-          first += n_copy_new;
+        // Copy old.
+        from = insert_index;
+        to   = from + n_insert;
+        etl::copy_n(&p_buffer[from], n_copy_old, &p_buffer[to]);
 
-          // Create new.
-          to = size();
-          for (size_t i = 0; i < n_create_new; ++i)
-          {
-            create_element_at(to++, *first);
-            ++first;
-          }
+        // Copy new.
+        to = insert_index;
+        etl::copy_n(first, n_copy_new, &p_buffer[to]);
+        first += n_copy_new;
 
-          current_size += n_insert;
+        // Create new.
+        to = size();
+        for (size_t i = 0; i < n_create_new; ++i)
+        {
+          create_element_at(to++, *first);
+          ++first;
         }
+
+        current_size += n_insert;
       }
     }
 
diff --git a/jenkins.h b/jenkins.h
index 4b05076b8..3e3c2157c 100644
--- a/jenkins.h
+++ b/jenkins.h
@@ -107,15 +107,13 @@ namespace etl
     void add(TIterator begin, const TIterator end)
     {
       STATIC_ASSERT(sizeof(typename std::iterator_traits<TIterator>::value_type) == 1, "Incompatible type");
+      ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised));
 
-      if (ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised)))
+      while (begin != end)
       {
-        while (begin != end)
-        {
-          hash += *begin++;
-          hash += (hash << 10);
-          hash ^= (hash >> 6);
-        }
+        hash += *begin++;
+        hash += (hash << 10);
+        hash ^= (hash >> 6);
       }
     }
 
@@ -124,12 +122,11 @@ namespace etl
     //*************************************************************************
     void add(uint8_t value)
     {
-      if (ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised)))
-      {
-        hash += value;
-        hash += (hash << 10);
-        hash ^= (hash >> 6);
-      }
+      ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised));
+
+      hash += value;
+      hash += (hash << 10);
+      hash ^= (hash >> 6);
     }
 
     //*************************************************************************
diff --git a/murmur3.h b/murmur3.h
index 92178be7b..18aac14d0 100644
--- a/murmur3.h
+++ b/murmur3.h
@@ -120,22 +120,20 @@ namespace etl
     void add(TIterator begin, const TIterator end)
     {
       STATIC_ASSERT(sizeof(typename std::iterator_traits<TIterator>::value_type) == 1, "Incompatible type");
+      ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised));
 
-      if (ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised)))
+      while (begin != end)
       {
-        while (begin != end)
-        {
-          block |= (*begin++) << (block_fill_count * 8);
-
-          if (++block_fill_count == FULL_BLOCK)
-          {
-            add_block();
-            block_fill_count = 0;
-            block = 0;
-          }
+        block |= (*begin++) << (block_fill_count * 8);
 
-          ++char_count;
+        if (++block_fill_count == FULL_BLOCK)
+        {
+          add_block();
+          block_fill_count = 0;
+          block = 0;
         }
+
+        ++char_count;
       }
     }
 
@@ -147,19 +145,18 @@ namespace etl
     void add(uint8_t value)
     {
       // We can't add to a finalised hash!
-      if (ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised)))
-      {
-        block |= value << (block_fill_count * 8);
+      ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised));
 
-        if (++block_fill_count == FULL_BLOCK)
-        {
-          add_block();
-          block_fill_count = 0;
-          block = 0;
-        }
+      block |= value << (block_fill_count * 8);
 
-        ++char_count;
+      if (++block_fill_count == FULL_BLOCK)
+      {
+        add_block();
+        block_fill_count = 0;
+        block = 0;
       }
+
+      ++char_count;
     }
 
     //*************************************************************************
diff --git a/observer.h b/observer.h
index 529423eef..a18e30208 100644
--- a/observer.h
+++ b/observer.h
@@ -121,11 +121,10 @@ namespace etl
       if (i_observer == observer_list.end())
       {
         // Is there enough room?
-        if (ETL_ASSERT(!observer_list.full(), ETL_ERROR(etl::observer_list_full)))
-        {
-          // Add it.
-          observer_list.push_back(&observer);
-        }
+        ETL_ASSERT(!observer_list.full(), ETL_ERROR(etl::observer_list_full));
+
+        // Add it.
+        observer_list.push_back(&observer);
       }
     }
 
diff --git a/private/forward_list_base.h b/private/forward_list_base.h
index d742640e4..d11fd82e7 100644
--- a/private/forward_list_base.h
+++ b/private/forward_list_base.h
@@ -72,6 +72,20 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Empty exception for the forward_list.
+  ///\ingroup forward_list
+  //***************************************************************************
+  class forward_list_empty : public forward_list_exception
+  {
+  public:
+
+    forward_list_empty(string_type file_name, numeric_type line_number)
+      : forward_list_exception(ETL_ERROR_TEXT("forward_list:empty", ETL_FILE"B"), file_name, line_number)
+    {
+    }
+  };
+
   //***************************************************************************
   /// Iterator exception for the forward_list.
   ///\ingroup forward_list
@@ -81,7 +95,7 @@ namespace etl
   public:
 
     forward_list_iterator(string_type file_name, numeric_type line_number)
-      : forward_list_exception(ETL_ERROR_TEXT("forward_list:iterator", ETL_FILE"B"), file_name, line_number)
+      : forward_list_exception(ETL_ERROR_TEXT("forward_list:iterator", ETL_FILE"C"), file_name, line_number)
     {
     }
   };
diff --git a/private/list_base.h b/private/list_base.h
index 80e74a2d9..56c1bf8e4 100644
--- a/private/list_base.h
+++ b/private/list_base.h
@@ -72,6 +72,20 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Empty exception for the list.
+  ///\ingroup list
+  //***************************************************************************
+  class list_empty : public list_exception
+  {
+  public:
+
+    list_empty(string_type file_name, numeric_type line_number)
+      : list_exception(ETL_ERROR_TEXT("list:empty", ETL_FILE"B"), file_name, line_number)
+    {
+    }
+  };
+
   //***************************************************************************
   /// Iterator exception for the list.
   ///\ingroup list
@@ -81,7 +95,7 @@ namespace etl
   public:
 
     list_iterator(string_type file_name, numeric_type line_number)
-      : list_exception(ETL_ERROR_TEXT("list:iterator", ETL_FILE"B"), file_name, line_number)
+      : list_exception(ETL_ERROR_TEXT("list:iterator", ETL_FILE"C"), file_name, line_number)
     {
     }
   };
diff --git a/private/stack_base.h b/private/stack_base.h
index 790b8f3b8..e3e6c556a 100644
--- a/private/stack_base.h
+++ b/private/stack_base.h
@@ -67,7 +67,21 @@ namespace etl
   public:
 
     stack_full(string_type file_name, numeric_type line_number)
-      : stack_exception(ETL_ERROR_TEXT("stack: full", ETL_FILE"A"), file_name, line_number)
+      : stack_exception(ETL_ERROR_TEXT("stack:full", ETL_FILE"A"), file_name, line_number)
+    {
+    }
+  };
+
+  //***************************************************************************
+  ///\ingroup stack
+  /// The exception thrown when the stack is empty.
+  //***************************************************************************
+  class stack_empty : public stack_exception
+  {
+  public:
+
+    stack_empty(string_type file_name, numeric_type line_number)
+      : stack_exception(ETL_ERROR_TEXT("stack:empty", ETL_FILE"B"), file_name, line_number)
     {
     }
   };
diff --git a/private/vector_base.h b/private/vector_base.h
index 2d3fc8c6f..026902b61 100644
--- a/private/vector_base.h
+++ b/private/vector_base.h
@@ -67,7 +67,21 @@ namespace etl
   public:
 
     vector_full(string_type file_name, numeric_type line_number)
-      : vector_exception(ETL_ERROR_TEXT("vector:full", ETL_FILE"0"), file_name, line_number)
+      : vector_exception(ETL_ERROR_TEXT("vector:full", ETL_FILE"A"), file_name, line_number)
+    {
+    }
+  };
+
+  //***************************************************************************
+  ///\ingroup vector
+  /// Vector empty exception.
+  //***************************************************************************
+  class vector_empty : public vector_exception
+  {
+  public:
+
+    vector_empty(string_type file_name, numeric_type line_number)
+      : vector_exception(ETL_ERROR_TEXT("vector:empty", ETL_FILE"B"), file_name, line_number)
     {
     }
   };
@@ -81,7 +95,7 @@ namespace etl
   public:
 
     vector_out_of_bounds(string_type file_name, numeric_type line_number)
-      : vector_exception(ETL_ERROR_TEXT("vector:bounds", ETL_FILE"1"), file_name, line_number)
+      : vector_exception(ETL_ERROR_TEXT("vector:bounds", ETL_FILE"C"), file_name, line_number)
     {
     }
   };
@@ -95,7 +109,7 @@ namespace etl
   public:
 
     vector_iterator(string_type file_name, numeric_type line_number)
-      : vector_exception(ETL_ERROR_TEXT("vector:iterator", ETL_FILE"2"), file_name, line_number)
+      : vector_exception(ETL_ERROR_TEXT("vector:iterator", ETL_FILE"D"), file_name, line_number)
     {
     }
   };
diff --git a/test/keil/Test1.uvguix.John b/test/keil/Test1.uvguix.John
index d3cdd9cb3..60941e9a9 100644
--- a/test/keil/Test1.uvguix.John
+++ b/test/keil/Test1.uvguix.John
@@ -93,7 +93,7 @@
       <RegID>0</RegID>
       <MDITabState>
         <Len>693</Len>
-        <Data>01000000040000000100000001000000010000000100000000000000020000000000000001000000010000000000000028000000280000000100000006000000000000000100000044443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C746573745C746573745F636F6D70696C652E6370700000000010746573745F636F6D70696C652E637070000000009CC1B600FFFFFFFF3B443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C63726336345F65636D612E68000000000C63726336345F65636D612E6800000000BCA8E100FFFFFFFF36443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C696C6973742E680000000007696C6973742E6800000000F0A0A100FFFFFFFF3A443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C616C676F726974686D2E68000000000B616C676F726974686D2E6800000000BECEA100FFFFFFFF38443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C696269747365742E680000000009696269747365742E6800000000FFDC7800FFFFFFFF37443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C6269747365742E6800000000086269747365742E6800000000C5D4F200FFFFFFFF0100000010000000C5D4F200FFDC7800BECEA100F0A0A100BCA8E1009CC1B600F7B88600D9ADC200A5C2D700B3A6BE00EAD6A300F6FA7D00B5E99D005FC3CF00C1838300CACAD500010000000000000002000000940100006600000080070000FD030000</Data>
+        <Data>01000000040000000100000001000000010000000100000000000000020000000000000001000000010000000000000028000000280000000100000006000000000000000100000044443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C746573745C746573745F636F6D70696C652E6370700000000010746573745F636F6D70696C652E63707000000000F7B88600FFFFFFFF3B443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C63726336345F65636D612E68000000000C63726336345F65636D612E68000000009CC1B600FFFFFFFF36443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C696C6973742E680000000007696C6973742E6800000000BCA8E100FFFFFFFF3A443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C616C676F726974686D2E68000000000B616C676F726974686D2E6800000000F0A0A100FFFFFFFF38443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C696269747365742E680000000009696269747365742E6800000000BECEA100FFFFFFFF37443A5C55736572735C4A6F686E5C446F63756D656E74735C50726F6772616D6D696E675C4769744875625C65746C5C6269747365742E6800000000086269747365742E6800000000FFDC7800FFFFFFFF0100000010000000C5D4F200FFDC7800BECEA100F0A0A100BCA8E1009CC1B600F7B88600D9ADC200A5C2D700B3A6BE00EAD6A300F6FA7D00B5E99D005FC3CF00C1838300CACAD500010000000000000002000000940100006600000080070000FD030000</Data>
       </MDITabState>
     </MDIClientArea>
     <ViewEx>
@@ -116,7 +116,7 @@
         </RectRecentDocked>
         <RectRecentFloat>
           <Len>16</Len>
-          <Data>81070000000000007E0C0000E9030000</Data>
+          <Data>81070000430000007E0C00003A040000</Data>
         </RectRecentFloat>
       </Window>
       <Window>
@@ -476,7 +476,7 @@
         </RectRecentDocked>
         <RectRecentFloat>
           <Len>16</Len>
-          <Data>81070000000000007E0C0000E9030000</Data>
+          <Data>81070000430000007E0C00003A040000</Data>
         </RectRecentFloat>
       </Window>
       <Window>
@@ -516,7 +516,7 @@
         </RectRecentDocked>
         <RectRecentFloat>
           <Len>16</Len>
-          <Data>81070000000000007E0C0000E9030000</Data>
+          <Data>81070000430000007E0C00003A040000</Data>
         </RectRecentFloat>
       </Window>
       <Window>
@@ -1136,7 +1136,7 @@
         </RectRecentDocked>
         <RectRecentFloat>
           <Len>16</Len>
-          <Data>81070000000000007E0C0000E9030000</Data>
+          <Data>81070000430000007E0C00003A040000</Data>
         </RectRecentFloat>
       </Window>
       <Window>
@@ -1156,7 +1156,7 @@
         </RectRecentDocked>
         <RectRecentFloat>
           <Len>16</Len>
-          <Data>81070000000000007E0C0000E9030000</Data>
+          <Data>81070000430000007E0C00003A040000</Data>
         </RectRecentFloat>
       </Window>
       <Window>
@@ -1281,14 +1281,14 @@
       </Window>
       <DockMan>
         <Len>2607</Len>
-        <Data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ata>
+        <Data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ata>
       </DockMan>
       <ToolBar>
         <RegID>59392</RegID>
         <Name>File</Name>
         <Buttons>
-          <Len>2015</Len>
-          <Data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ata>
+          <Len>2061</Len>
+          <Data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ata>
         </Buttons>
         <OriginalItems>
           <Len>1423</Len>
@@ -1320,7 +1320,7 @@
         <Name>Debug</Name>
         <Buttons>
           <Len>2220</Len>
-          <Data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ata>
+          <Data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ata>
         </Buttons>
         <OriginalItems>
           <Len>898</Len>
@@ -2588,9 +2588,9 @@
       <ActiveTab>0</ActiveTab>
       <Doc>
         <Name>..\test_compile.cpp</Name>
-        <ColumnNumber>14</ColumnNumber>
+        <ColumnNumber>0</ColumnNumber>
         <TopLine>137</TopLine>
-        <CurrentLine>160</CurrentLine>
+        <CurrentLine>161</CurrentLine>
         <Folding>1</Folding>
         <ContractedFolders></ContractedFolders>
         <PaneID>0</PaneID>