diff --git a/source/utils/CarlaBackendUtils.hpp b/source/utils/CarlaBackendUtils.hpp index cb4655f2e..a14bf491e 100644 --- a/source/utils/CarlaBackendUtils.hpp +++ b/source/utils/CarlaBackendUtils.hpp @@ -441,9 +441,13 @@ PluginType getPluginTypeFromString(const char* const ctype) noexcept carla_debug("CarlaBackend::getPluginTypeFromString(\"%s\")", ctype); CarlaString stype(ctype); + + if (stype.isEmpty()) + return PLUGIN_NONE; + stype.toLower(); - if (stype.isEmpty() || stype == "none") + if (stype == "none") return PLUGIN_NONE; if (stype == "internal") return PLUGIN_INTERNAL; diff --git a/source/utils/CarlaLibCounter.hpp b/source/utils/CarlaLibCounter.hpp index 01d8c7fa7..7bdd21923 100644 --- a/source/utils/CarlaLibCounter.hpp +++ b/source/utils/CarlaLibCounter.hpp @@ -29,7 +29,7 @@ class LibCounter public: LibCounter() noexcept {} - ~LibCounter() + ~LibCounter() noexcept { // might have some leftovers for (LinkedList::Itenerator it = fLibs.begin(); it.valid(); it.next()) diff --git a/source/utils/CarlaLibUtils.hpp b/source/utils/CarlaLibUtils.hpp index d38ffd69f..26b9b1447 100644 --- a/source/utils/CarlaLibUtils.hpp +++ b/source/utils/CarlaLibUtils.hpp @@ -38,9 +38,9 @@ void* lib_open(const char* const filename) noexcept try { #ifdef CARLA_OS_WIN - return (void*)LoadLibraryA(filename); + return (void*)::LoadLibraryA(filename); #else - return dlopen(filename, RTLD_NOW|RTLD_LOCAL); + return ::dlopen(filename, RTLD_NOW|RTLD_LOCAL); #endif } CARLA_SAFE_EXCEPTION_RETURN("lib_open", nullptr); } @@ -56,9 +56,9 @@ bool lib_close(void* const lib) noexcept try { #ifdef CARLA_OS_WIN - return FreeLibrary((HMODULE)lib); + return ::FreeLibrary((HMODULE)lib); #else - return (dlclose(lib) == 0); + return (::dlclose(lib) == 0); #endif } CARLA_SAFE_EXCEPTION_RETURN("lib_close", false); } @@ -74,9 +74,9 @@ void* lib_symbol(void* const lib, const char* const symbol) noexcept CARLA_SAFE_ASSERT_RETURN(symbol != nullptr && symbol[0] != '\0', nullptr); #ifdef CARLA_OS_WIN - return (void*)GetProcAddress((HMODULE)lib, symbol); + return (void*)::GetProcAddress((HMODULE)lib, symbol); #else - return dlsym(lib, symbol); + return ::dlsym(lib, symbol); #endif } @@ -95,16 +95,16 @@ const char* lib_error(const char* const filename) noexcept try { LPVOID winErrorString; - DWORD winErrorCode = GetLastError(); - FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, winErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&winErrorString, 0, nullptr); + DWORD winErrorCode = ::GetLastError(); + ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, winErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&winErrorString, 0, nullptr); std::snprintf(libError, 2048, "%s: error code %li: %s", filename, winErrorCode, (const char*)winErrorString); - LocalFree(winErrorString); + ::LocalFree(winErrorString); } CARLA_SAFE_EXCEPTION("lib_error"); return (libError[0] != '\0') ? libError : nullptr; #else - return dlerror(); + return ::dlerror(); #endif } diff --git a/source/utils/CarlaShmUtils.hpp b/source/utils/CarlaShmUtils.hpp index 1c01c31fb..55fdd39a2 100644 --- a/source/utils/CarlaShmUtils.hpp +++ b/source/utils/CarlaShmUtils.hpp @@ -29,9 +29,9 @@ typedef int shm_t; #endif #ifdef CARLA_OS_WIN -static shm_t gNullCarlaShm = { nullptr, nullptr }; +static const shm_t gNullCarlaShm = { nullptr, nullptr }; #else -static shm_t gNullCarlaShm = -1; +static const shm_t gNullCarlaShm = -1; #endif // ----------------------------------------------------------------------- @@ -77,7 +77,7 @@ shm_t carla_shm_attach(const char* const name) CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', gNullCarlaShm); shm_t ret; - ret.shm = CreateFileA(name, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); + ret.shm = ::CreateFileA(name, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); ret.map = nullptr; return ret; @@ -88,7 +88,7 @@ shm_t carla_shm_create(const char* const name) { CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', gNullCarlaShm); - return shm_open(name, O_RDWR|O_CREAT|O_EXCL, 0600); + return ::shm_open(name, O_RDWR|O_CREAT|O_EXCL, 0600); } static inline @@ -96,7 +96,7 @@ shm_t carla_shm_attach(const char* const name) { CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', gNullCarlaShm); - return shm_open(name, O_RDWR, 0); + return ::shm_open(name, O_RDWR, 0); } #endif @@ -108,10 +108,10 @@ void carla_shm_close(shm_t& shm) #ifdef CARLA_OS_WIN CARLA_SAFE_ASSERT(shm.map == nullptr); - CloseHandle(shm.shm); + ::CloseHandle(shm.shm); shm.shm = nullptr; #else - close(shm); + ::close(shm); shm = -1; #endif } @@ -125,15 +125,15 @@ void* carla_shm_map(shm_t& shm, const size_t size) #ifdef CARLA_OS_WIN CARLA_SAFE_ASSERT_RETURN(shm.map == nullptr, nullptr); - HANDLE map = CreateFileMapping(shm.shm, NULL, PAGE_READWRITE, size, size, NULL); + HANDLE map = ::CreateFileMapping(shm.shm, NULL, PAGE_READWRITE, size, size, NULL); CARLA_SAFE_ASSERT_RETURN(map != nullptr, nullptr); - HANDLE ptr = MapViewOfFile(map, FILE_MAP_COPY, 0, 0, size); + HANDLE ptr = ::MapViewOfFile(map, FILE_MAP_COPY, 0, 0, size); if (ptr == nullptr) { - CloseHandle(map); + ::CloseHandle(map); return nullptr; } @@ -141,10 +141,10 @@ void* carla_shm_map(shm_t& shm, const size_t size) return ptr; #else - if (ftruncate(shm, static_cast(size)) != 0) + if (::ftruncate(shm, static_cast(size)) != 0) return nullptr; - return mmap(nullptr, size, PROT_READ|PROT_WRITE, MAP_SHARED, shm, 0); + return ::mmap(nullptr, size, PROT_READ|PROT_WRITE, MAP_SHARED, shm, 0); #endif } @@ -158,15 +158,15 @@ void carla_shm_unmap(shm_t& shm, void* const ptr, const size_t size) #ifdef CARLA_OS_WIN CARLA_SAFE_ASSERT_RETURN(shm.map != nullptr,); - UnmapViewOfFile(ptr); - CloseHandle(shm.map); + ::UnmapViewOfFile(ptr); + ::CloseHandle(shm.map); shm.map = nullptr; return; // unused (void)size; #else - munmap(ptr, size); + ::munmap(ptr, size); return; // unused diff --git a/source/utils/LinkedList.hpp b/source/utils/LinkedList.hpp index 1f14e35a3..3b186bce7 100644 --- a/source/utils/LinkedList.hpp +++ b/source/utils/LinkedList.hpp @@ -46,7 +46,7 @@ typedef struct list_head k_list_head; // Abstract Linked List class // _allocate() and _deallocate are virtual calls provided by subclasses -// NOTE: data-type classes are allowed to throw on creation, but NOT on deletion! +// NOTE: data-type classes are not allowed to throw template class AbstractLinkedList @@ -57,10 +57,9 @@ protected: k_list_head siblings; }; - AbstractLinkedList(const bool needsCopyCtr) noexcept - : fDataSize(sizeof(Data)), - fCount(0), - fNeedsCopyCtr(needsCopyCtr) + AbstractLinkedList(const bool isClass) noexcept + : kIsClass(isClass), + kDataSize(sizeof(Data)) { _init(); } @@ -73,20 +72,19 @@ public: class Itenerator { public: - Itenerator(const k_list_head* queue) noexcept + Itenerator(const k_list_head& queue) noexcept : fData(nullptr), - fEntry(queue->next), + fEntry(queue.next), fEntry2(fEntry->next), - fQueue(queue) + kQueue(queue) { CARLA_SAFE_ASSERT(fEntry != nullptr); CARLA_SAFE_ASSERT(fEntry2 != nullptr); - CARLA_SAFE_ASSERT(fQueue != nullptr); } bool valid() const noexcept { - return (fEntry != fQueue); + return (fEntry != &kQueue); } void next() noexcept @@ -111,34 +109,34 @@ public: Data* fData; k_list_head* fEntry; k_list_head* fEntry2; - const k_list_head* const fQueue; + const k_list_head& kQueue; friend class AbstractLinkedList; }; Itenerator begin() const noexcept { - return Itenerator(&fQueue); + return Itenerator(fQueue); } void clear() noexcept { - if (fCount != 0) + if (fCount == 0) + return; + + k_list_head* entry; + k_list_head* entry2; + + for (entry = fQueue.next, entry2 = entry->next; entry != &fQueue; entry = entry2, entry2 = entry->next) { - k_list_head* entry; - k_list_head* entry2; - - list_for_each_safe(entry, entry2, &fQueue) - { - if (Data* data = list_entry(entry, Data, siblings)) - { - if (fNeedsCopyCtr) - data->~Data(); - _deallocate(data); - } - } + Data* const data = list_entry(entry, Data, siblings); + CARLA_SAFE_ASSERT_CONTINUE(data != nullptr); + + _delete(entry, data); } + CARLA_SAFE_ASSERT(fCount == 0); + _init(); } @@ -172,268 +170,207 @@ public: return _add(value, false, it.fEntry->prev); } - T& getAt(const size_t index) const noexcept + T& getAt(const size_t index, T& fallback) const noexcept { - if (fCount == 0 || index >= fCount) - return fRetValue; + CARLA_SAFE_ASSERT_RETURN(fCount > 0 && index < fCount, fallback); size_t i = 0; - Data* data = nullptr; k_list_head* entry; k_list_head* entry2; - list_for_each_safe(entry, entry2, &fQueue) + for (entry = fQueue.next, entry2 = entry->next; entry != &fQueue; entry = entry2, entry2 = entry->next) { if (index != i++) continue; - data = list_entry(entry, Data, siblings); + return _get(entry, fallback); + } - if (data != nullptr) - fRetValue = data->value; + return fallback; + } - break; - } + T& getFirst(T& fallback) const noexcept + { + CARLA_SAFE_ASSERT_RETURN(fCount > 0, fallback); + + return _get(fQueue.next, fallback); + } + + T& getLast(T& fallback) const noexcept + { + CARLA_SAFE_ASSERT_RETURN(fCount > 0, fallback); - return fRetValue; + return _get(fQueue.prev, fallback); } - T& getAt(const size_t index, const bool removeObj) noexcept + T getAt(const size_t index, T& fallback, const bool removeObj) noexcept { - if (fCount == 0 || index >= fCount) - return fRetValue; + CARLA_SAFE_ASSERT_RETURN(fCount > 0 && index < fCount, fallback); size_t i = 0; - Data* data = nullptr; k_list_head* entry; k_list_head* entry2; - list_for_each_safe(entry, entry2, &fQueue) + for (entry = fQueue.next, entry2 = entry->next; entry != &fQueue; entry = entry2, entry2 = entry->next) { if (index != i++) continue; - data = list_entry(entry, Data, siblings); - - if (data != nullptr) - fRetValue = data->value; - - if (removeObj) - { - --fCount; - list_del(entry); - - if (data != nullptr) - { - if (fNeedsCopyCtr) - data->~Data(); - _deallocate(data); - } - } - - break; + return _get(entry, fallback, removeObj); } - return fRetValue; + return fallback; } - T& getFirst(const bool removeObj = false) noexcept + T getFirst(T& fallback, const bool removeObj) noexcept { - return _getFirstOrLast(true, removeObj); + CARLA_SAFE_ASSERT_RETURN(fCount > 0, fallback); + + return _get(fQueue.next, fallback, removeObj); } - T& getLast(const bool removeObj = false) noexcept + T getLast(T& fallback, const bool removeObj) noexcept { - return _getFirstOrLast(false, removeObj); + CARLA_SAFE_ASSERT_RETURN(fCount > 0, fallback); + + return _get(fQueue.prev, fallback, removeObj); } void remove(Itenerator& it) noexcept { CARLA_SAFE_ASSERT_RETURN(it.fEntry != nullptr,); - - --fCount; - list_del(it.fEntry); - CARLA_SAFE_ASSERT_RETURN(it.fData != nullptr,); - if (fNeedsCopyCtr) - it.fData->~Data(); - _deallocate(it.fData); + _delete(it.fEntry, it.fData); } bool removeOne(const T& value) noexcept { - Data* data = nullptr; k_list_head* entry; k_list_head* entry2; - list_for_each_safe(entry, entry2, &fQueue) + for (entry = fQueue.next, entry2 = entry->next; entry != &fQueue; entry = entry2, entry2 = entry->next) { - data = list_entry(entry, Data, siblings); - + Data* const data = list_entry(entry, Data, siblings); CARLA_SAFE_ASSERT_CONTINUE(data != nullptr); - if (data->value == value) - { - --fCount; - list_del(entry); + if (data->value != value) + continue; + + _delete(entry, data); - if (fNeedsCopyCtr) - data->~Data(); - _deallocate(data); - break; - } + return true; } - return (data != nullptr); + return false; } void removeAll(const T& value) noexcept { - Data* data; k_list_head* entry; k_list_head* entry2; - list_for_each_safe(entry, entry2, &fQueue) + for (entry = fQueue.next, entry2 = entry->next; entry != &fQueue; entry = entry2, entry2 = entry->next) { - data = list_entry(entry, Data, siblings); - + Data* const data = list_entry(entry, Data, siblings); CARLA_SAFE_ASSERT_CONTINUE(data != nullptr); - if (data->value == value) - { - --fCount; - list_del(entry); + if (data->value != value) + continue; - if (fNeedsCopyCtr) - data->~Data(); - _deallocate(data); - } + _delete(entry, data); } } - void spliceAppend(AbstractLinkedList& list, const bool init = true) noexcept + void spliceAppend(AbstractLinkedList& list) noexcept { - if (init) - { - list_splice_tail_init(&fQueue, &list.fQueue); - list.fCount += fCount; - fCount = 0; - } - else - { - list_splice_tail(&fQueue, &list.fQueue); - list.fCount += fCount; - } + list_splice_tail_init(&fQueue, &list.fQueue); + list.fCount += fCount; + fCount = 0; } - void spliceInsert(AbstractLinkedList& list, const bool init = true) noexcept + void spliceInsert(AbstractLinkedList& list) noexcept { - if (init) - { - list_splice_init(&fQueue, &list.fQueue); - list.fCount += fCount; - fCount = 0; - } - else - { - list_splice(&fQueue, &list.fQueue); - list.fCount += fCount; - } + list_splice_init(&fQueue, &list.fQueue); + list.fCount += fCount; + fCount = 0; } protected: - const size_t fDataSize; + const bool kIsClass; + const size_t kDataSize; size_t fCount; k_list_head fQueue; - const bool fNeedsCopyCtr; - virtual Data* _allocate() noexcept = 0; virtual void _deallocate(Data* const dataPtr) noexcept = 0; - bool _createData(Data* const data, const T& value) + void _createData(Data* const data, const T& value) noexcept { - if (fNeedsCopyCtr) - { - try { - new(data)Data(); - } - catch(...) { - _deallocate(data); - return false; - } - - try { - data->value = value; - } - catch(...) { - data->~Data(); - _deallocate(data); - return false; - } - } + if (kIsClass) + new(data)Data(value); else - { - std::memcpy(&data->value, &value, this->fDataSize); - } + data->value = value; - return true; + ++fCount; } private: - mutable T fRetValue; - void _init() noexcept { fCount = 0; - INIT_LIST_HEAD(&fQueue); + fQueue.next = &fQueue; + fQueue.prev = &fQueue; } bool _add(const T& value, const bool inTail, k_list_head* const queue) noexcept { if (Data* const data = _allocate()) { - if (! _createData(data, value)) - return false; + _createData(data, value); if (inTail) list_add_tail(&data->siblings, queue); else list_add(&data->siblings, queue); - ++fCount; return true; } return false; } - T& _getFirstOrLast(const bool first, const bool removeObj) noexcept + void _delete(k_list_head* const entry, Data* const data) noexcept { - if (fCount == 0) - return fRetValue; + --fCount; + list_del(entry); - k_list_head* const entry = first ? fQueue.next : fQueue.prev; - Data* data = list_entry(entry, Data, siblings); + if (kIsClass) + data->~Data(); + _deallocate(data); + } - if (data != nullptr) - fRetValue = data->value; + T& _get(k_list_head* const entry, T& fallback) const noexcept + { + Data* const data = list_entry(entry, Data, siblings); + CARLA_SAFE_ASSERT_RETURN(data != nullptr, fallback); - if (removeObj) - { - --fCount; - list_del(entry); - - if (data != nullptr) - { - if (fNeedsCopyCtr) - data->~Data(); - _deallocate(data); - } - } + return data->value; + } + + T _get(k_list_head* const entry, T& fallback, const bool removeObj) noexcept + { + Data* const data = list_entry(entry, Data, siblings); + CARLA_SAFE_ASSERT_RETURN(data != nullptr, fallback); + + if (! removeObj) + return data->value; + + const T value(data->value); + + _delete(entry, data); - return fRetValue; + return value; } LINKED_LIST_DECLARATIONS(AbstractLinkedList) @@ -446,13 +383,13 @@ template class LinkedList : public AbstractLinkedList { public: - LinkedList(const bool needsCopyCtr = false) noexcept - : AbstractLinkedList(needsCopyCtr) {} + LinkedList(const bool isClass = false) noexcept + : AbstractLinkedList(isClass) {} protected: typename AbstractLinkedList::Data* _allocate() noexcept override { - return (typename AbstractLinkedList::Data*)std::malloc(this->fDataSize); + return (typename AbstractLinkedList::Data*)std::malloc(this->kDataSize); } void _deallocate(typename AbstractLinkedList::Data* const dataPtr) noexcept override diff --git a/source/utils/RtLinkedList.hpp b/source/utils/RtLinkedList.hpp index 50868906f..70c453755 100644 --- a/source/utils/RtLinkedList.hpp +++ b/source/utils/RtLinkedList.hpp @@ -39,7 +39,7 @@ public: public: Pool(const size_t minPreallocated, const size_t maxPreallocated) noexcept : fHandle(nullptr), - fDataSize(sizeof(typename AbstractLinkedList::Data)) + kDataSize(sizeof(typename AbstractLinkedList::Data)) { resize(minPreallocated, maxPreallocated); } @@ -76,30 +76,30 @@ public: fHandle = nullptr; } - rtsafe_memory_pool_create(&fHandle, nullptr, fDataSize, minPreallocated, maxPreallocated); + rtsafe_memory_pool_create(&fHandle, nullptr, kDataSize, minPreallocated, maxPreallocated); CARLA_SAFE_ASSERT(fHandle != nullptr); } bool operator==(const Pool& pool) const noexcept { - return (fHandle == pool.fHandle && fDataSize == pool.fDataSize); + return (fHandle == pool.fHandle && kDataSize == pool.kDataSize); } bool operator!=(const Pool& pool) const noexcept { - return (fHandle != pool.fHandle || fDataSize != pool.fDataSize); + return (fHandle != pool.fHandle || kDataSize != pool.kDataSize); } private: mutable RtMemPool_Handle fHandle; - const size_t fDataSize; + const size_t kDataSize; }; // ------------------------------------------------------------------- // Now the actual rt-linkedlist code - RtLinkedList(Pool& memPool, const bool needsCopyCtr = false) noexcept - : AbstractLinkedList(needsCopyCtr), + RtLinkedList(Pool& memPool, const bool isClass = false) noexcept + : AbstractLinkedList(isClass), fMemPool(memPool) {} bool append_sleepy(const T& value) noexcept @@ -119,18 +119,18 @@ public: fMemPool.resize(minPreallocated, maxPreallocated); } - void spliceAppend(RtLinkedList& list, const bool init = true) noexcept + void spliceAppend(RtLinkedList& list) noexcept { CARLA_SAFE_ASSERT_RETURN(fMemPool == list.fMemPool,); - AbstractLinkedList::spliceAppend(list, init); + AbstractLinkedList::spliceAppend(list); } - void spliceInsert(RtLinkedList& list, const bool init = true) noexcept + void spliceInsert(RtLinkedList& list) noexcept { CARLA_SAFE_ASSERT_RETURN(fMemPool == list.fMemPool,); - AbstractLinkedList::spliceInsert(list, init); + AbstractLinkedList::spliceInsert(list); } protected: @@ -158,15 +158,13 @@ private: { if (typename AbstractLinkedList::Data* const data = _allocate_sleepy()) { - if (! this->_createData(data, value)) - return false; + this->_createData(data, value); if (inTail) list_add_tail(&data->siblings, &this->fQueue); else list_add(&data->siblings, &this->fQueue); - ++(this->fCount); return true; }