From c3b25e6fe1b84f77c2b0ee861b896c973884bc90 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Mon, 27 Aug 2018 22:06:10 +0100 Subject: [PATCH 1/3] ARM project updates --- .../ArmTimerCallbacks.uvoptx | 2 ++ .../ArmTimerCallbacks.uvprojx | 27 ++++++++++--------- .../ArmTimerCallbacks - C++/etl_profile.h | 3 +-- 3 files changed, 17 insertions(+), 15 deletions(-) diff --git a/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvoptx b/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvoptx index 8a5d0503..040f00a1 100644 --- a/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvoptx +++ b/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvoptx @@ -101,6 +101,8 @@ 0 0 1 + 0 + 0 5 diff --git a/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx b/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx index b7fa094b..d92ef376 100644 --- a/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx +++ b/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx @@ -10,13 +10,13 @@ Target 1 0x4 ARM-ADS - 6070000::V6.7::.\ARMCLANG - 1 + 5060750::V5.06 update 6 (build 750)::ARMCC + 0 STM32F401RETx STMicroelectronics - Keil.STM32F4xx_DFP.2.11.0 + Keil.STM32F4xx_DFP.2.13.0 http://www.keil.com/pack IRAM(0x20000000,0x18000) IROM(0x08000000,0x80000) CPUTYPE("Cortex-M4") FPU2 CLOCK(12000000) ELITTLE @@ -311,7 +311,7 @@ 1 - 7 + 1 0 0 1 @@ -320,10 +320,11 @@ 1 0 0 - 3 + 2 0 0 1 + 0 0 3 3 @@ -421,8 +422,8 @@ - - + + @@ -439,8 +440,8 @@ - - + + @@ -449,16 +450,16 @@ RTE\Device\STM32F401RETx\startup_stm32f401xe.s - - + + RTE\Device\STM32F401RETx\system_stm32f4xx.c - - + + diff --git a/examples/ArmTimerCallbacks - C++/etl_profile.h b/examples/ArmTimerCallbacks - C++/etl_profile.h index a2e2f33f..0e874e1e 100644 --- a/examples/ArmTimerCallbacks - C++/etl_profile.h +++ b/examples/ArmTimerCallbacks - C++/etl_profile.h @@ -2,14 +2,13 @@ #ifndef __ETL_PROFILE_H__ #define __ETL_PROFILE_H__ -#define ETL_THROW_EXCEPTIONS #define ETL_VERBOSE_ERRORS #define ETL_CHECK_PUSH_POP #define ETL_ISTRING_REPAIR_ENABLE #define ETL_IVECTOR_REPAIR_ENABLE #define ETL_IDEQUE_REPAIR_ENABLE -#define ETL_IN_UNIT_TEST #define ETL_CALLBACK_TIMER_USE_ATOMIC_LOCK +#define ETL_NO_STL #if (__CC_ARM == 1) // ARM5 compiler From b6b6a36316aa47d9b2c6c587ef9daa258a40daa6 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Mon, 27 Aug 2018 22:06:49 +0100 Subject: [PATCH 2/3] Added missing find_n & transform --- include/etl/stl/alternate/algorithm.h | 45 ++++++++++++++++++++++ test/test_no_stl_algorithm.cpp | 55 +++++++++++++++++++++++++++ 2 files changed, 100 insertions(+) diff --git a/include/etl/stl/alternate/algorithm.h b/include/etl/stl/alternate/algorithm.h index 02566915..f234b132 100644 --- a/include/etl/stl/alternate/algorithm.h +++ b/include/etl/stl/alternate/algorithm.h @@ -292,6 +292,27 @@ SOFTWARE. memset(first, value, last - first); } + //*************************************************************************** + // fill_n + template + typename etl::enable_if::value || etl::is_same::value) || !etl::is_pointer::value, TIterator>::type + fill_n(TIterator first, TSize count, const TValue& value) + { + for (TSize i = 0; i < count; ++i) + { + *first++ = value; + } + + return first; + } + + template + typename etl::enable_if<(etl::is_same::value || etl::is_same::value) && etl::is_pointer::value, void>::type + fill_n(TIterator first, TSize count, const TValue& value) + { + memset(first, value, count); + } + //*************************************************************************** // count template @@ -447,6 +468,30 @@ SOFTWARE. return ETLSTD::max(a, b, compare()); } + //*************************************************************************** + // transform + template + TIteratorOut transform(TIteratorIn first1, TIteratorIn last1, TIteratorOut d_first, TUnaryOperation unary_operation) + { + while (first1 != last1) + { + *d_first++ = unary_operation(*first1++); + } + + return d_first; + } + + template + TIteratorOut transform(TIteratorIn1 first1, TIteratorIn1 last1, TIteratorIn2 first2, TIteratorOut d_first, TBinaryOperation binary_operation) + { + while (first1 != last1) + { + *d_first++ = binary_operation(*first1++, *first2++); + } + + return d_first; + } + //*************************************************************************** // Heap namespace private_heap diff --git a/test/test_no_stl_algorithm.cpp b/test/test_no_stl_algorithm.cpp index 3a7d7442..a430b761 100644 --- a/test/test_no_stl_algorithm.cpp +++ b/test/test_no_stl_algorithm.cpp @@ -57,6 +57,9 @@ namespace typedef std::list List; List dataL = { 2, 1, 4, 3, 6, 5, 8, 7, 10, 9 }; + int dataD1[SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + int dataD2[SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + class Data { public: @@ -591,5 +594,57 @@ namespace CHECK(c1 == c2); } + + //************************************************************************* + TEST(fill_n) + { + int* p1 = std::fill_n(std::begin(dataD1), SIZE, 5); + int* p2 = etlstd::fill_n(std::begin(dataD2), SIZE, 5); + + CHECK(p2 == std::end(dataD2)); + + bool isEqual = std::equal(std::begin(dataD1), std::end(dataD1), std::begin(dataD2)); + CHECK(isEqual); + } + + //************************************************************************* + TEST(transform1) + { + struct Function + { + int operator()(int d) const + { + return d * 2; + } + }; + + int* p1 = std::transform(std::begin(dataS), std::end(dataS), std::begin(dataD1), Function()); + int* p2 = std::transform(std::begin(dataS), std::end(dataS), std::begin(dataD2), Function()); + + CHECK(p2 == std::end(dataD2)); + + bool isEqual = std::equal(std::begin(dataD1), std::end(dataD1), std::begin(dataD2)); + CHECK(isEqual); + } + + //************************************************************************* + TEST(transform2) + { + struct Function + { + int operator()(int d1, int d2) const + { + return d1 + d2; + } + }; + + int* p1 = std::transform(std::begin(dataS), std::end(dataS), std::begin(dataA), std::begin(dataD1), Function()); + int* p2 = std::transform(std::begin(dataS), std::end(dataS), std::begin(dataA), std::begin(dataD2), Function()); + + CHECK(p2 == std::end(dataD2)); + + bool isEqual = std::equal(std::begin(dataD1), std::end(dataD1), std::begin(dataD2)); + CHECK(isEqual); + } }; } From e5e38a8ee82af9093640e376ec6b681980746442 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Mon, 27 Aug 2018 22:07:17 +0100 Subject: [PATCH 3/3] Compatibility with Keil compiler --- include/etl/atomic/atomic_gcc_sync.h | 6 +- include/etl/atomic/atomic_llvm_sync.h | 785 +++++++++++++++++++++++++ include/etl/atomic/atomic_std.h | 1 + include/etl/basic_string.h | 2 +- include/etl/callback_timer.h | 3 +- include/etl/cstring.h | 5 +- include/etl/deque.h | 7 +- include/etl/memory.h | 4 +- include/etl/private/pvoidvector.h | 2 +- include/etl/stl/alternate/functional.h | 2 +- include/etl/stl/alternate/iterator.h | 36 +- include/etl/u16string.h | 5 +- include/etl/u32string.h | 5 +- include/etl/vector.h | 9 +- include/etl/wstring.h | 5 +- src/private/pvoidvector.cpp | 2 +- test/vs2017/etl.vcxproj | 1 + test/vs2017/etl.vcxproj.filters | 3 + 18 files changed, 848 insertions(+), 35 deletions(-) create mode 100644 include/etl/atomic/atomic_llvm_sync.h diff --git a/include/etl/atomic/atomic_gcc_sync.h b/include/etl/atomic/atomic_gcc_sync.h index 725c44ac..80ce7c2d 100644 --- a/include/etl/atomic/atomic_gcc_sync.h +++ b/include/etl/atomic/atomic_gcc_sync.h @@ -33,12 +33,14 @@ SOFTWARE. #include "../type_traits.h" #include "../static_assert.h" #include "../nullptr.h" +#include "../char_traits.h" -//#include #include +#if defined(ETL_COMPILER_GCC) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" +#endif namespace etl { @@ -785,6 +787,8 @@ namespace etl typedef etl::atomic atomic_uintmax_t; } +#if defined(ETL_COMPILER_GCC) #pragma GCC diagnostic pop +#endif #endif diff --git a/include/etl/atomic/atomic_llvm_sync.h b/include/etl/atomic/atomic_llvm_sync.h new file mode 100644 index 00000000..50e0be01 --- /dev/null +++ b/include/etl/atomic/atomic_llvm_sync.h @@ -0,0 +1,785 @@ +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2017 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_ATOMIC_LLVM_SYNC_INCLUDED +#define ETL_ATOMIC_LLVM_SYNC_INCLUDED + +//#include "../platform.h" +//#include "../type_traits.h" +//#include "../static_assert.h" +//#include "../nullptr.h" +//#include "../char_traits.h" +// +//#include +// +//namespace etl +//{ +// //*************************************************************************** +// // Atomic type for pre C++11 GCC compilers that support the builtin '__sync' functions. +// // Only integral and pointer types are supported. +// //*************************************************************************** +// +// typedef enum memory_order +// { +// memory_order_relaxed, +// memory_order_consume, +// memory_order_acquire, +// memory_order_release, +// memory_order_acq_rel, +// memory_order_seq_cst +// } memory_order; +// +// template +// class atomic +// { +// public: +// +// ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); +// +// atomic() +// : value(0) +// { +// } +// +// atomic(T v) +// : value(v) +// { +// } +// +// // Assignment +// T operator =(T v) +// { +// store(v); +// +// return v; +// } +// +// T operator =(T v) volatile +// { +// store(v); +// +// return v; +// } +// +// // Pre-increment +// T operator ++() +// { +// return fetch_add(1) + 1; +// } +// +// T operator ++() volatile +// { +// return fetch_add(1) + 1; +// } +// +// // Post-increment +// T operator ++(int) +// { +// return fetch_add(1); +// } +// +// T operator ++(int) volatile +// { +// return fetch_add(1); +// } +// +// // Pre-decrement +// T operator --() +// { +// return fetch_sub(1) + 1; +// } +// +// T operator --() volatile +// { +// return fetch_sub(1) + 1; +// } +// +// // Post-decrement +// T operator --(int) +// { +// return fetch_sub(1); +// } +// +// T operator --(int) volatile +// { +// return fetch_sub(1); +// } +// +// // Add +// T operator +=(T v) +// { +// return fetch_add(v) + v; +// } +// +// T operator +=(T v) volatile +// { +// return fetch_add(v) + v; +// } +// +// // Subtract +// T operator -=(T v) +// { +// return fetch_sub(v) - v; +// } +// +// T operator -=(T v) volatile +// { +// return fetch_sub(v) - v; +// } +// +// // And +// T operator &=(T v) +// { +// return fetch_and(v) & v; +// } +// +// T operator &=(T v) volatile +// { +// return fetch_and(v) & v; +// } +// +// // Or +// T operator |=(T v) +// { +// return fetch_or(v) | v; +// } +// +// T operator |=(T v) volatile +// { +// return fetch_or(v) | v; +// } +// +// // Exclusive or +// T operator ^=(T v) +// { +// return fetch_xor(v) ^ v; +// } +// +// T operator ^=(T v) volatile +// { +// return fetch_xor(v) ^ v; +// } +// +// // Conversion operator +// operator T () const +// { +// return __sync_fetch_and_add(&value, 0); +// } +// +// operator T() volatile const +// { +// return __sync_fetch_and_add(&value, 0); +// } +// +// // Is lock free? +// bool is_lock_free() const +// { +// return true; +// } +// +// bool is_lock_free() const volatile +// { +// return true; +// } +// +// // Store +// void store(T v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// __sync_lock_test_and_set(&value, v); +// } +// +// void store(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// __sync_lock_test_and_set(&value, v); +// } +// +// // Load +// T load(etl::memory_order order = etl::memory_order_seq_cst) const +// { +// return __sync_fetch_and_add(&value, 0); +// } +// +// T load(etl::memory_order order = etl::memory_order_seq_cst) const volatile +// { +// return __sync_fetch_and_add(&value, 0); +// } +// +// // Fetch add +// T fetch_add(T v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// return __sync_fetch_and_add(&value, v); +// } +// +// T fetch_add(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// return __sync_fetch_and_add(&value, v); +// } +// +// // Fetch subtract +// T fetch_sub(T v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// return __sync_fetch_and_sub(&value, v); +// } +// +// T fetch_sub(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// return __sync_fetch_and_sub(&value, v); +// } +// +// // Fetch or +// T fetch_or(T v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// return __sync_fetch_and_or(&value, v); +// } +// +// T fetch_or(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// return __sync_fetch_and_or(&value, v); +// } +// +// // Fetch and +// T fetch_and(T v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// return __sync_fetch_and_and(&value, v); +// } +// +// T fetch_and(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// return __sync_fetch_and_and(&value, v); +// } +// +// // Fetch exclusive or +// T fetch_xor(T v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// return __sync_fetch_and_xor(&value, v); +// } +// +// T fetch_xor(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// return __sync_fetch_and_xor(&value, v); +// } +// +// // Exchange +// T exchange(T v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// return __sync_lock_test_and_set(&value, v); +// } +// +// T exchange(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// return __sync_lock_test_and_set(&value, v); +// } +// +// // Compare exchange weak +// bool compare_exchange_weak(T& expected, T desired, etl::memory_order order = etl::memory_order_seq_cst) +// { +// T old = __sync_val_compare_and_swap(&value, expected, desired); +// +// if (old == expected) +// { +// return true; +// } +// else +// { +// expected = old; +// return false; +// } +// } +// +// bool compare_exchange_weak(T& expected, T desired, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// T old = __sync_val_compare_and_swap(&value, expected, desired); +// +// if (old == expected) +// { +// return true; +// } +// else +// { +// expected = old; +// return false; +// } +// } +// +// bool compare_exchange_weak(T& expected, T desired, etl::memory_order success, etl::memory_order failure) +// { +// T old = __sync_val_compare_and_swap(&value, expected, desired); +// +// if (old == expected) +// { +// return true; +// } +// else +// { +// expected = old; +// return false; +// } +// } +// +// bool compare_exchange_weak(T& expected, T desired, etl::memory_order success, etl::memory_order failure) volatile +// { +// T old = __sync_val_compare_and_swap(&value, expected, desired); +// +// if (old == expected) +// { +// return true; +// } +// else +// { +// expected = old; +// return false; +// } +// } +// +// // Compare exchange strong +// bool compare_exchange_strong(T& expected, T desired, etl::memory_order order = etl::memory_order_seq_cst) +// { +// T old = expected; +// +// while (!compare_exchange_weak(old, desired)) +// { +// if (memcmp(&old, &expected, sizeof(T))) +// { +// expected = old; +// return false; +// } +// } +// +// return true; +// } +// +// bool compare_exchange_strong(T& expected, T desired, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// T old = expected; +// +// while (!compare_exchange_weak(old, desired)) +// { +// if (memcmp(&old, &expected, sizeof(T))) +// { +// expected = old; +// return false; +// } +// } +// +// return true; +// } +// +// bool compare_exchange_strong(T& expected, T desired, etl::memory_order success, etl::memory_order failure) +// { +// T old = expected; +// +// while (!compare_exchange_weak(old, desired)) +// { +// if (memcmp(&old, &expected, sizeof(T))) +// { +// expected = old; +// return false; +// } +// } +// +// return true; +// } +// +// bool compare_exchange_strong(T& expected, T desired, etl::memory_order success, etl::memory_order failure) volatile +// { +// T old = expected; +// +// while (!compare_exchange_weak(old, desired)) +// { +// if (memcmp(&old, &expected, sizeof(T))) +// { +// expected = old; +// return false; +// } +// } +// +// return true; +// } +// +// private: +// +// atomic& operator =(const atomic&); +// atomic& operator =(const atomic&) volatile; +// +// mutable volatile T value; +// }; +// +// template +// class atomic +// { +// public: +// +// atomic() +// : value(nullptr) +// { +// } +// +// atomic(T* v) +// : value(v) +// { +// } +// +// // Assignment +// T* operator =(T* v) +// { +// store(v); +// +// return v; +// } +// +// T* operator =(T* v) volatile +// { +// store(v); +// +// return v; +// } +// +// // Pre-increment +// T* operator ++() +// { +// return fetch_add(1) + 1; +// } +// +// T* operator ++() volatile +// { +// return fetch_add(1) + 1; +// } +// +// // Post-increment +// T* operator ++(int) +// { +// return fetch_add(1); +// } +// +// T* operator ++(int) volatile +// { +// return fetch_add(1); +// } +// +// // Pre-decrement +// T* operator --() +// { +// return fetch_sub(1) + 1; +// } +// +// T* operator --() volatile +// { +// return fetch_sub(1) + 1; +// } +// +// // Post-decrement +// T* operator --(int) +// { +// return fetch_sub(1); +// } +// +// T* operator --(int) volatile +// { +// return fetch_sub(1); +// } +// +// // Add +// T* operator +=(ptrdiff_t v) +// { +// return fetch_add(v) + v; +// } +// +// T* operator +=(ptrdiff_t v) volatile +// { +// return fetch_add(v) + v; +// } +// +// // Subtract +// T* operator -=(ptrdiff_t v) +// { +// return fetch_sub(v) - v; +// } +// +// T* operator -=(ptrdiff_t v) volatile +// { +// return fetch_sub(v) - v; +// } +// +// // Conversion operator +// operator T* () const +// { +// return __sync_fetch_and_add(&value, 0); +// } +// +// operator T*() volatile const +// { +// return __sync_fetch_and_add(&value, 0); +// } +// +// // Is lock free? +// bool is_lock_free() const +// { +// return true; +// } +// +// bool is_lock_free() const volatile +// { +// return true; +// } +// +// // Store +// void store(T* v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// __sync_lock_test_and_set(&value, v); +// } +// +// void store(T* v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// __sync_lock_test_and_set(&value, v); +// } +// +// // Load +// T* load(etl::memory_order order = etl::memory_order_seq_cst) const +// { +// return __sync_fetch_and_add(&value, 0); +// } +// +// T* load(etl::memory_order order = etl::memory_order_seq_cst) const volatile +// { +// return __sync_fetch_and_add(&value, 0); +// } +// +// // Fetch add +// T* fetch_add(ptrdiff_t v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// return __sync_fetch_and_add(&value, v); +// } +// +// T* fetch_add(ptrdiff_t v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// return __sync_fetch_and_add(&value, v); +// } +// +// // Fetch subtract +// T* fetch_sub(ptrdiff_t v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// return __sync_fetch_and_sub(&value, v); +// } +// +// T* fetch_sub(ptrdiff_t v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// return __sync_fetch_and_sub(&value, v); +// } +// +// // Exchange +// T* exchange(T* v, etl::memory_order order = etl::memory_order_seq_cst) +// { +// return __sync_lock_test_and_set(&value, v); +// } +// +// T* exchange(T* v, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// return __sync_lock_test_and_set(&value, v); +// } +// +// // Compare exchange weak +// bool compare_exchange_weak(T*& expected, T* desired, etl::memory_order order = etl::memory_order_seq_cst) +// { +// T* old = __sync_val_compare_and_swap(&value, expected, desired); +// +// if (old == expected) +// { +// return true; +// } +// else +// { +// expected = old; +// return false; +// } +// } +// +// bool compare_exchange_weak(T*& expected, T* desired, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// T* old = __sync_val_compare_and_swap(&value, expected, desired); +// +// if (old == expected) +// { +// return true; +// } +// else +// { +// expected = old; +// return false; +// } +// } +// +// bool compare_exchange_weak(T*& expected, T* desired, etl::memory_order success, etl::memory_order failure) +// { +// T* old = __sync_val_compare_and_swap(&value, expected, desired); +// +// if (old == expected) +// { +// return true; +// } +// else +// { +// expected = old; +// return false; +// } +// } +// +// bool compare_exchange_weak(T*& expected, T* desired, etl::memory_order success, etl::memory_order failure) volatile +// { +// T* old = __sync_val_compare_and_swap(&value, expected, desired); +// +// if (old == expected) +// { +// return true; +// } +// else +// { +// expected = old; +// return false; +// } +// } +// +// // Compare exchange strong +// bool compare_exchange_strong(T*& expected, T* desired, etl::memory_order order = etl::memory_order_seq_cst) +// { +// T* old = expected; +// +// while (!compare_exchange_weak(old, desired)) +// { +// if (memcmp(&old, &expected, sizeof(T*))) +// { +// expected = old; +// return false; +// } +// } +// +// return true; +// } +// +// bool compare_exchange_strong(T*& expected, T* desired, etl::memory_order order = etl::memory_order_seq_cst) volatile +// { +// T* old = expected; +// +// while (!compare_exchange_weak(old, desired)) +// { +// if (memcmp(&old, &expected, sizeof(T*))) +// { +// expected = old; +// return false; +// } +// } +// +// return true; +// } +// +// bool compare_exchange_strong(T*& expected, T* desired, etl::memory_order success, etl::memory_order failure) +// { +// T* old = expected; +// +// while (!compare_exchange_weak(old, desired)) +// { +// if (memcmp(&old, &expected, sizeof(T*))) +// { +// expected = old; +// return false; +// } +// } +// +// return true; +// } +// +// bool compare_exchange_strong(T*& expected, T* desired, etl::memory_order success, etl::memory_order failure) volatile +// { +// T* old = expected; +// +// while (!compare_exchange_weak(old, desired)) +// { +// if (memcmp(&old, &expected, sizeof(T*))) +// { +// expected = old; +// return false; +// } +// } +// +// return true; +// } +// +// private: +// +// atomic& operator =(const atomic&); +// atomic& operator =(const atomic&) volatile; +// +// mutable volatile T* value; +// }; +// +// typedef etl::atomic atomic_char; +// typedef etl::atomic atomic_schar; +// typedef etl::atomic atomic_uchar; +// typedef etl::atomic atomic_short; +// typedef etl::atomic atomic_ushort; +// typedef etl::atomic atomic_int; +// typedef etl::atomic atomic_uint; +// typedef etl::atomic atomic_long; +// typedef etl::atomic atomic_ulong; +// typedef etl::atomic atomic_llong; +// typedef etl::atomic atomic_ullong; +// typedef etl::atomic atomic_wchar_t; +// typedef etl::atomic atomic_char16_t; +// typedef etl::atomic atomic_char32_t; +// typedef etl::atomic atomic_uint8_t; +// typedef etl::atomic atomic_int8_t; +// typedef etl::atomic atomic_uint16_t; +// typedef etl::atomic atomic_int16_t; +// typedef etl::atomic atomic_uint32_t; +// typedef etl::atomic atomic_int32_t; +// typedef etl::atomic atomic_uint64_t; +// typedef etl::atomic atomic_int64_t; +// typedef etl::atomic atomic_int_least8_t; +// typedef etl::atomic atomic_uint_least8_t; +// typedef etl::atomic atomic_int_least16_t; +// typedef etl::atomic atomic_uint_least16_t; +// typedef etl::atomic atomic_int_least32_t; +// typedef etl::atomic atomic_uint_least32_t; +// typedef etl::atomic atomic_int_least64_t; +// typedef etl::atomic atomic_uint_least64_t; +// typedef etl::atomic atomic_int_fast8_t; +// typedef etl::atomic atomic_uint_fast8_t; +// typedef etl::atomic atomic_int_fast16_t; +// typedef etl::atomic atomic_uint_fast16_t; +// typedef etl::atomic atomic_int_fast32_t; +// typedef etl::atomic atomic_uint_fast32_t; +// typedef etl::atomic atomic_int_fast64_t; +// typedef etl::atomic atomic_uint_fast64_t; +// typedef etl::atomic atomic_intptr_t; +// typedef etl::atomic atomic_uintptr_t; +// typedef etl::atomic atomic_size_t; +// typedef etl::atomic atomic_ptrdiff_t; +// typedef etl::atomic atomic_intmax_t; +// typedef etl::atomic atomic_uintmax_t; +//} + +#endif diff --git a/include/etl/atomic/atomic_std.h b/include/etl/atomic/atomic_std.h index eb3cd146..e2e7fea9 100644 --- a/include/etl/atomic/atomic_std.h +++ b/include/etl/atomic/atomic_std.h @@ -31,6 +31,7 @@ SOFTWARE. #include "../platform.h" #include "../nullptr.h" +#include "../char_traits.h" #include #include diff --git a/include/etl/basic_string.h b/include/etl/basic_string.h index b87f989b..b823293d 100644 --- a/include/etl/basic_string.h +++ b/include/etl/basic_string.h @@ -1922,7 +1922,7 @@ namespace etl //************************************************************************* /// Fix the internal pointers after a low level memory copy. //************************************************************************* - void repair(T* p_buffer_) + void repair_buffer(T* p_buffer_) { p_buffer = p_buffer_; } diff --git a/include/etl/callback_timer.h b/include/etl/callback_timer.h index a57f9d5d..0d1ff258 100644 --- a/include/etl/callback_timer.h +++ b/include/etl/callback_timer.h @@ -30,9 +30,10 @@ SOFTWARE. #define ETL_CALLBACK_TIMER_INCLUDED #include -#include "algorithm.h" +#include #include "platform.h" +#include "algorithm.h" #include "nullptr.h" #include "function.h" #include "static_assert.h" diff --git a/include/etl/cstring.h b/include/etl/cstring.h index 87ab5d5a..01ff2d12 100644 --- a/include/etl/cstring.h +++ b/include/etl/cstring.h @@ -189,9 +189,12 @@ namespace etl //************************************************************************* /// Fix the internal pointers after a low level memory copy. //************************************************************************* +#ifdef ETL_ISTRING_REPAIR_ENABLE + virtual +#endif void repair() { - etl::istring::repair(buffer); + etl::istring::repair_buffer(buffer); } private: diff --git a/include/etl/deque.h b/include/etl/deque.h index 98e2feef..bdcd4b85 100644 --- a/include/etl/deque.h +++ b/include/etl/deque.h @@ -1828,7 +1828,7 @@ namespace etl //************************************************************************* /// Fix the internal pointers after a low level memory copy. //************************************************************************* - void repair(pointer p_buffer_) + void repair_buffer(pointer p_buffer_) { p_buffer = p_buffer_; @@ -2095,13 +2095,16 @@ namespace etl //************************************************************************* /// Fix the internal pointers after a low level memory copy. //************************************************************************* +#ifdef ETL_IDEQUE_REPAIR_ENABLE + virtual +#endif void repair() { #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED ETL_ASSERT(std::is_trivially_copyable::value, ETL_ERROR(etl::deque_incompatible_type)); #endif - etl::ideque::repair(reinterpret_cast(&buffer[0])); + etl::ideque::repair_buffer(reinterpret_cast(&buffer[0])); } private: diff --git a/include/etl/memory.h b/include/etl/memory.h index de82cc95..fca5ff44 100644 --- a/include/etl/memory.h +++ b/include/etl/memory.h @@ -872,7 +872,7 @@ namespace etl std::swap(p, value.p); } - ETL_CONSTEXPR explicit operator bool() const + ETL_CONSTEXPR operator bool() const { return (p != nullptr); } @@ -1006,7 +1006,7 @@ namespace etl std::swap(p, v.p); } - ETL_CONSTEXPR explicit operator bool() const + ETL_CONSTEXPR operator bool() const { return (p != nullptr); } diff --git a/include/etl/private/pvoidvector.h b/include/etl/private/pvoidvector.h index 07692a61..f3ec0716 100644 --- a/include/etl/private/pvoidvector.h +++ b/include/etl/private/pvoidvector.h @@ -184,7 +184,7 @@ namespace etl void initialise(); - void repair(void** p_buffer_); + void repair_buffer(void** p_buffer_); void** p_buffer; void** p_end; diff --git a/include/etl/stl/alternate/functional.h b/include/etl/stl/alternate/functional.h index 01d9c0a7..58adcdbf 100644 --- a/include/etl/stl/alternate/functional.h +++ b/include/etl/stl/alternate/functional.h @@ -141,4 +141,4 @@ } } -#endif \ No newline at end of file +#endif diff --git a/include/etl/stl/alternate/iterator.h b/include/etl/stl/alternate/iterator.h index 13b128ce..59c8c715 100644 --- a/include/etl/stl/alternate/iterator.h +++ b/include/etl/stl/alternate/iterator.h @@ -267,69 +267,69 @@ namespace std return current; } - ETL_CONSTEXPR reference operator *() const + reference operator *() const { TIterator temp = current; --temp; return *temp; } - ETL_CONSTEXPR pointer operator ->() const + pointer operator ->() const { TIterator temp = current; --temp; return &(*temp); } - ETL_CONSTEXPR reverse_iterator& operator ++() + reverse_iterator& operator ++() { --current; return *this; } - ETL_CONSTEXPR reverse_iterator operator ++(int) + reverse_iterator operator ++(int) { reverse_iterator temp = *this; --current; return temp; } - ETL_CONSTEXPR reverse_iterator& operator --() + reverse_iterator& operator --() { ++current; return *this; } - ETL_CONSTEXPR reverse_iterator operator --(int) + reverse_iterator operator --(int) { reverse_iterator temp = *this; ++current; return temp; } - ETL_CONSTEXPR reverse_iterator operator +(difference_type n) const + reverse_iterator operator +(difference_type n) const { return reverse_iterator(current - n); } - ETL_CONSTEXPR reverse_iterator& operator +=(difference_type n) + reverse_iterator& operator +=(difference_type n) { current -= n; return *this; } - ETL_CONSTEXPR reverse_iterator operator -(difference_type n) const + reverse_iterator operator -(difference_type n) const { return reverse_iterator(current + n); } - ETL_CONSTEXPR reverse_iterator& operator -=(difference_type n) + reverse_iterator& operator -=(difference_type n) { current += n; return *this; } - ETL_CONSTEXPR reference operator [](difference_type n) const + reference operator [](difference_type n) const { return *(*this + n); } @@ -340,43 +340,43 @@ namespace std }; template - inline ETL_CONSTEXPR bool operator <(const reverse_iterator& lhs, const reverse_iterator& rhs) + inline bool operator <(const reverse_iterator& lhs, const reverse_iterator& rhs) { return rhs.base() < lhs.base(); } template - inline ETL_CONSTEXPR bool operator !=(const reverse_iterator& lhs, const reverse_iterator& rhs) + inline bool operator !=(const reverse_iterator& lhs, const reverse_iterator& rhs) { return !(lhs == rhs); } template - inline ETL_CONSTEXPR bool operator >(const reverse_iterator& lhs, const reverse_iterator& rhs) + inline bool operator >(const reverse_iterator& lhs, const reverse_iterator& rhs) { return rhs < lhs; } template - inline ETL_CONSTEXPR bool operator <=(const reverse_iterator& lhs, const reverse_iterator& rhs) + inline bool operator <=(const reverse_iterator& lhs, const reverse_iterator& rhs) { return !(rhs < lhs); } template - inline ETL_CONSTEXPR bool operator >=(const reverse_iterator& lhs, const reverse_iterator& rhs) + inline bool operator >=(const reverse_iterator& lhs, const reverse_iterator& rhs) { return !(lhs < rhs); } template - inline ETL_CONSTEXPR typename reverse_iterator::difference_type operator -(const reverse_iterator& lhs, const reverse_iterator& rhs) + inline typename reverse_iterator::difference_type operator -(const reverse_iterator& lhs, const reverse_iterator& rhs) { return rhs.base() - lhs.base(); } template - inline ETL_CONSTEXPR reverse_iterator operator +(TDifference n, const reverse_iterator& itr) + inline reverse_iterator operator +(TDifference n, const reverse_iterator& itr) { return itr.operator +(n); } diff --git a/include/etl/u16string.h b/include/etl/u16string.h index 4dd9b990..d496f094 100644 --- a/include/etl/u16string.h +++ b/include/etl/u16string.h @@ -193,9 +193,12 @@ namespace etl //************************************************************************* /// Fix the internal pointers after a low level memory copy. //************************************************************************* +#ifdef ETL_ISTRING_REPAIR_ENABLE + virtual +#endif void repair() { - etl::iu16string::repair(buffer); + etl::iu16string::repair_buffer(buffer); } private: diff --git a/include/etl/u32string.h b/include/etl/u32string.h index 3edc3465..bc076373 100644 --- a/include/etl/u32string.h +++ b/include/etl/u32string.h @@ -193,9 +193,12 @@ namespace etl //************************************************************************* /// Fix the internal pointers after a low level memory copy. //************************************************************************* +#ifdef ETL_ISTRING_REPAIR_ENABLE + virtual +#endif void repair() { - etl::iu32string::repair(buffer); + etl::iu32string::repair_buffer(buffer); } private: diff --git a/include/etl/vector.h b/include/etl/vector.h index 2d5f2fb2..decc9577 100644 --- a/include/etl/vector.h +++ b/include/etl/vector.h @@ -868,7 +868,7 @@ namespace etl //************************************************************************* /// Fix the internal pointers after a low level memory copy. //************************************************************************* - void repair(T* p_buffer_) + void repair_buffer(T* p_buffer_) { uintptr_t length = p_end - p_buffer; p_buffer = p_buffer_; @@ -1112,13 +1112,16 @@ namespace etl //************************************************************************* /// Fix the internal pointers after a low level memory copy. //************************************************************************* +#ifdef ETL_IVECTOR_REPAIR_ENABLE + virtual +#endif void repair() { #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED ETL_ASSERT(std::is_trivially_copyable::value, ETL_ERROR(etl::vector_incompatible_type)); #endif - etl::ivector::repair(buffer); + etl::ivector::repair_buffer(buffer); } private: @@ -1222,7 +1225,7 @@ namespace etl //************************************************************************* void repair() { - etl::ivector::repair(buffer); + etl::ivector::repair_buffer(buffer); } private: diff --git a/include/etl/wstring.h b/include/etl/wstring.h index 1ab83a02..206f7253 100644 --- a/include/etl/wstring.h +++ b/include/etl/wstring.h @@ -194,9 +194,12 @@ namespace etl //************************************************************************* /// Fix the internal pointers after a low level memory copy. //************************************************************************* +#ifdef ETL_ISTRING_REPAIR_ENABLE + virtual +#endif void repair() { - etl::iwstring::repair(buffer); + etl::iwstring::repair_buffer(buffer); } private: diff --git a/src/private/pvoidvector.cpp b/src/private/pvoidvector.cpp index 814abbd4..985b72ee 100644 --- a/src/private/pvoidvector.cpp +++ b/src/private/pvoidvector.cpp @@ -479,7 +479,7 @@ void etl::pvoidvector::initialise() //************************************************************************* /// Fix the internal pointers after a low level memory copy. //************************************************************************* -void etl::pvoidvector::repair(void** p_buffer_) +void etl::pvoidvector::repair_buffer(void** p_buffer_) { uintptr_t length = p_end - p_buffer; diff --git a/test/vs2017/etl.vcxproj b/test/vs2017/etl.vcxproj index 5ae6cd62..7c97660e 100644 --- a/test/vs2017/etl.vcxproj +++ b/test/vs2017/etl.vcxproj @@ -360,6 +360,7 @@ + diff --git a/test/vs2017/etl.vcxproj.filters b/test/vs2017/etl.vcxproj.filters index 26a9da1d..b4225aba 100644 --- a/test/vs2017/etl.vcxproj.filters +++ b/test/vs2017/etl.vcxproj.filters @@ -690,6 +690,9 @@ Source Files + + ETL\Utilities\Atomic +