6 files changed, 197 insertions, 197 deletions

diff --git a/apps/codecs/lib/ffmpeg_bswap.h b/apps/codecs/lib/ffmpeg_bswap.h
index b083d10ed0..24a2aab7ea 100644
--- a/apps/codecs/lib/ffmpeg_bswap.h
+++ b/apps/codecs/lib/ffmpeg_bswap.h
@@ -34,8 +34,8 @@ static inline uint64_t ByteSwap64(uint64_t x)
 #elif defined(ARCH_X86)
 static inline unsigned short ByteSwap16(unsigned short x)
 {
-  __asm("xchgb %b0,%h0" :
-        "=q" (x)        :
+  __asm("xchgb %b0,%h0" :
+        "=q" (x)    :
         "0" (x));
     return x;
 }
@@ -44,13 +44,13 @@ static inline unsigned short ByteSwap16(unsigned short x)
 static inline unsigned int ByteSwap32(unsigned int x)
 {
 #if __CPU__ > 386
- __asm("bswap   %0":
+ __asm("bswap   %0":
       "=r" (x)     :
 #else
- __asm("xchgb   %b0,%h0\n"
-      " rorl    $16,%0\n"
-      " xchgb   %b0,%h0":
-      "=q" (x)          :
+ __asm("xchgb   %b0,%h0\n"
+      " rorl    $16,%0\n"
+      " xchgb   %b0,%h0":
+      "=q" (x)      :
 #endif
       "0" (x));
   return x;
@@ -61,7 +61,7 @@ static inline unsigned long long int ByteSwap64(unsigned long long int x)
 {
   register union { __extension__ uint64_t __ll;
           uint32_t __l[2]; } __x;
-  asm("xchgl    %0,%1":
+  asm("xchgl    %0,%1":
       "=r"(__x.__l[0]),"=r"(__x.__l[1]):
       "0"(bswap_32((unsigned long)x)),"1"(bswap_32((unsigned long)(x>>32))));
   return __x.__ll;
@@ -71,17 +71,17 @@ static inline unsigned long long int ByteSwap64(unsigned long long int x)
 #elif defined(ARCH_SH4)
 
 static inline uint16_t ByteSwap16(uint16_t x) {
-        __asm__("swap.b %0,%0":"=r"(x):"0"(x));
-        return x;
+    __asm__("swap.b %0,%0":"=r"(x):"0"(x));
+    return x;
 }
 
 static inline uint32_t ByteSwap32(uint32_t x) {
-        __asm__(
-        "swap.b %0,%0\n"
-        "swap.w %0,%0\n"
-        "swap.b %0,%0\n"
-        :"=r"(x):"0"(x));
-        return x;
+    __asm__(
+    "swap.b %0,%0\n"
+    "swap.w %0,%0\n"
+    "swap.b %0,%0\n"
+    :"=r"(x):"0"(x));
+    return x;
 }
 
 #define bswap_16(x) ByteSwap16(x)
@@ -124,9 +124,9 @@ static inline uint64_t ByteSwap64(uint64_t x)
 }
 #define bswap_64(x) ByteSwap64(x)
 
-#endif  /* !ARCH_X86 */
+#endif  /* !ARCH_X86 */
 
-#endif  /* !HAVE_BYTESWAP_H */
+#endif  /* !HAVE_BYTESWAP_H */
 
 // be2me ... BigEndian to MachineEndian
 // le2me ... LittleEndian to MachineEndian
diff --git a/apps/codecs/lib/fft-ffmpeg.c b/apps/codecs/lib/fft-ffmpeg.c
index 203a82e7d4..d18f0481c0 100644
--- a/apps/codecs/lib/fft-ffmpeg.c
+++ b/apps/codecs/lib/fft-ffmpeg.c
@@ -463,7 +463,7 @@ int main (void)
 //exec_time = (((double)end-(double)start)/CLOCKS_PER_SEC);
     for(j = 0; j < FFT_SIZE; j++)
     {
-        printf("%8.4f\n", sqrt(pow(fixtof32(z[j].re),2)+ pow(fixtof32(z[j].im), 2)));   
+        printf("%8.4f\n", sqrt(pow(fixtof32(z[j].re),2)+ pow(fixtof32(z[j].im), 2)));   
         //getchar();
     }
     printf("muls = %d, adds = %d\n", muls, adds);
diff --git a/apps/codecs/lib/setjmp.h b/apps/codecs/lib/setjmp.h
index eed43c6f95..f7ff2ea58c 100644
--- a/apps/codecs/lib/setjmp.h
+++ b/apps/codecs/lib/setjmp.h
@@ -18,10 +18,10 @@
 #ifdef CPU_COLDFIRE
 /*
  * onsstack,sigmask,sp,pc,psl,d2-d7,a2-a6,
- * fp2-fp7      for 68881.
+ * fp2-fp7  for 68881.
  * All else recovered by under/over(flow) handling.
  */
-#define _JBLEN  34
+#define _JBLEN  34
 #endif
 
 #ifdef CPU_MIPS
@@ -48,9 +48,9 @@
 
 #ifdef _JBLEN
 #ifdef _JBTYPE
-typedef _JBTYPE jmp_buf[_JBLEN];
+typedef _JBTYPE jmp_buf[_JBLEN];
 #else
-typedef int jmp_buf[_JBLEN];
+typedef int jmp_buf[_JBLEN];
 #endif
 #else
 typedef int jmp_buf;
diff --git a/apps/codecs/lib/setjmp_arm.S b/apps/codecs/lib/setjmp_arm.S
index 4bb2a46a7a..a4d5a016bd 100644
--- a/apps/codecs/lib/setjmp_arm.S
+++ b/apps/codecs/lib/setjmp_arm.S
@@ -27,10 +27,10 @@
    in both interworked and non-interworked environments as well as with
    older processors which do not have the BX instruction we do the 
    following:
-        Test the return address.
-        If the bottom bit is clear perform an "old style" function exit.
-        (We know that we are in ARM mode and returning to an ARM mode caller).
-        Otherwise use the BX instruction to perform the function exit.
+    Test the return address.
+    If the bottom bit is clear perform an "old style" function exit.
+    (We know that we are in ARM mode and returning to an ARM mode caller).
+    Otherwise use the BX instruction to perform the function exit.
 
    We know that we will never attempt to perform the BX instruction on 
    an older processor, because that kind of processor will never be 
@@ -47,7 +47,7 @@
    test the bottom bit, because this is part of the processor status.  
    Instead we just do a normal return, since we know that we cannot be 
    returning to a Thumb caller - the Thumb does not support APCS-26.
-        
+    
    Function entry is much simpler.  If we are compiling for the Thumb we 
    just switch into ARM mode and then drop through into the rest of the
    function.  The function exit code will take care of the restore to
@@ -56,18 +56,18 @@
    For Thumb-2 do everything in Thumb mode.  */
 
 #ifdef __APCS_26__
-#define RET     movs            pc, lr
+#define RET movs        pc, lr
 #elif defined(__thumb2__)
-#define RET     bx lr
+#define RET bx lr
 #else
-#define RET     tst             lr, #1; \
-                moveq           pc, lr ; \
-.word           0xe12fff1e      /* bx lr */
+#define RET tst     lr, #1; \
+            moveq       pc, lr ; \
+.word           0xe12fff1e  /* bx lr */
 #endif
 
 #ifdef __thumb2__
 .macro COND where when 
-        i\where \when
+    i\where \when
 .endm
 #else
 .macro COND where when 
@@ -77,96 +77,96 @@
 #if defined(__thumb2__)
 .syntax unified
 .macro MODE
-        .thumb
-        .thumb_func
+    .thumb
+    .thumb_func
 .endm
 .macro PROLOGUE name
 .endm
 
 #elif defined(__thumb__)
-#define MODE            .thumb_func
+#define MODE        .thumb_func
 .macro PROLOGUE name
-        .code 16
-        bx      pc
-        nop     
-        .code 32
+    .code 16
+    bx  pc
+    nop 
+    .code 32
 SYM (.arm_start_of.\name):
 .endm
 #else /* Arm */
-#define MODE            .code 32
+#define MODE        .code 32
 .macro PROLOGUE name
 .endm
 #endif
-        
+    
 .macro FUNC_START name
-        .text
-        .align 2
-        MODE
-        .globl SYM (\name)
-        TYPE (\name)
+    .text
+    .align 2
+    MODE
+    .globl SYM (\name)
+    TYPE (\name)
 SYM (\name):
-        PROLOGUE \name
+    PROLOGUE \name
 .endm
 
 .macro FUNC_END name
-        RET
-        SIZE (\name)
+    RET
+    SIZE (\name)
 .endm
-        
+    
 /* --------------------------------------------------------------------
                  int setjmp (jmp_buf); 
    -------------------------------------------------------------------- */
-        
-        FUNC_START setjmp
+    
+    FUNC_START setjmp
 
-        /* Save all the callee-preserved registers into the jump buffer.  */
+    /* Save all the callee-preserved registers into the jump buffer.  */
 #ifdef __thumb2__
-        stmea           a1!, { v1-v7, fp, ip, lr }
-        str             sp, [a1],#+4
+    stmea       a1!, { v1-v7, fp, ip, lr }
+    str     sp, [a1],#+4
 #else
-        stmea           a1!, { v1-v7, fp, ip, sp, lr }
+    stmea       a1!, { v1-v7, fp, ip, sp, lr }
 #endif
-        
-#if 0   /* Simulator does not cope with FP instructions yet.  */
+    
+#if 0   /* Simulator does not cope with FP instructions yet.  */
 #ifndef __SOFTFP__
-        /* Save the floating point registers.  */
-        sfmea           f4, 4, [a1]
+    /* Save the floating point registers.  */
+    sfmea       f4, 4, [a1]
 #endif
-#endif          
-        /* When setting up the jump buffer return 0.  */
-        mov             a1, #0
+#endif      
+    /* When setting up the jump buffer return 0.  */
+    mov     a1, #0
 
-        FUNC_END setjmp
-        
+    FUNC_END setjmp
+    
 /* --------------------------------------------------------------------
-                volatile void longjmp (jmp_buf, int);
+        volatile void longjmp (jmp_buf, int);
    -------------------------------------------------------------------- */
-        
-        FUNC_START longjmp
+    
+    FUNC_START longjmp
 
-        /* If we have stack extension code it ought to be handled here.  */
-        
-        /* Restore the registers, retrieving the state when setjmp() was called.  */
+    /* If we have stack extension code it ought to be handled here.  */
+    
+    /* Restore the registers, retrieving the state when setjmp() was called.  */
 #ifdef __thumb2__
-        ldmfd           a1!, { v1-v7, fp, ip, lr }
-        ldr             sp, [a1],#+4
+    ldmfd       a1!, { v1-v7, fp, ip, lr }
+    ldr     sp, [a1],#+4
 #else
-        ldmfd           a1!, { v1-v7, fp, ip, sp, lr }
+    ldmfd       a1!, { v1-v7, fp, ip, sp, lr }
 #endif
-        
-#if 0   /* Simulator does not cope with FP instructions yet.  */
+    
+#if 0   /* Simulator does not cope with FP instructions yet.  */
 #ifndef __SOFTFP__
-        /* Restore floating point registers as well.  */
-        lfmfd           f4, 4, [a1]
+    /* Restore floating point registers as well.  */
+    lfmfd       f4, 4, [a1]
 #endif
-#endif  
-        /* Put the return value into the integer result register.
-           But if it is zero then return 1 instead.  */ 
-        movs            a1, a2
+#endif  
+    /* Put the return value into the integer result register.
+       But if it is zero then return 1 instead.  */ 
+    movs        a1, a2
 #ifdef __thumb2__
-        it              eq
+    it      eq
 #endif
-        moveq           a1, #1
+    moveq       a1, #1
 
-        FUNC_END longjmp
+    FUNC_END longjmp
 
diff --git a/apps/codecs/lib/setjmp_cf.S b/apps/codecs/lib/setjmp_cf.S
index acc98c3f59..86eda8079c 100644
--- a/apps/codecs/lib/setjmp_cf.S
+++ b/apps/codecs/lib/setjmp_cf.S
@@ -34,46 +34,46 @@
 .global SYM (longjmp)
 
 SYM (setjmp):
-        moveal sp@(4),a0
-        movel sp@(0),a0@(12)
-        movel sp,a0@(8)
-        moveml d2-d7/a2-a6,a0@(20)
-        clrl d0
-        rts
+    moveal sp@(4),a0
+    movel sp@(0),a0@(12)
+    movel sp,a0@(8)
+    moveml d2-d7/a2-a6,a0@(20)
+    clrl d0
+    rts
 
 SYM (longjmp):
-        moveal sp@(4),a0
-        movel sp@(8),d0
-        bne 1f
-        movel &1,d0
+    moveal sp@(4),a0
+    movel sp@(8),d0
+    bne 1f
+    movel &1,d0
 1:
-        moveml a0@(20),d2-d7/a2-a6
-        moveal a0@(8),sp
-        movel a0@(12),sp@
-        rts
+    moveml a0@(20),d2-d7/a2-a6
+    moveal a0@(8),sp
+    movel a0@(12),sp@
+    rts
 
 #ifdef M68881
 .global SYM (setjmp_68881)
 .global SYM (longjmp_68881)
 
 SYM (setjmp_68881):
-        moveal sp@(4),a0
-        movel sp@(0),a0@(12)
-        movel sp,a0@(8)
-        moveml d2-d7/a2-a6,a0@(20)
-        fmovemx fp2-fp7,a0@(64)
-        clrl d0
-        rts
+    moveal sp@(4),a0
+    movel sp@(0),a0@(12)
+    movel sp,a0@(8)
+    moveml d2-d7/a2-a6,a0@(20)
+    fmovemx fp2-fp7,a0@(64)
+    clrl d0
+    rts
 
 SYM (longjmp_68881):
-        moveal sp@(4),a0
-        fmovemx a0@(64),fp2-fp7
-        movel sp@(8),d0
-        bne 1f
-        movel &1,d0
+    moveal sp@(4),a0
+    fmovemx a0@(64),fp2-fp7
+    movel sp@(8),d0
+    bne 1f
+    movel &1,d0
 1:
-        moveml a0@(20),d2-d7/a2-a6
-        moveal a0@(8),sp
-        movel a0@(12),sp@
-        rts
+    moveml a0@(20),d2-d7/a2-a6
+    moveal a0@(8),sp
+    movel a0@(12),sp@
+    rts
 #endif
diff --git a/apps/codecs/lib/tlsf/src/tlsf.c b/apps/codecs/lib/tlsf/src/tlsf.c
index 830184761a..6d15c3a3f6 100644
--- a/apps/codecs/lib/tlsf/src/tlsf.c
+++ b/apps/codecs/lib/tlsf/src/tlsf.c
@@ -56,19 +56,19 @@
 #include <string.h>
 
 #ifndef TLSF_USE_LOCKS
-#define TLSF_USE_LOCKS  (0)
+#define TLSF_USE_LOCKS  (0)
 #endif
 
 #ifndef TLSF_STATISTIC
-#define TLSF_STATISTIC  (0)
+#define TLSF_STATISTIC  (0)
 #endif
 
 #ifndef USE_MMAP
-#define USE_MMAP        (0)
+#define USE_MMAP    (0)
 #endif
 
 #ifndef USE_SBRK
-#define USE_SBRK        (0)
+#define USE_SBRK    (0)
 #endif
 
 
@@ -82,18 +82,18 @@
 #endif
 
 #if TLSF_STATISTIC
-#define TLSF_ADD_SIZE(tlsf, b) do {                                                                     \
-                tlsf->used_size += (b->size & BLOCK_SIZE) + BHDR_OVERHEAD;      \
-                if (tlsf->used_size > tlsf->max_size)                                           \
-                        tlsf->max_size = tlsf->used_size;                                               \
-                } while(0)
-
-#define TLSF_REMOVE_SIZE(tlsf, b) do {                                                          \
-                tlsf->used_size -= (b->size & BLOCK_SIZE) + BHDR_OVERHEAD;      \
-        } while(0)
+#define TLSF_ADD_SIZE(tlsf, b) do {                                 \
+        tlsf->used_size += (b->size & BLOCK_SIZE) + BHDR_OVERHEAD;  \
+        if (tlsf->used_size > tlsf->max_size)                       \
+            tlsf->max_size = tlsf->used_size;                       \
+        } while(0)
+
+#define TLSF_REMOVE_SIZE(tlsf, b) do {                              \
+        tlsf->used_size -= (b->size & BLOCK_SIZE) + BHDR_OVERHEAD;  \
+    } while(0)
 #else
-#define TLSF_ADD_SIZE(tlsf, b)       do{}while(0)
-#define TLSF_REMOVE_SIZE(tlsf, b)    do{}while(0)
+#define TLSF_ADD_SIZE(tlsf, b)       do{}while(0)
+#define TLSF_REMOVE_SIZE(tlsf, b)    do{}while(0)
 #endif
 
 #if USE_MMAP || USE_SBRK
@@ -125,37 +125,37 @@
 /* Unlike the preview TLSF versions, now they are statics */
 #define BLOCK_ALIGN (sizeof(void *) * 2)
 
-#define MAX_FLI         (30)
-#define MAX_LOG2_SLI    (5)
-#define MAX_SLI         (1 << MAX_LOG2_SLI)     /* MAX_SLI = 2^MAX_LOG2_SLI */
+#define MAX_FLI     (30)
+#define MAX_LOG2_SLI    (5)
+#define MAX_SLI     (1 << MAX_LOG2_SLI)     /* MAX_SLI = 2^MAX_LOG2_SLI */
 
-#define FLI_OFFSET      (6)     /* tlsf structure just will manage blocks bigger */
+#define FLI_OFFSET  (6)     /* tlsf structure just will manage blocks bigger */
 /* than 128 bytes */
-#define SMALL_BLOCK     (128)
-#define REAL_FLI        (MAX_FLI - FLI_OFFSET)
-#define MIN_BLOCK_SIZE  (sizeof (free_ptr_t))
-#define BHDR_OVERHEAD   (sizeof (bhdr_t) - MIN_BLOCK_SIZE)
-#define TLSF_SIGNATURE  (0x2A59FA59)
+#define SMALL_BLOCK (128)
+#define REAL_FLI    (MAX_FLI - FLI_OFFSET)
+#define MIN_BLOCK_SIZE  (sizeof (free_ptr_t))
+#define BHDR_OVERHEAD   (sizeof (bhdr_t) - MIN_BLOCK_SIZE)
+#define TLSF_SIGNATURE  (0x2A59FA59)
 
-#define PTR_MASK        (sizeof(void *) - 1)
-#define BLOCK_SIZE      (0xFFFFFFFF - PTR_MASK)
+#define PTR_MASK    (sizeof(void *) - 1)
+#define BLOCK_SIZE  (0xFFFFFFFF - PTR_MASK)
 
 #define GET_NEXT_BLOCK(_addr, _r) ((bhdr_t *) ((char *) (_addr) + (_r)))
-#define MEM_ALIGN                 ((BLOCK_ALIGN) - 1)
+#define MEM_ALIGN         ((BLOCK_ALIGN) - 1)
 #define ROUNDUP_SIZE(_r)          (((_r) + MEM_ALIGN) & ~MEM_ALIGN)
 #define ROUNDDOWN_SIZE(_r)        ((_r) & ~MEM_ALIGN)
 #define ROUNDUP(_x, _v)           ((((~(_x)) + 1) & ((_v)-1)) + (_x))
 
-#define BLOCK_STATE     (0x1)
-#define PREV_STATE      (0x2)
+#define BLOCK_STATE (0x1)
+#define PREV_STATE  (0x2)
 
 /* bit 0 of the block size */
-#define FREE_BLOCK      (0x1)
-#define USED_BLOCK      (0x0)
+#define FREE_BLOCK  (0x1)
+#define USED_BLOCK  (0x0)
 
 /* bit 1 of the block size */
-#define PREV_FREE       (0x2)
-#define PREV_USED       (0x0)
+#define PREV_FREE   (0x2)
+#define PREV_USED   (0x0)
 
 
 #define DEFAULT_AREA_SIZE (1024*10)
@@ -352,46 +352,46 @@ static __inline__ bhdr_t *FIND_SUITABLE_BLOCK(tlsf_t * _tlsf, int *_fl, int *_sl
 }
 
 
-#define EXTRACT_BLOCK_HDR(_b, _tlsf, _fl, _sl) do {                                     \
-                _tlsf -> matrix [_fl] [_sl] = _b -> ptr.free_ptr.next;          \
-                if (_tlsf -> matrix[_fl][_sl])                                                          \
-                        _tlsf -> matrix[_fl][_sl] -> ptr.free_ptr.prev = NULL;  \
-                else {                                                                                                          \
-                        clear_bit (_sl, &_tlsf -> sl_bitmap [_fl]);                             \
-                        if (!_tlsf -> sl_bitmap [_fl])                                                  \
-                                clear_bit (_fl, &_tlsf -> fl_bitmap);                           \
-                }                                                                                                                       \
-                _b -> ptr.free_ptr.prev =  NULL;                                \
-                _b -> ptr.free_ptr.next =  NULL;                                \
-        }while(0)
-
-
-#define EXTRACT_BLOCK(_b, _tlsf, _fl, _sl) do {                                                 \
-                if (_b -> ptr.free_ptr.next)                                                                    \
-                        _b -> ptr.free_ptr.next -> ptr.free_ptr.prev = _b -> ptr.free_ptr.prev; \
-                if (_b -> ptr.free_ptr.prev)                                                                    \
-                        _b -> ptr.free_ptr.prev -> ptr.free_ptr.next = _b -> ptr.free_ptr.next; \
-                if (_tlsf -> matrix [_fl][_sl] == _b) {                                                 \
-                        _tlsf -> matrix [_fl][_sl] = _b -> ptr.free_ptr.next;           \
-                        if (!_tlsf -> matrix [_fl][_sl]) {                                                      \
-                                clear_bit (_sl, &_tlsf -> sl_bitmap[_fl]);                              \
-                                if (!_tlsf -> sl_bitmap [_fl])                                                  \
-                                        clear_bit (_fl, &_tlsf -> fl_bitmap);                           \
-                        }                                                                                                                       \
-                }                                                                                                                               \
-                _b -> ptr.free_ptr.prev = NULL;                                 \
-                _b -> ptr.free_ptr.next = NULL;                                 \
-        } while(0)
-
-#define INSERT_BLOCK(_b, _tlsf, _fl, _sl) do {                                                  \
-                _b -> ptr.free_ptr.prev = NULL; \
-                _b -> ptr.free_ptr.next = _tlsf -> matrix [_fl][_sl]; \
-                if (_tlsf -> matrix [_fl][_sl])                                                                 \
-                        _tlsf -> matrix [_fl][_sl] -> ptr.free_ptr.prev = _b;           \
-                _tlsf -> matrix [_fl][_sl] = _b;                                                                \
-                set_bit (_sl, &_tlsf -> sl_bitmap [_fl]);                                               \
-                set_bit (_fl, &_tlsf -> fl_bitmap);                                                             \
-        } while(0)
+#define EXTRACT_BLOCK_HDR(_b, _tlsf, _fl, _sl) do {                 \
+        _tlsf -> matrix [_fl] [_sl] = _b -> ptr.free_ptr.next;      \
+        if (_tlsf -> matrix[_fl][_sl])                              \
+            _tlsf -> matrix[_fl][_sl] -> ptr.free_ptr.prev = NULL;  \
+        else {                                                      \
+            clear_bit (_sl, &_tlsf -> sl_bitmap [_fl]);             \
+            if (!_tlsf -> sl_bitmap [_fl])                          \
+                clear_bit (_fl, &_tlsf -> fl_bitmap);               \
+        }                                                           \
+        _b -> ptr.free_ptr.prev =  NULL;                \
+        _b -> ptr.free_ptr.next =  NULL;                \
+    }while(0)
+
+
+#define EXTRACT_BLOCK(_b, _tlsf, _fl, _sl) do {                         \
+        if (_b -> ptr.free_ptr.next)                                    \
+            _b -> ptr.free_ptr.next -> ptr.free_ptr.prev = _b -> ptr.free_ptr.prev; \
+        if (_b -> ptr.free_ptr.prev)                                    \
+            _b -> ptr.free_ptr.prev -> ptr.free_ptr.next = _b -> ptr.free_ptr.next; \
+        if (_tlsf -> matrix [_fl][_sl] == _b) {                         \
+            _tlsf -> matrix [_fl][_sl] = _b -> ptr.free_ptr.next;       \
+            if (!_tlsf -> matrix [_fl][_sl]) {                          \
+                clear_bit (_sl, &_tlsf -> sl_bitmap[_fl]);              \
+                if (!_tlsf -> sl_bitmap [_fl])                          \
+                    clear_bit (_fl, &_tlsf -> fl_bitmap);               \
+            }                                                           \
+        }                                                               \
+        _b -> ptr.free_ptr.prev = NULL;                 \
+        _b -> ptr.free_ptr.next = NULL;                 \
+    } while(0)
+
+#define INSERT_BLOCK(_b, _tlsf, _fl, _sl) do {                          \
+        _b -> ptr.free_ptr.prev = NULL; \
+        _b -> ptr.free_ptr.next = _tlsf -> matrix [_fl][_sl]; \
+        if (_tlsf -> matrix [_fl][_sl])                                 \
+            _tlsf -> matrix [_fl][_sl] -> ptr.free_ptr.prev = _b;       \
+        _tlsf -> matrix [_fl][_sl] = _b;                                \
+        set_bit (_sl, &_tlsf -> sl_bitmap [_fl]);                       \
+        set_bit (_fl, &_tlsf -> fl_bitmap);                             \
+    } while(0)
 
 #if USE_SBRK || USE_MMAP
 static __inline__ void *get_new_area(size_t * size) 
@@ -656,9 +656,9 @@ void *tlsf_realloc(void *ptr, size_t size)
     void *ret;
 
 #if USE_MMAP || USE_SBRK
-        if (!mp) {
-                return tlsf_malloc(size);
-        }
+    if (!mp) {
+        return tlsf_malloc(size);
+    }
 #endif
 
     TLSF_ACQUIRE_LOCK(&((tlsf_t *)mp)->lock);
@@ -813,7 +813,7 @@ void *realloc_ex(void *ptr, size_t new_size, void *mem_pool)
     new_size = (new_size < MIN_BLOCK_SIZE) ? MIN_BLOCK_SIZE : ROUNDUP_SIZE(new_size);
     tmp_size = (b->size & BLOCK_SIZE);
     if (new_size <= tmp_size) {
-        TLSF_REMOVE_SIZE(tlsf, b);
+    TLSF_REMOVE_SIZE(tlsf, b);
         if (next_b->size & FREE_BLOCK) {
             MAPPING_INSERT(next_b->size & BLOCK_SIZE, &fl, &sl);
             EXTRACT_BLOCK(next_b, tlsf, fl, sl);
@@ -833,12 +833,12 @@ void *realloc_ex(void *ptr, size_t new_size, void *mem_pool)
             INSERT_BLOCK(tmp_b, tlsf, fl, sl);
             b->size = new_size | (b->size & PREV_STATE);
         }
-        TLSF_ADD_SIZE(tlsf, b);
+    TLSF_ADD_SIZE(tlsf, b);
         return (void *) b->ptr.buffer;
     }
     if ((next_b->size & FREE_BLOCK)) {
         if (new_size <= (tmp_size + (next_b->size & BLOCK_SIZE))) {
-                        TLSF_REMOVE_SIZE(tlsf, b);
+            TLSF_REMOVE_SIZE(tlsf, b);
             MAPPING_INSERT(next_b->size & BLOCK_SIZE, &fl, &sl);
             EXTRACT_BLOCK(next_b, tlsf, fl, sl);
             b->size += (next_b->size & BLOCK_SIZE) + BHDR_OVERHEAD;
@@ -856,7 +856,7 @@ void *realloc_ex(void *ptr, size_t new_size, void *mem_pool)
                 INSERT_BLOCK(tmp_b, tlsf, fl, sl);
                 b->size = new_size | (b->size & PREV_STATE);
             }
-                        TLSF_ADD_SIZE(tlsf, b);
+            TLSF_ADD_SIZE(tlsf, b);
             return (void *) b->ptr.buffer;
         }
     }