Fix whitespace issues in opj_malloc.c

[openjpeg.git] / src / lib / openjp2 / opj_malloc.c

diff --git a/src/lib/openjp2/opj_malloc.c b/src/lib/openjp2/opj_malloc.c
index 04ef055c9434aae571ca9c16eee4c91295fac016..e91b660e9a0a8acabc48b3dfcef535ef454d4e95 100644 (file)
--- a/src/lib/openjp2/opj_malloc.c
+++ b/src/lib/openjp2/opj_malloc.c
@@ -1,6 +1,6 @@
 /*
- * The copyright in this software is being made available under the 2-clauses 
- * BSD License, included below. This software may be subject to other third 
+ * The copyright in this software is being made available under the 2-clauses
+ * BSD License, included below. This software may be subject to other third
  * party and contributor rights, including patent rights, and no such rights
  * are granted under this license.
  *
@@ -49,7 +49,7 @@ static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size)
     return NULL;
   }
 
-#if defined(HAVE_POSIX_MEMALIGN)
+#if defined(OPJ_HAVE_POSIX_MEMALIGN)
   /* aligned_alloc requires c11, restrict to posix_memalign for now. Quote:
    * This function was introduced in POSIX 1003.1d. Although this function is
    * superseded by aligned_alloc, it is more portable to older POSIX systems
@@ -59,16 +59,16 @@ static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size)
     ptr = NULL;
   }
   /* older linux */
-#elif defined(HAVE_MEMALIGN)
+#elif defined(OPJ_HAVE_MEMALIGN)
   ptr = memalign( alignment, size );
 /* _MSC_VER */
-#elif defined(HAVE__ALIGNED_MALLOC)
+#elif defined(OPJ_HAVE__ALIGNED_MALLOC)
   ptr = _aligned_malloc(size, alignment);
 #else
   /*
    * Generic aligned malloc implementation.
    * Uses size_t offset for the integer manipulation of the pointer,
-   * as uintptr_t is not available in C89 to do 
+   * as uintptr_t is not available in C89 to do
    * bitwise operations on the pointer itself.
    */
   alignment--;
@@ -78,7 +78,7 @@ static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size)
 
     /* Room for padding and extra pointer stored in front of allocated area */
     size_t overhead = alignment + sizeof(void *);
-               
+
     /* let's be extra careful */
     assert(alignment <= (SIZE_MAX - sizeof(void *)));
 
@@ -114,8 +114,8 @@ static INLINE void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t ne
   }
 
 /* no portable aligned realloc */
-#if defined(HAVE_POSIX_MEMALIGN) || defined(HAVE_MEMALIGN)
-  /* glibc doc states one can mixed aligned malloc with realloc */
+#if defined(OPJ_HAVE_POSIX_MEMALIGN) || defined(OPJ_HAVE_MEMALIGN)
+  /* glibc doc states one can mix aligned malloc with realloc */
   r_ptr = realloc( ptr, new_size ); /* fast path */
   /* we simply use `size_t` to cast, since we are only interest in binary AND
    * operator */
@@ -132,7 +132,7 @@ static INLINE void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t ne
     r_ptr = a_ptr;
   }
 /* _MSC_VER */
-#elif defined(HAVE__ALIGNED_MALLOC)
+#elif defined(OPJ_HAVE__ALIGNED_MALLOC)
   r_ptr = _aligned_realloc( ptr, new_size, alignment );
 #else
   if (ptr == NULL) {
@@ -151,7 +151,7 @@ static INLINE void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t ne
     if (new_size > SIZE_MAX - overhead) {
       return NULL;
     }
-               
+
     oldmem = ((void**) ptr)[-1];
     newmem = (OPJ_UINT8*)realloc(oldmem, new_size + overhead);
     if (newmem == NULL) {
@@ -166,7 +166,7 @@ static INLINE void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t ne
       size_t new_offset;
 
       /* realloc created a new copy, realign the copied memory block */
-      old_offset = (size_t)(ptr - oldmem);
+      old_offset = (size_t)((OPJ_UINT8*)ptr - (OPJ_UINT8*)oldmem);
 
       /* offset = ((alignment + 1U) - ((size_t)(mem + sizeof(void*)) & alignment)) & alignment; */
       /* Use the fact that alignment + 1U is a power of 2 */
@@ -210,9 +210,9 @@ void * opj_aligned_realloc(void *ptr, size_t size)
 
 void opj_aligned_free(void* ptr)
 {
-#if defined(HAVE_POSIX_MEMALIGN) || defined(HAVE_MEMALIGN)
+#if defined(OPJ_HAVE_POSIX_MEMALIGN) || defined(OPJ_HAVE_MEMALIGN)
   free( ptr );
-#elif defined(HAVE__ALIGNED_MALLOC)
+#elif defined(OPJ_HAVE__ALIGNED_MALLOC)
   _aligned_free( ptr );
 #else
   /* Generic implementation has malloced pointer stored in front of used area */