ceedling 1.0.1 → 1.1.0

data/vendor/cmock/src/cmock.c

@@ -1,16 +1,10 @@
 /* =========================================================================
     CMock - Automatic Mock Generation for C
     ThrowTheSwitch.org
-    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
     SPDX-License-Identifier: MIT
 ========================================================================= */
 
-/* ==========================================
-    CMock Project - Automatic Mock Generation for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
 #include "cmock.h"
 
 /* public constants to be used by mocks */
@@ -28,14 +22,18 @@ const char* CMockStringMismatch    = "Function called with unexpected argument v
 
 /* private variables */
 #ifdef CMOCK_MEM_DYNAMIC
-static unsigned char*         CMock_Guts_Buffer = NULL;
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_ALIGN_SIZE;
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
+    static unsigned char*         CMock_Guts_Buffer = NULL;
+    static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_ALIGN_SIZE;
+    static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
+#else
+#if !defined(UNITY_EXCLUDE_STDDEF_H) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
+    static _Alignas(max_align_t) long long CMock_Guts_Space[(CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE + sizeof(long long) - 1) / sizeof(long long)];
 #else
-static long long              CMock_Guts_Space[(CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE + sizeof(long long) - 1) / sizeof(long long)];
-static unsigned char*         CMock_Guts_Buffer = (unsigned char *)CMock_Guts_Space;
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;//sizeof(CMock_Guts_Space);
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
+    static long long              CMock_Guts_Space[(CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE + sizeof(long long) - 1) / sizeof(long long)];
+#endif
+    static unsigned char*         CMock_Guts_Buffer = (unsigned char*)CMock_Guts_Space;
+    static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;//sizeof(CMock_Guts_Space);
+    static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
 #endif
 
 /*-------------------------------------------------------
@@ -43,41 +41,41 @@ static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
  *-------------------------------------------------------*/
 CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size)
 {
-  CMOCK_MEM_INDEX_TYPE index;
-
-  /* verify arguments valid (we must be allocating space for at least 1 byte, and the existing chain must be in memory somewhere) */
-  if (size < 1)
-  {
-    return CMOCK_GUTS_NONE;
-  }
-
-  /* verify we have enough room */
-  size = size + CMOCK_MEM_INDEX_SIZE;
-  if (size & CMOCK_MEM_ALIGN_MASK)
-  {
-    size = (size + CMOCK_MEM_ALIGN_MASK) & ~CMOCK_MEM_ALIGN_MASK;
-  }
-  if ((CMock_Guts_BufferSize - CMock_Guts_FreePtr) < size)
-  {
+    CMOCK_MEM_INDEX_TYPE index;
+
+    /* verify arguments valid (we must be allocating space for at least 1 byte, and the existing chain must be in memory somewhere) */
+    if (size < 1)
+    {
+        return CMOCK_GUTS_NONE;
+    }
+
+    /* verify we have enough room */
+    size = size + CMOCK_MEM_INDEX_SIZE;
+    if (size & CMOCK_MEM_ALIGN_MASK)
+    {
+        size = (size + CMOCK_MEM_ALIGN_MASK) & ~CMOCK_MEM_ALIGN_MASK;
+    }
+    if ((CMock_Guts_BufferSize - CMock_Guts_FreePtr) < size)
+    {
 #ifndef CMOCK_MEM_DYNAMIC
-    return CMOCK_GUTS_NONE; /* nothing we can do; our static buffer is out of memory */
+        return CMOCK_GUTS_NONE; /* nothing we can do; our static buffer is out of memory */
 #else
-    /* our dynamic buffer does not have enough room; request more via realloc() */
-    CMOCK_MEM_INDEX_TYPE new_buffersize = CMock_Guts_BufferSize + CMOCK_MEM_SIZE + size;
-    unsigned char* new_buffer = realloc(CMock_Guts_Buffer, (size_t)new_buffersize);
-    if (new_buffer == NULL)
-      return CMOCK_GUTS_NONE; /* realloc() failed; out of memory */
-    CMock_Guts_Buffer = new_buffer;
-    CMock_Guts_BufferSize = new_buffersize;
+        /* our dynamic buffer does not have enough room; request more via realloc() */
+        CMOCK_MEM_INDEX_TYPE new_buffersize = CMock_Guts_BufferSize + CMOCK_MEM_SIZE + size;
+        unsigned char* new_buffer = realloc(CMock_Guts_Buffer, (size_t)new_buffersize);
+        if (new_buffer == NULL)
+            return CMOCK_GUTS_NONE; /* realloc() failed; out of memory */
+        CMock_Guts_Buffer = new_buffer;
+        CMock_Guts_BufferSize = new_buffersize;
 #endif
-  }
+    }
 
-  /* determine where we're putting this new block, and init its pointer to be the end of the line */
-  index = CMock_Guts_FreePtr + CMOCK_MEM_INDEX_SIZE;
-  *(CMOCK_MEM_INDEX_TYPE*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr]) = CMOCK_GUTS_NONE;
-  CMock_Guts_FreePtr += size;
+    /* determine where we're putting this new block, and init its pointer to be the end of the line */
+    index = CMock_Guts_FreePtr + CMOCK_MEM_INDEX_SIZE;
+    CMOCK_MEMSET(&CMock_Guts_Buffer[CMock_Guts_FreePtr], 0, CMOCK_MEM_INDEX_SIZE);
+    CMock_Guts_FreePtr += size;
 
-  return index;
+    return index;
 }
 
 /*-------------------------------------------------------
@@ -85,47 +83,52 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size)
  *-------------------------------------------------------*/
 CMOCK_MEM_INDEX_TYPE CMock_Guts_MemChain(CMOCK_MEM_INDEX_TYPE root_index, CMOCK_MEM_INDEX_TYPE obj_index)
 {
-  CMOCK_MEM_INDEX_TYPE index;
-  void* root;
-  void* obj;
-  void* next;
-
-  if (root_index == CMOCK_GUTS_NONE)
-  {
-    /* if there is no root currently, we return this object as the root of the chain */
-    return obj_index;
-  }
-  else
-  {
-    /* reject illegal nodes */
-    if ((root_index < CMOCK_MEM_ALIGN_SIZE) || (root_index >= CMock_Guts_FreePtr))
+    CMOCK_MEM_INDEX_TYPE index;
+    void* root;
+    void* obj;
+    void* next;
+
+    if (root_index == CMOCK_GUTS_NONE)
     {
-      return CMOCK_GUTS_NONE;
+        /* if there is no root currently, we return this object as the root of the chain */
+        return obj_index;
     }
-    if ((obj_index < CMOCK_MEM_ALIGN_SIZE) || (obj_index >= CMock_Guts_FreePtr))
+    else
     {
-      return CMOCK_GUTS_NONE;
+        /* reject illegal nodes */
+        if ((root_index < CMOCK_MEM_ALIGN_SIZE) || (root_index >= CMock_Guts_FreePtr))
+        {
+            return CMOCK_GUTS_NONE;
+        }
+        if ((obj_index < CMOCK_MEM_ALIGN_SIZE) || (obj_index >= CMock_Guts_FreePtr))
+        {
+            return CMOCK_GUTS_NONE;
+        }
+
+        root = (void*)(&CMock_Guts_Buffer[root_index]);
+        obj  = (void*)(&CMock_Guts_Buffer[obj_index]);
+
+        /* find the end of the existing chain and add us */
+        next = root;
+        do
+        {
+            CMOCK_MEMCPY(&index, (unsigned char*)next - CMOCK_MEM_INDEX_SIZE, sizeof(index));
+            if (index >= CMock_Guts_FreePtr)
+            {
+                return CMOCK_GUTS_NONE;
+            }
+            if (index > 0)
+            {
+                next = (void*)(&CMock_Guts_Buffer[index]);
+            }
+        }
+        while (index > 0);
+        {
+            CMOCK_MEM_INDEX_TYPE tmp = (CMOCK_MEM_INDEX_TYPE)((unsigned char*)obj - CMock_Guts_Buffer);
+            CMOCK_MEMCPY((unsigned char*)next - CMOCK_MEM_INDEX_SIZE, &tmp, sizeof(tmp));
+        }
+        return root_index;
     }
-
-    root = (void*)(&CMock_Guts_Buffer[root_index]);
-    obj  = (void*)(&CMock_Guts_Buffer[obj_index]);
-
-    /* find the end of the existing chain and add us */
-    next = root;
-    do {
-      index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE);
-      if (index >= CMock_Guts_FreePtr)
-      {
-        return CMOCK_GUTS_NONE;
-      }
-      if (index > 0)
-      {
-        next = (void*)(&CMock_Guts_Buffer[index]);
-      }
-    } while (index > 0);
-    *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE) = (CMOCK_MEM_INDEX_TYPE)((CMOCK_MEM_PTR_AS_INT)obj - (CMOCK_MEM_PTR_AS_INT)CMock_Guts_Buffer);
-    return root_index;
-  }
 }
 
 /*-------------------------------------------------------
@@ -133,27 +136,27 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemChain(CMOCK_MEM_INDEX_TYPE root_index, CMOCK_
  *-------------------------------------------------------*/
 CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index)
 {
-  CMOCK_MEM_INDEX_TYPE index;
-  void* previous_item;
-
-  /* There is nothing "next" if the pointer isn't from our buffer */
-  if ((previous_item_index < CMOCK_MEM_ALIGN_SIZE) || (previous_item_index  >= CMock_Guts_FreePtr))
-  {
-    return CMOCK_GUTS_NONE;
-  }
-  previous_item = (void*)(&CMock_Guts_Buffer[previous_item_index]);
-
-  /* if the pointer is good, then use it to look up the next index
-   * (we know the first element always goes in zero, so NEXT must always be > 1) */
-  index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)previous_item - CMOCK_MEM_INDEX_SIZE);
-  if ((index > 1) && (index < CMock_Guts_FreePtr))
-  {
-    return index;
-  }
-  else
-  {
-    return CMOCK_GUTS_NONE;
-  }
+    CMOCK_MEM_INDEX_TYPE index;
+    void* previous_item;
+
+    /* There is nothing "next" if the pointer isn't from our buffer */
+    if ((previous_item_index < CMOCK_MEM_ALIGN_SIZE) || (previous_item_index  >= CMock_Guts_FreePtr))
+    {
+        return CMOCK_GUTS_NONE;
+    }
+    previous_item = (void*)(&CMock_Guts_Buffer[previous_item_index]);
+
+    /* if the pointer is good, then use it to look up the next index
+     * (we know the first element always goes in zero, so NEXT must always be > 1) */
+    CMOCK_MEMCPY(&index, (unsigned char*)previous_item - CMOCK_MEM_INDEX_SIZE, sizeof(index));
+    if ((index > 1) && (index < CMock_Guts_FreePtr))
+    {
+        return index;
+    }
+    else
+    {
+        return CMOCK_GUTS_NONE;
+    }
 }
 
 /*-------------------------------------------------------
@@ -161,17 +164,17 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index
  *-------------------------------------------------------*/
 CMOCK_MEM_INDEX_TYPE CMock_Guts_MemEndOfChain(CMOCK_MEM_INDEX_TYPE root_index)
 {
-  CMOCK_MEM_INDEX_TYPE index = root_index;
-  CMOCK_MEM_INDEX_TYPE next_index;
+    CMOCK_MEM_INDEX_TYPE index = root_index;
+    CMOCK_MEM_INDEX_TYPE next_index;
 
-  for (next_index = root_index;
-       next_index != CMOCK_GUTS_NONE;
-       next_index = CMock_Guts_MemNext(index))
-  {
-    index = next_index;
-  }
+    for (next_index = root_index;
+            next_index != CMOCK_GUTS_NONE;
+            next_index = CMock_Guts_MemNext(index))
+    {
+        index = next_index;
+    }
 
-  return index;
+    return index;
 }
 
 /*-------------------------------------------------------
@@ -179,14 +182,14 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemEndOfChain(CMOCK_MEM_INDEX_TYPE root_index)
  *-------------------------------------------------------*/
 void* CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index)
 {
-  if ((index >= CMOCK_MEM_ALIGN_SIZE) && (index < CMock_Guts_FreePtr))
-  {
-    return (void*)(&CMock_Guts_Buffer[index]);
-  }
-  else
-  {
-    return NULL;
-  }
+    if ((index >= CMOCK_MEM_ALIGN_SIZE) && (index < CMock_Guts_FreePtr))
+    {
+        return (void*)(&CMock_Guts_Buffer[index]);
+    }
+    else
+    {
+        return NULL;
+    }
 }
 
 /*-------------------------------------------------------
@@ -194,7 +197,7 @@ void* CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index)
  *-------------------------------------------------------*/
 CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesCapacity(void)
 {
-  return (sizeof(CMock_Guts_Buffer) - CMOCK_MEM_ALIGN_SIZE);
+    return (CMock_Guts_BufferSize - CMOCK_MEM_ALIGN_SIZE);
 }
 
 /*-------------------------------------------------------
@@ -202,7 +205,7 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesCapacity(void)
  *-------------------------------------------------------*/
 CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesFree(void)
 {
-  return CMock_Guts_BufferSize - CMock_Guts_FreePtr;
+    return CMock_Guts_BufferSize - CMock_Guts_FreePtr;
 }
 
 /*-------------------------------------------------------
@@ -210,7 +213,7 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesFree(void)
  *-------------------------------------------------------*/
 CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesUsed(void)
 {
-  return CMock_Guts_FreePtr - CMOCK_MEM_ALIGN_SIZE;
+    return CMock_Guts_FreePtr - CMOCK_MEM_ALIGN_SIZE;
 }
 
 /*-------------------------------------------------------
@@ -218,7 +221,7 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesUsed(void)
  *-------------------------------------------------------*/
 void CMock_Guts_MemFreeAll(void)
 {
-  CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE; /* skip the very beginning */
+    CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE; /* skip the very beginning */
 }
 
 /*-------------------------------------------------------
@@ -226,13 +229,13 @@ void CMock_Guts_MemFreeAll(void)
  *-------------------------------------------------------*/
 void CMock_Guts_MemFreeFinal(void)
 {
-  CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
+    CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
 #ifdef CMOCK_MEM_DYNAMIC
-  if (CMock_Guts_Buffer)
-  {
-    free(CMock_Guts_Buffer);
-    CMock_Guts_Buffer = NULL;
-  }
+    if (CMock_Guts_Buffer)
+    {
+        free(CMock_Guts_Buffer);
+        CMock_Guts_Buffer = NULL;
+    }
 #endif
 }
 

data/vendor/cmock/src/cmock.h

@@ -1,38 +1,32 @@
 /* =========================================================================
     CMock - Automatic Mock Generation for C
     ThrowTheSwitch.org
-    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
     SPDX-License-Identifier: MIT
 ========================================================================= */
 
-/* ==========================================
-    CMock Project - Automatic Mock Generation for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
 #ifndef CMOCK_FRAMEWORK_H
 #define CMOCK_FRAMEWORK_H
 
 #include "cmock_internals.h"
 
 #define CMOCK_VERSION_MAJOR    2
-#define CMOCK_VERSION_MINOR    6
+#define CMOCK_VERSION_MINOR    7
 #define CMOCK_VERSION_BUILD    0
 #define CMOCK_VERSION          ((CMOCK_VERSION_MAJOR << 16) | (CMOCK_VERSION_MINOR << 8) | CMOCK_VERSION_BUILD)
 
 /* should be big enough to index full range of CMOCK_MEM_MAX */
 #ifndef CMOCK_MEM_INDEX_TYPE
-#include <stddef.h>
-#define CMOCK_MEM_INDEX_TYPE  size_t
+    #include <stddef.h>
+    #define CMOCK_MEM_INDEX_TYPE  size_t
 #endif
 
 #define CMOCK_GUTS_NONE   (0)
 
 #if defined __GNUC__
-#    define CMOCK_FUNCTION_ATTR(a) __attribute__((a))
+    #define CMOCK_FUNCTION_ATTR(a) __attribute__((a))
 #else
-#    define CMOCK_FUNCTION_ATTR(a) /* ignore */
+    #define CMOCK_FUNCTION_ATTR(a) /* ignore */
 #endif
 
 /*-------------------------------------------------------
@@ -45,7 +39,7 @@ CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemEndOfChain(CMOCK_MEM_INDEX_TYPE root_index)
 
 void*                 CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index) CMOCK_FUNCTION_ATTR(pure);
 
-CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesCapacity(void) CMOCK_FUNCTION_ATTR(const);
+CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesCapacity(void) CMOCK_FUNCTION_ATTR(const);
 CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesFree(void) CMOCK_FUNCTION_ATTR(pure);
 CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesUsed(void) CMOCK_FUNCTION_ATTR(pure);
 void                  CMock_Guts_MemFreeAll(void);

data/vendor/cmock/src/cmock_internals.h

@@ -1,16 +1,10 @@
 /* =========================================================================
     CMock - Automatic Mock Generation for C
     ThrowTheSwitch.org
-    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
     SPDX-License-Identifier: MIT
 ========================================================================= */
 
-/* ==========================================
-    CMock Project - Automatic Mock Generation for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
 #ifndef CMOCK_FRAMEWORK_INTERNALS_H
 #define CMOCK_FRAMEWORK_INTERNALS_H
 
@@ -32,66 +26,106 @@ extern const char* CMockStringMismatch;
 /* define CMOCK_MEM_DYNAMIC to grab memory as needed with malloc
  * when you do that, CMOCK_MEM_SIZE is used for incremental size instead of total */
 #ifdef CMOCK_MEM_STATIC
-#undef CMOCK_MEM_DYNAMIC
+    #undef CMOCK_MEM_DYNAMIC
 #endif
 
 #ifdef CMOCK_MEM_DYNAMIC
-#include <stdlib.h>
+    #include <stdlib.h>
 #endif
 
 /* this is used internally during pointer arithmetic. make sure this type is the same size as the target's pointer type */
 #ifndef CMOCK_MEM_PTR_AS_INT
-#ifdef UNITY_POINTER_WIDTH
-#ifdef UNITY_INT_WIDTH
-#if UNITY_POINTER_WIDTH == UNITY_INT_WIDTH
-#define CMOCK_MEM_PTR_AS_INT unsigned int
-#endif
-#endif
-#endif
+    #ifdef UNITY_POINTER_WIDTH
+        #ifdef UNITY_INT_WIDTH
+            #if UNITY_POINTER_WIDTH == UNITY_INT_WIDTH
+                #define CMOCK_MEM_PTR_AS_INT unsigned int
+            #endif
+        #endif
+    #endif
 #endif
 
 #ifndef CMOCK_MEM_PTR_AS_INT
-#ifdef UNITY_POINTER_WIDTH
-#ifdef UNITY_LONG_WIDTH
-#if UNITY_POINTER_WIDTH == UNITY_LONG_WIDTH
-#define CMOCK_MEM_PTR_AS_INT unsigned long
-#endif
-#if UNITY_POINTER_WIDTH > UNITY_LONG_WIDTH
-#define CMOCK_MEM_PTR_AS_INT unsigned long long
-#endif
-#endif
-#endif
+    #ifdef UNITY_POINTER_WIDTH
+        #ifdef UNITY_LONG_WIDTH
+            #if UNITY_POINTER_WIDTH == UNITY_LONG_WIDTH
+                #define CMOCK_MEM_PTR_AS_INT unsigned long
+            #endif
+            #if UNITY_POINTER_WIDTH > UNITY_LONG_WIDTH
+                #define CMOCK_MEM_PTR_AS_INT unsigned long long
+            #endif
+        #endif
+    #endif
 #endif
 
 #ifndef CMOCK_MEM_PTR_AS_INT
-#define CMOCK_MEM_PTR_AS_INT unsigned long
+    #define CMOCK_MEM_PTR_AS_INT unsigned long
 #endif
 
 /* 0 for no alignment, 1 for 16-bit, 2 for 32-bit, 3 for 64-bit */
 #ifndef CMOCK_MEM_ALIGN
-  #ifdef UNITY_LONG_WIDTH
-    #if (UNITY_LONG_WIDTH == 16)
-      #define CMOCK_MEM_ALIGN (1)
-    #elif (UNITY_LONG_WIDTH == 32)
-      #define CMOCK_MEM_ALIGN (2)
-    #elif (UNITY_LONG_WIDTH == 64)
-      #define CMOCK_MEM_ALIGN (3)
+    #ifdef UNITY_LONG_WIDTH
+        #if (UNITY_LONG_WIDTH == 16)
+            #define CMOCK_MEM_ALIGN (1)
+        #elif (UNITY_LONG_WIDTH == 32)
+            #define CMOCK_MEM_ALIGN (2)
+        #elif (UNITY_LONG_WIDTH == 64)
+            #define CMOCK_MEM_ALIGN (3)
+        #else
+            #define CMOCK_MEM_ALIGN (2)
+        #endif
     #else
-      #define CMOCK_MEM_ALIGN (2)
+        #define CMOCK_MEM_ALIGN (2)
     #endif
-  #else
-    #define CMOCK_MEM_ALIGN (2)
-  #endif
+
+    /* Boost to 8-byte alignment when 64-bit integers or doubles are enabled,
+     * since those types require 8-byte alignment even on 32-bit platforms */
+    #if CMOCK_MEM_ALIGN < 3
+        #if defined(UNITY_SUPPORT_64) || defined(UNITY_INCLUDE_DOUBLE)
+            #undef  CMOCK_MEM_ALIGN
+            #define CMOCK_MEM_ALIGN (3)
+        #endif
+    #endif
+
+    /* sentinel: CMOCK_MEM_ALIGN was auto-detected (not user-supplied) */
+    #define CMOCK_MEM_ALIGN_AUTO
 #endif
 
 /* amount of memory to allow cmock to use in its internal heap */
 #ifndef CMOCK_MEM_SIZE
-#define CMOCK_MEM_SIZE (32768)
+    #define CMOCK_MEM_SIZE (32768)
+#endif
+
+/* Cast a volatile pointer to void* for use with CMOCK_MEMCPY or Unity assertion
+ * macros. Routing through CMOCK_MEM_PTR_AS_INT (a pointer-sized integer) avoids
+ * -Wcast-qual without requiring compiler-specific pragmas or C99 intptr_t. */
+#define CMOCK_DEVOLATILE_PTR(p) ((void*)(CMOCK_MEM_PTR_AS_INT)(p))
+
+/* memory copy/set functions used by CMock internals and generated mocks.
+ * Override to use custom implementations on targets without standard libc. */
+#if !defined(CMOCK_MEMCPY) || !defined(CMOCK_MEMSET)
+    #include <string.h>
+    #ifndef CMOCK_MEMCPY
+        #define CMOCK_MEMCPY(a, b, c) memcpy(a, b, c)
+    #endif
+    #ifndef CMOCK_MEMSET
+        #define CMOCK_MEMSET(a, b, c) memset(a, b, c)
+    #endif
 #endif
 
 /* automatically calculated defs for easier reading */
 #define CMOCK_MEM_ALIGN_SIZE  (CMOCK_MEM_INDEX_TYPE)(1u << CMOCK_MEM_ALIGN)
 #define CMOCK_MEM_ALIGN_MASK  (CMOCK_MEM_INDEX_TYPE)(CMOCK_MEM_ALIGN_SIZE - 1)
+
+/* When CMOCK_MEM_ALIGN was auto-detected and stddef.h is available (C11+),
+ * use sizeof(max_align_t) to guarantee alignment is sufficient for all
+ * fundamental types on this platform, taking the larger of the two values */
+#if defined(CMOCK_MEM_ALIGN_AUTO) && !defined(UNITY_EXCLUDE_STDDEF_H) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
+    #undef  CMOCK_MEM_ALIGN_SIZE
+    #undef  CMOCK_MEM_ALIGN_MASK
+    #define CMOCK_MEM_ALIGN_SIZE  (CMOCK_MEM_INDEX_TYPE)(sizeof(max_align_t) > (1u << CMOCK_MEM_ALIGN) ? sizeof(max_align_t) : (1u << CMOCK_MEM_ALIGN))
+    #define CMOCK_MEM_ALIGN_MASK  (CMOCK_MEM_INDEX_TYPE)(CMOCK_MEM_ALIGN_SIZE - 1)
+#endif
+
 #define CMOCK_MEM_INDEX_SIZE  (CMOCK_MEM_INDEX_TYPE)(CMOCK_MEM_PTR_AS_INT)((sizeof(CMOCK_MEM_INDEX_TYPE) > CMOCK_MEM_ALIGN_SIZE) ? sizeof(CMOCK_MEM_INDEX_TYPE) : CMOCK_MEM_ALIGN_SIZE)
 
 

data/vendor/cmock/test/c/TestCMockC.c

@@ -1,16 +1,10 @@
 /* =========================================================================
     CMock - Automatic Mock Generation for C
     ThrowTheSwitch.org
-    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
     SPDX-License-Identifier: MIT
 ========================================================================= */
 
-/* ==========================================
-    CMock Project - Automatic Mock Generation for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
 #include "unity.h"
 #include "cmock.h"
 

data/vendor/cmock/test/c/TestCMockC.yml

@@ -1,7 +1,7 @@
 # =========================================================================
 #   CMock - Automatic Mock Generation for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 

data/vendor/cmock/test/c/TestCMockCDynamic.c

@@ -1,16 +1,10 @@
 /* =========================================================================
     CMock - Automatic Mock Generation for C
     ThrowTheSwitch.org
-    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
     SPDX-License-Identifier: MIT
 ========================================================================= */
 
-/* ==========================================
-    CMock Project - Automatic Mock Generation for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
 #include "unity.h"
 #include "cmock.h"
 

data/vendor/cmock/test/c/TestCMockCDynamic.yml

@@ -1,7 +1,7 @@
 # =========================================================================
 #   CMock - Automatic Mock Generation for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 

data/vendor/cmock/test/c/TestCMockCDynamic_Runner.c

@@ -1,16 +1,10 @@
 /* =========================================================================
     CMock - Automatic Mock Generation for C
     ThrowTheSwitch.org
-    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
     SPDX-License-Identifier: MIT
 ========================================================================= */
 
-/* ==========================================
-    CMock Project - Automatic Mock Generation for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
 #include "unity.h"
 #include "cmock.h"
 #include <setjmp.h>

data/vendor/cmock/test/c/TestCMockC_Runner.c

@@ -1,16 +1,10 @@
 /* =========================================================================
     CMock - Automatic Mock Generation for C
     ThrowTheSwitch.org
-    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
     SPDX-License-Identifier: MIT
 ========================================================================= */
 
-/* ==========================================
-    CMock Project - Automatic Mock Generation for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
 #include "unity.h"
 #include <setjmp.h>
 #include <stdio.h>