Revert unintented branch merge

source/backend/CarlaEngine.hpp

@@ -241,7 +241,6 @@ struct EngineOptions {
 #ifndef DOXYGEN
     EngineOptions() noexcept;
     ~EngineOptions() noexcept;
-    CARLA_DECLARE_NON_COPY_STRUCT(EngineOptions)
 #endif
 };
 

source/backend/CarlaHost.h

@@ -137,7 +137,6 @@ typedef struct _CarlaPluginInfo {
      */
     _CarlaPluginInfo() noexcept;
     ~_CarlaPluginInfo() noexcept;
-    CARLA_DECLARE_NON_COPY_STRUCT(_CarlaPluginInfo)
 #endif
 
 } CarlaPluginInfo;
@@ -213,7 +212,6 @@ typedef struct _CarlaNativePluginInfo {
      * C++ constructor.
      */
     _CarlaNativePluginInfo() noexcept;
-    CARLA_DECLARE_NON_COPY_STRUCT(_CarlaNativePluginInfo)
 #endif
 
 } CarlaNativePluginInfo;
@@ -269,7 +267,6 @@ typedef struct _CarlaParameterInfo {
      */
     _CarlaParameterInfo() noexcept;
     ~_CarlaParameterInfo() noexcept;
-    CARLA_DECLARE_NON_COPY_STRUCT(_CarlaParameterInfo)
 #endif
 
 } CarlaParameterInfo;
@@ -295,7 +292,6 @@ typedef struct _CarlaScalePointInfo {
      */
     _CarlaScalePointInfo() noexcept;
     ~_CarlaScalePointInfo() noexcept;
-    CARLA_DECLARE_NON_COPY_STRUCT(_CarlaScalePointInfo)
 #endif
 
 } CarlaScalePointInfo;

source/backend/CarlaStandalone.cpp

@@ -57,10 +57,8 @@ struct CarlaBackendStandalone {
         : engine(nullptr),
           engineCallback(nullptr),
           engineCallbackPtr(nullptr),
-          engineOptions(),
           fileCallback(nullptr),
-          fileCallbackPtr(nullptr),
-          lastError()
+          fileCallbackPtr(nullptr)
     {
 #ifdef BUILD_BRIDGE
         engineOptions.processMode         = CB::ENGINE_PROCESS_MODE_BRIDGE;
@@ -104,8 +102,6 @@ class CarlaNSM
 public:
     CarlaNSM() noexcept
         : fOscServer(nullptr),
-          fClientId(),
-          fProjectPath(),
           fHasBroadcast(false),
           fHasShowHideUI(false) {}
 

source/backend/engine/CarlaEngineData.cpp

@@ -245,8 +245,7 @@ EngineTimeInfo::EngineTimeInfo() noexcept
     : playing(false),
       frame(0),
       usecs(0),
-      valid(0x0),
-      bbt() {}
+      valid(0x0) {}
 
 void EngineTimeInfo::clear() noexcept
 {

source/backend/engine/CarlaEngineGraph.cpp

@@ -123,28 +123,10 @@ uint RackGraph::MIDI::getPortId(const bool isInput, const char portName[], bool*
 // -----------------------------------------------------------------------
 // RackGraph
 
-RackGraph::Audio::Audio() noexcept
-    : mutex(),
-      connectedIn1(),
-      connectedIn2(),
-      connectedOut1(),
-      connectedOut2(),
-      inBuf{0, 0},
-      inBufTmp{0, 0},
-      outBuf{0, 0} {}
-
-RackGraph::MIDI::MIDI() noexcept
-    : ins(),
-      outs() {}
-
 RackGraph::RackGraph(const uint32_t bufferSize, const uint32_t ins, const uint32_t outs) noexcept
-    : connections(),
-      inputs(ins),
+    : inputs(ins),
       outputs(outs),
-      isOffline(false),
-      retCon(),
-      audio(),
-      midi()
+      isOffline(false)
 {
     audio.inBuf[0]    = audio.inBuf[1]    = nullptr;
     audio.inBufTmp[0] = audio.inBufTmp[1] = nullptr;

source/backend/engine/CarlaEngineGraph.hpp

@@ -76,10 +76,6 @@ struct RackGraph {
         float* inBuf[2];
         float* inBufTmp[2];
         float* outBuf[2];
-        // c++ compat stuff
-        Audio() noexcept;
-        CARLA_PREVENT_HEAP_ALLOCATION
-        CARLA_DECLARE_NON_COPY_CLASS(Audio)
     } audio;
 
     struct MIDI {
@@ -87,10 +83,6 @@ struct RackGraph {
         LinkedList<PortNameToId> outs;
         const char* getName(const bool isInput, const uint portId) const noexcept;
         uint getPortId(const bool isInput, const char portName[], bool* const ok = nullptr) const noexcept;
-        MIDI() noexcept;
-        // c++ compat stuff
-        CARLA_PREVENT_HEAP_ALLOCATION
-        CARLA_DECLARE_NON_COPY_CLASS(MIDI)
     } midi;
 
     RackGraph(const uint32_t bufferSize, const uint32_t inputs, const uint32_t outputs) noexcept;

source/backend/engine/CarlaEngineInternal.cpp

@@ -67,8 +67,7 @@ EngineInternalTime::EngineInternalTime() noexcept
 EngineNextAction::EngineNextAction() noexcept
     : opcode(kEnginePostActionNull),
       pluginId(0),
-      value(0),
-      waitEvent() {}
+      value(0) {}
 
 EngineNextAction::~EngineNextAction() noexcept
 {
@@ -98,25 +97,15 @@ CarlaEngine::ProtectedData::ProtectedData(CarlaEngine* const engine) noexcept
       isIdling(0),
       curPluginCount(0),
       maxPluginNumber(0),
-      nextPluginId(0),
-      lastError(),
-      name(),
-      options(),
-      timeInfo(),
-#ifndef BUILD_BRIDGE
-      plugins(nullptr),
-#endif
-      events(),
 #ifndef BUILD_BRIDGE
-      graph(),
-#endif
-      time(),
-      nextAction()
+      nextPluginId(0),
+      plugins(nullptr) {}
+#else
+      nextPluginId(0)
 {
-#ifdef BUILD_BRIDGE
     carla_zeroStruct(plugins, 1);
-#endif
 }
+#endif
 
 CarlaEngine::ProtectedData::~ProtectedData() noexcept
 {

source/backend/engine/CarlaEngineInternal.hpp

@@ -26,9 +26,6 @@
 using juce::Atomic;
 using juce::WaitableEvent;
 
-// FIXME only use CARLA_PREVENT_HEAP_ALLOCATION for structs
-//       maybe separate macro
-
 CARLA_BACKEND_START_NAMESPACE
 
 // -----------------------------------------------------------------------
@@ -90,7 +87,6 @@ private:
         PatchbayGraph* fPatchbay;
     };
 
-    CARLA_PREVENT_HEAP_ALLOCATION
     CARLA_DECLARE_NON_COPY_STRUCT(EngineInternalGraph)
 };
 #endif

source/backend/engine/CarlaEngineOsc.cpp

@@ -41,15 +41,8 @@ extern int CarlaPluginSetOscBridgeInfo(CarlaPlugin* const plugin, const PluginBr
 
 CarlaEngineOsc::CarlaEngineOsc(CarlaEngine* const engine) noexcept
     : fEngine(engine),
-#ifndef BUILD_BRIDGE
-      fControlData(),
-#endif
-      fName(),
-      fServerPathTCP(),
-      fServerPathUDP(),
       fServerTCP(nullptr),
-      fServerUDP(nullptr),
-      leakDetector()
+      fServerUDP(nullptr)
 {
     CARLA_SAFE_ASSERT(engine != nullptr);
     carla_debug("CarlaEngineOsc::CarlaEngineOsc(%p)", engine);

source/backend/engine/CarlaEngineOsc.hpp

@@ -93,16 +93,17 @@ public:
 private:
     CarlaEngine* const fEngine;
 
-#ifndef BUILD_BRIDGE
-    CarlaOscData fControlData; // for carla-control
-#endif
-
     CarlaString fName;
+
     CarlaString fServerPathTCP;
     CarlaString fServerPathUDP;
     lo_server   fServerTCP;
     lo_server   fServerUDP;
 
+#ifndef BUILD_BRIDGE
+    CarlaOscData fControlData; // for carla-control
+#endif
+
     // -------------------------------------------------------------------
 
     int handleMessage(const bool isTCP, const char* const path, const int argc, const lo_arg* const* const argv, const char* const types, const lo_message msg);

source/backend/engine/CarlaEngineThread.cpp

@@ -25,8 +25,7 @@ CARLA_BACKEND_START_NAMESPACE
 
 CarlaEngineThread::CarlaEngineThread(CarlaEngine* const engine) noexcept
     : CarlaThread("CarlaEngineThread"),
-      kEngine(engine),
-      leakDetector()
+      kEngine(engine)
 {
     CARLA_SAFE_ASSERT(engine != nullptr);
     carla_debug("CarlaEngineThread::CarlaEngineThread(%p)", engine);

source/includes/CarlaDefines.h

@@ -209,17 +209,6 @@ private:                               \
     static void operator delete(void*);
 #endif
 
-/* Define CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION */
-#ifdef CARLA_PROPER_CPP11_SUPPORT
-# define CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION  \
-private:                                        \
-    static void* operator new(size_t) = delete;
-#else
-# define CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION  \
-private:                                        \
-    static void* operator new(size_t);
-#endif
-
 /* Define EXTERN_C */
 #ifdef __cplusplus
 # define EXTERN_C extern "C"

source/modules/lilv/lilv-0.18.0/lilv/lilvmm.hpp

@@ -17,8 +17,6 @@
 #ifndef LILV_LILVMM_HPP
 #define LILV_LILVMM_HPP
 
-#include "CarlaDefines.h"
-
 #include "lilv/lilv.h"
 
 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
@@ -99,12 +97,6 @@ struct Node {
 	LILV_WRAP0_CONST(bool,        node, is_bool);
 	LILV_WRAP0_CONST(bool,        node, as_bool);
 
-	Node& operator=(const Node& copy) {
-		lilv_node_free(me);
-		me = lilv_node_duplicate(copy.me);
-		return *this;
-	}
-
 	LilvNode* me;
 };
 
@@ -116,8 +108,6 @@ struct ScalePoint {
 	LILV_WRAP0(const LilvNode*, scale_point, get_value);
 
 	const LilvScalePoint* me;
-
-	//CARLA_DECLARE_NON_COPY_STRUCT(ScalePoint)
 };
 
 struct PluginClass {
@@ -130,8 +120,6 @@ struct PluginClass {
 	LILV_WRAP0(LilvPluginClasses*, plugin_class, get_children);
 
 	const LilvPluginClass* me;
-
-	//CARLA_DECLARE_NON_COPY_STRUCT(PluginClass)
 };
 
 #define LILV_WRAP_COLL(CT, ET, prefix) \
@@ -177,8 +165,6 @@ struct UI {
 	LILV_WRAP0(Nodes, ui, get_extension_data);
 
 	const LilvUI* me;
-
-	//CARLA_DECLARE_NON_COPY_STRUCT(UI)
 };
 
 struct UIs {
@@ -212,8 +198,6 @@ struct Port {
 
 	const LilvPlugin* parent;
 	const LilvPort*   me;
-
-	//CARLA_DECLARE_NON_COPY_STRUCT(Port)
 };
 
 struct Plugin {
@@ -270,8 +254,6 @@ struct Plugin {
 	}
 
 	const LilvPlugin* me;
-
-	//CARLA_DECLARE_NON_COPY_STRUCT(Plugin)
 };
 
 struct Plugins {
@@ -283,13 +265,15 @@ struct Instance {
 	inline Instance(LilvInstance* instance) : me(instance) {}
 
 	LILV_DEPRECATED
-	inline Instance(Plugin plugin, double sample_rate)
-		: me(lilv_plugin_instantiate(plugin, sample_rate, nullptr)) {}
+	inline Instance(Plugin plugin, double sample_rate) {
+		me = lilv_plugin_instantiate(plugin, sample_rate, nullptr);
+	}
 
 	LILV_DEPRECATED inline Instance(Plugin              plugin,
 	                                double              sample_rate,
-	                                LV2_Feature* const* features)
-		me(lilv_plugin_instantiate(plugin, sample_rate, features)) {}
+	                                LV2_Feature* const* features) {
+		me = lilv_plugin_instantiate(plugin, sample_rate, features);
+	}
 
 	static inline Instance* create(Plugin              plugin,
 	                               double              sample_rate,
@@ -323,13 +307,11 @@ struct Instance {
 	}
 
 	LilvInstance* me;
-
-	//CARLA_DECLARE_NON_COPY_STRUCT(Instance)
 };
 
 struct World {
-	inline          World() : me(lilv_world_new()) {}
-	inline virtual ~World() { lilv_world_free(me); }
+	inline World() : me(lilv_world_new()) {}
+	inline ~World() { lilv_world_free(me); }
 
 	inline LilvNode* new_uri(const char* uri) const {
 		return lilv_new_uri(me, uri);
@@ -361,8 +343,6 @@ struct World {
 	LILV_WRAP1(int, world, load_resource, const LilvNode*, resource);
 
 	LilvWorld* me;
-
-	CARLA_DECLARE_NON_COPY_STRUCT(World)
 };
 
 } /* namespace Lilv */

source/tests/CarlaUtils1.cpp

@@ -121,8 +121,6 @@ static void test_CarlaUtils()
                     str4 = nullptr;
                 }
             }
-
-            CARLA_DECLARE_NON_COPY_STRUCT(TestStruct)
         };
 
         TestStruct a, b, c;

source/tests/CarlaUtils3.cpp

@@ -30,7 +30,7 @@
 class LeakTestClass
 {
 public:
-    LeakTestClass() noexcept
+    LeakTestClass()noexcept
         : i(0) {}
 
 private:

source/utils/CarlaBinaryUtils.hpp

@@ -56,9 +56,6 @@ public:
 
 private:
     const magic_t fMagic;
-
-    CARLA_PREVENT_HEAP_ALLOCATION
-    CARLA_DECLARE_NON_COPY_STRUCT(CarlaMagic)
 };
 
 static const CarlaMagic& getCarlaMagicInstance()

source/utils/CarlaJuceUtils.hpp

@@ -45,21 +45,12 @@
 #define CARLA_LEAK_DETECTOR(ClassName)                                            \
     friend class ::LeakedObjectDetector<ClassName>;                               \
     static const char* getLeakedObjectClassName() noexcept { return #ClassName; } \
-    ::LeakedObjectDetector<ClassName> leakDetector;
-
-#define CARLA_LEAK_DETECTOR_NAME(ClassName, leakDetectorName)                     \
-    friend class ::LeakedObjectDetector<ClassName>;                               \
-    static const char* getLeakedObjectClassName() noexcept { return #ClassName; } \
-    ::LeakedObjectDetector<ClassName> leakDetectorName;
+    ::LeakedObjectDetector<ClassName> CARLA_JOIN_MACRO(leakDetector, __LINE__);
 
 #define CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(ClassName) \
     CARLA_DECLARE_NON_COPY_CLASS(ClassName)                      \
     CARLA_LEAK_DETECTOR(ClassName)
 
-#define CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR_NAME(ClassName, leakDetectorName) \
-    CARLA_DECLARE_NON_COPY_CLASS(ClassName)                                             \
-    CARLA_LEAK_DETECTOR_NAME(ClassName, leakDetectorName)
-
 //==============================================================================
 /**
     Embedding an instance of this class inside another class can be used as a low-overhead
@@ -105,7 +96,9 @@ private:
     {
     public:
         LeakCounter() noexcept
-            : numObjects(0) {}
+        {
+            numObjects = 0;
+        }
 
         ~LeakCounter() noexcept
         {

source/utils/CarlaLibCounter.hpp

@@ -27,9 +27,7 @@
 class LibCounter
 {
 public:
-    LibCounter() noexcept
-        : fMutex(),
-          fLibs() {}
+    LibCounter() noexcept {}
 
     ~LibCounter() noexcept
     {

source/utils/CarlaLv2Utils.hpp

@@ -429,7 +429,7 @@ public:
         return cState;
     }
 
-    CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
+    CARLA_PREVENT_HEAP_ALLOCATION
 };
 
 // -----------------------------------------------------------------------

source/utils/CarlaMutex.hpp

@@ -32,8 +32,7 @@ public:
      * Constructor.
      */
     CarlaMutex() noexcept
-        : fMutex(),
-          fTryLockWasCalled(false)
+        : fTryLockWasCalled(false)
     {
         pthread_mutex_init(&fMutex, nullptr);
     }
@@ -104,11 +103,6 @@ public:
      * Constructor.
      */
     CarlaRecursiveMutex() noexcept
-#ifdef CARLA_OS_WIN
-        : fSection()
-#else
-        : fMutex()
-#endif
     {
 #ifdef CARLA_OS_WIN
         InitializeCriticalSection(&fSection);

source/utils/CarlaPatchbayUtils.hpp

@@ -66,8 +66,7 @@ struct PatchbayGroupList {
     LinkedList<GroupNameToId> list;
 
     PatchbayGroupList() noexcept
-        : lastId(0),
-          list() {}
+        : lastId(0) {}
 
     void clear() noexcept
     {
@@ -160,8 +159,7 @@ struct PatchbayPortList {
     LinkedList<PortNameToId> list;
 
     PatchbayPortList() noexcept
-        : lastId(0),
-          list() {}
+        : lastId(0) {}
 
     void clear() noexcept
     {
@@ -249,8 +247,7 @@ struct PatchbayConnectionList {
     LinkedList<ConnectionToId> list;
 
     PatchbayConnectionList() noexcept
-        : lastId(0),
-          list() {}
+        : lastId(0) {}
 
     void clear() noexcept
     {

source/utils/CarlaPluginUI.cpp

@@ -41,10 +41,10 @@ static int temporaryErrorHandler(Display*, XErrorEvent*)
     return 0;
 }
 
-class X11PluginUI : public CarlaPluginUI
+class X11PluginUi : public CarlaPluginUI
 {
 public:
-    X11PluginUI(CloseCallback* const cb, const uintptr_t parentId) noexcept
+    X11PluginUi(CloseCallback* const cb, const uintptr_t parentId) noexcept
         : CarlaPluginUI(cb),
           fDisplay(nullptr),
           fWindow(0),
@@ -88,7 +88,7 @@ public:
             setTransientWinId(parentId);
     }
 
-    ~X11PluginUI() override
+    ~X11PluginUi() override
     {
         CARLA_SAFE_ASSERT(! fIsVisible);
 
@@ -293,8 +293,6 @@ private:
     bool     fIsVisible;
     bool     fFirstShow;
     EventProcPtr fEventProc;
-
-    CARLA_DECLARE_NON_COPY_CLASS(X11PluginUI)
 };
 #endif
 
@@ -316,9 +314,6 @@ bool CarlaPluginUI::tryTransientWinIdMatch(const uintptr_t pid, const char* cons
         Display* display;
         ScopedDisplay() : display(XOpenDisplay(nullptr)) {}
         ~ScopedDisplay() { if (display!=nullptr) XCloseDisplay(display); }
-        // c++ compat stuff
-        CARLA_PREVENT_HEAP_ALLOCATION
-        CARLA_DECLARE_NON_COPY_CLASS(ScopedDisplay)
     };
     struct ScopedFreeData {
         union {
@@ -328,9 +323,6 @@ bool CarlaPluginUI::tryTransientWinIdMatch(const uintptr_t pid, const char* cons
         ScopedFreeData(char* d) : data(d) {}
         ScopedFreeData(uchar* d) : udata(d) {}
         ~ScopedFreeData() { XFree(data); }
-        // c++ compat stuff
-        CARLA_PREVENT_HEAP_ALLOCATION
-        CARLA_DECLARE_NON_COPY_CLASS(ScopedFreeData)
     };
 
     const ScopedDisplay sd;
@@ -510,7 +502,7 @@ CarlaPluginUI* CarlaPluginUI::newWindows(CloseCallback*, uintptr_t)
 #ifdef HAVE_X11
 CarlaPluginUI* CarlaPluginUI::newX11(CloseCallback* cb, uintptr_t parentId)
 {
-    return new X11PluginUI(cb, parentId);
+    return new X11PluginUi(cb, parentId);
 }
 #endif
 

source/utils/CarlaPluginUI.hpp

@@ -60,8 +60,6 @@ protected:
     bool fIsIdling;
     CloseCallback* fCallback;
     CarlaPluginUI(CloseCallback* const cb) noexcept : fIsIdling(false), fCallback(cb) {}
-
-    CARLA_DECLARE_NON_COPY_CLASS(CarlaPluginUI)
 };
 
 // -----------------------------------------------------

source/utils/CarlaRingBuffer.hpp

@@ -75,9 +75,6 @@ struct BigStackBuffer {
     uint8_t  buf[size];
 };
 
-#define HeapBuffer_INIT  {0, 0, 0, 0, false, nullptr}
-#define StackBuffer_INIT {0, 0, 0, false, {0}}
-
 // -----------------------------------------------------------------------
 // CarlaRingBuffer templated class
 
@@ -88,9 +85,12 @@ public:
     CarlaRingBuffer() noexcept
         : fBuffer(nullptr) {}
 
-    virtual ~CarlaRingBuffer() noexcept {}
-
-    // -------------------------------------------------------------------
+    CarlaRingBuffer(BufferStruct* const ringBuf) noexcept
+        : fBuffer(ringBuf)
+    {
+        if (ringBuf != nullptr)
+            clear();
+    }
 
     void clear() noexcept
     {
@@ -376,7 +376,7 @@ protected:
 private:
     BufferStruct* fBuffer;
 
-    CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
+    CARLA_PREVENT_HEAP_ALLOCATION
     CARLA_DECLARE_NON_COPY_CLASS(CarlaRingBuffer)
 };
 
@@ -387,9 +387,12 @@ class CarlaHeapRingBuffer : public CarlaRingBuffer<HeapBuffer>
 {
 public:
     CarlaHeapRingBuffer() noexcept
-        : fHeapBuffer(HeapBuffer_INIT) {}
+        : CarlaRingBuffer<HeapBuffer>()
+    {
+        carla_zeroStruct(fHeapBuffer);
+    }
 
-    ~CarlaHeapRingBuffer() noexcept override
+    ~CarlaHeapRingBuffer() noexcept
     {
         if (fHeapBuffer.buf == nullptr)
             return;
@@ -427,7 +430,7 @@ public:
 private:
     HeapBuffer fHeapBuffer;
 
-    CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
+    CARLA_PREVENT_HEAP_ALLOCATION
     CARLA_DECLARE_NON_COPY_CLASS(CarlaHeapRingBuffer)
 };
 
@@ -438,15 +441,12 @@ class CarlaStackRingBuffer : public CarlaRingBuffer<StackBuffer>
 {
 public:
     CarlaStackRingBuffer() noexcept
-        : fStackBuffer(StackBuffer_INIT)
-    {
-        setRingBuffer(&fStackBuffer, true); // FIXME
-    }
+        : CarlaRingBuffer<StackBuffer>(&fStackBuffer) {}
 
 private:
     StackBuffer fStackBuffer;
 
-    CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
+    CARLA_PREVENT_HEAP_ALLOCATION
     CARLA_DECLARE_NON_COPY_CLASS(CarlaStackRingBuffer)
 };
 

source/utils/CarlaStateUtils.cpp

@@ -152,9 +152,7 @@ StateSave::StateSave() noexcept
       currentProgramName(nullptr),
       currentMidiBank(-1),
       currentMidiProgram(-1),
-      chunk(nullptr),
-      parameters(),
-      customData() {}
+      chunk(nullptr) {}
 
 StateSave::~StateSave() noexcept
 {

source/utils/CarlaString.hpp

@@ -40,20 +40,20 @@ public:
      * Empty string.
      */
     explicit CarlaString() noexcept
-        : fBuffer(_null()),
-          fBufferLen(0) {}
+    {
+        _init();
+    }
 
     /*
      * Simple character.
      */
     explicit CarlaString(const char c) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
         char ch[2];
         ch[0] = c;
         ch[1] = '\0';
 
+        _init();
         _dup(ch);
     }
 
@@ -61,9 +61,8 @@ public:
      * Simple char string.
      */
     explicit CarlaString(char* const strBuf) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
+        _init();
         _dup(strBuf);
     }
 
@@ -71,9 +70,8 @@ public:
      * Simple const char string.
      */
     explicit CarlaString(const char* const strBuf) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
+        _init();
         _dup(strBuf);
     }
 
@@ -81,13 +79,12 @@ public:
      * Integer.
      */
     explicit CarlaString(const int value) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
         char strBuf[0xff+1];
         std::snprintf(strBuf, 0xff, "%d", value);
         strBuf[0xff] = '\0';
 
+        _init();
         _dup(strBuf);
     }
 
@@ -95,13 +92,12 @@ public:
      * Unsigned integer, possibly in hexadecimal.
      */
     explicit CarlaString(const unsigned int value, const bool hexadecimal = false) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
         char strBuf[0xff+1];
         std::snprintf(strBuf, 0xff, hexadecimal ? "0x%x" : "%u", value);
         strBuf[0xff] = '\0';
 
+        _init();
         _dup(strBuf);
     }
 
@@ -109,13 +105,12 @@ public:
      * Long integer.
      */
     explicit CarlaString(const long value) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
         char strBuf[0xff+1];
         std::snprintf(strBuf, 0xff, "%ld", value);
         strBuf[0xff] = '\0';
 
+        _init();
         _dup(strBuf);
     }
 
@@ -123,13 +118,12 @@ public:
      * Long unsigned integer, possibly hexadecimal.
      */
     explicit CarlaString(const unsigned long value, const bool hexadecimal = false) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
         char strBuf[0xff+1];
         std::snprintf(strBuf, 0xff, hexadecimal ? "0x%lx" : "%lu", value);
         strBuf[0xff] = '\0';
 
+        _init();
         _dup(strBuf);
     }
 
@@ -137,13 +131,12 @@ public:
      * Long long integer.
      */
     explicit CarlaString(const long long value) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
         char strBuf[0xff+1];
         std::snprintf(strBuf, 0xff, "%lld", value);
         strBuf[0xff] = '\0';
 
+        _init();
         _dup(strBuf);
     }
 
@@ -151,13 +144,12 @@ public:
      * Long long unsigned integer, possibly hexadecimal.
      */
     explicit CarlaString(const unsigned long long value, const bool hexadecimal = false) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
         char strBuf[0xff+1];
         std::snprintf(strBuf, 0xff, hexadecimal ? "0x%llx" : "%llu", value);
         strBuf[0xff] = '\0';
 
+        _init();
         _dup(strBuf);
     }
 
@@ -165,13 +157,12 @@ public:
      * Single-precision floating point number.
      */
     explicit CarlaString(const float value) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
         char strBuf[0xff+1];
         std::snprintf(strBuf, 0xff, "%f", value);
         strBuf[0xff] = '\0';
 
+        _init();
         _dup(strBuf);
     }
 
@@ -179,13 +170,12 @@ public:
      * Double-precision floating point number.
      */
     explicit CarlaString(const double value) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
         char strBuf[0xff+1];
         std::snprintf(strBuf, 0xff, "%g", value);
         strBuf[0xff] = '\0';
 
+        _init();
         _dup(strBuf);
     }
 
@@ -196,9 +186,8 @@ public:
      * Create string from another string.
      */
     CarlaString(const CarlaString& str) noexcept
-        : fBuffer(_null()),
-          fBufferLen(0)
     {
+        _init();
         _dup(str.fBuffer);
     }
 
@@ -761,6 +750,16 @@ private:
         return &sNull;
     }
 
+    /*
+     * Shared init function.
+     * Called on all constructors.
+     */
+    void _init() noexcept
+    {
+        fBuffer    = _null();
+        fBufferLen = 0;
+    }
+
     /*
      * Helper function.
      * Called whenever the string needs to be allocated.
@@ -784,11 +783,7 @@ private:
             fBuffer    = (char*)std::malloc(fBufferLen+1);
 
             if (fBuffer == nullptr)
-            {
-                fBuffer    = _null();
-                fBufferLen = 0;
-                return;
-            }
+                return _init();
 
             std::strcpy(fBuffer, strBuf);
 
@@ -805,8 +800,7 @@ private:
             CARLA_SAFE_ASSERT(fBuffer != nullptr);
             std::free(fBuffer);
 
-            fBuffer    = _null();
-            fBufferLen = 0;
+            _init();
         }
     }
 

source/utils/CarlaStringList.hpp

@@ -163,12 +163,14 @@ public:
     CarlaStringList() noexcept
         : LinkedList<CarlaString>(true) {}
 
+#if 0
     CarlaStringList(const CarlaStringList& list) noexcept
         : LinkedList<CarlaString>(true)
     {
         for (Itenerator it = list.begin(); it.valid(); it.next())
             LinkedList<CarlaString>::append(it.getValue());
     }
+#endif
 
     ~CarlaStringList() noexcept
     {
@@ -224,7 +226,8 @@ public:
         return *this;
     }
 
-    CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
+private:
+    LinkedList<CarlaString> fList;
 };
 
 // -----------------------------------------------------------------------

source/utils/CarlaThread.hpp

@@ -37,14 +37,11 @@ protected:
      * Constructor.
      */
     CarlaThread(const char* const threadName = nullptr) noexcept
-        : fLock(),
-          fName(threadName),
-#ifdef PTW32_DLLPORT
-          fHandle(nullptr, 0)
-#else
-          fHandle(0),
-#endif
-          fShouldExit(false) {}
+        : fName(threadName),
+          fShouldExit(false)
+    {
+        _init();
+    }
 
     /*
      * Destructor.

source/utils/LinkedList.hpp

@@ -47,6 +47,22 @@
     ((const type *)((const char *)(ptr)-offsetof(type, member)))
 #endif
 
+// -----------------------------------------------------------------------
+// Declare non copyable and prevent heap allocation
+
+#ifdef CARLA_PROPER_CPP11_SUPPORT
+# define LINKED_LIST_DECLARATIONS(ClassName)         \
+    ClassName(ClassName&) = delete;                  \
+    ClassName(const ClassName&) = delete;            \
+    ClassName& operator=(const ClassName&) = delete; \
+    static void* operator new(size_t) = delete;
+#else
+# define LINKED_LIST_DECLARATIONS(ClassName) \
+    ClassName(ClassName&);                   \
+    ClassName(const ClassName&);             \
+    ClassName& operator=(const ClassName&);
+#endif
+
 // -----------------------------------------------------------------------
 // Abstract Linked List class
 // _allocate() and _deallocate are virtual calls provided by subclasses
@@ -69,9 +85,10 @@ protected:
 
     AbstractLinkedList(const bool isClass) noexcept
         : kIsClass(isClass),
-          kDataSize(sizeof(Data)),
-          fCount(0),
-          fQueue({&fQueue, &fQueue}) {}
+          kDataSize(sizeof(Data))
+    {
+        _init();
+    }
 
 public:
     virtual ~AbstractLinkedList() noexcept
@@ -367,10 +384,9 @@ private:
     void _createData(Data* const data, const T& value) noexcept
     {
         if (kIsClass)
-            new(data)Data({value, {nullptr, nullptr}});
-        else
-            data->value = value;
+            new(data)Data();
 
+        data->value = value;
         ++fCount;
     }
 
@@ -381,9 +397,9 @@ private:
             _createData(data, value);
 
             if (inTail)
-                __list_add(data->siblings, queue->prev, queue);
+                __list_add(&data->siblings, queue->prev, queue);
             else
-                __list_add(data->siblings, queue, queue->next);
+                __list_add(&data->siblings, queue, queue->next);
 
             return true;
         }
@@ -438,12 +454,12 @@ private:
    /*
     * Insert a new entry between two known consecutive entries.
     */
-    static void __list_add(ListHead& new_, ListHead* const prev, ListHead* const next) noexcept
+    static void __list_add(ListHead* const new_, ListHead* const prev, ListHead* const next) noexcept
     {
-        next->prev = &new_;
-        new_.next  = next;
-        new_.prev  = prev;
-        prev->next = &new_;
+        next->prev = new_;
+        new_->next = next;
+        new_->prev = prev;
+        prev->next = new_;
     }
 
    /*
@@ -484,8 +500,7 @@ private:
 
     template<typename> friend class RtLinkedList;
 
-    CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
-    CARLA_DECLARE_NON_COPY_CLASS(AbstractLinkedList)
+    LINKED_LIST_DECLARATIONS(AbstractLinkedList)
 };
 
 // -----------------------------------------------------------------------
@@ -511,8 +526,7 @@ protected:
         std::free(dataPtr);
     }
 
-    CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
-    CARLA_DECLARE_NON_COPY_CLASS(LinkedList)
+    LINKED_LIST_DECLARATIONS(LinkedList)
 };
 
 // -----------------------------------------------------------------------

source/utils/RtLinkedList.hpp

@@ -93,9 +93,6 @@ public:
     private:
         mutable RtMemPool_Handle fHandle;
         const size_t             kDataSize;
-
-        CARLA_PREVENT_HEAP_ALLOCATION
-        CARLA_DECLARE_NON_COPY_CLASS(Pool)
     };
 
     // -------------------------------------------------------------------
@@ -164,9 +161,9 @@ private:
             this->_createData(data, value);
 
             if (inTail)
-                this->__list_add(data->siblings, this->fQueue.prev, &(this->fQueue));
+                this->__list_add(&data->siblings, this->fQueue.prev, &this->fQueue);
             else
-                this->__list_add(data->siblings, &(this->fQueue), this->fQueue.next);
+                this->__list_add(&data->siblings, &this->fQueue, this->fQueue.next);
 
             return true;
         }
@@ -174,8 +171,7 @@ private:
         return false;
     }
 
-    CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
-    CARLA_DECLARE_NON_COPY_CLASS(RtLinkedList)
+    LINKED_LIST_DECLARATIONS(RtLinkedList)
 };
 
 // -----------------------------------------------------------------------