mm/: Coding style clean-up

Run tools/nxstyle against all C files under mm/ and correct coding standard violations.

mm/iob/iob_alloc_qentry.c

@@ -132,9 +132,9 @@ static FAR struct iob_qentry_s *iob_allocwait_qentry(void)
       ret = nxsem_wait_uninterruptible(&g_qentry_sem);
       if (ret >= 0)
         {
-          /* When we wake up from wait successfully, an I/O buffer chain container was
+          /* When we wake up from wait successfully, an I/O buffer chain
-           * freed and we hold a count for one IOB.  Unless somehting
+           * container was freed and we hold a count for one IOB.  Unless
-           * failed, we should have an IOB waiting for us in the
+           * something failed, we should have an IOB waiting for us in the
            * committed list.
            */
 

mm/iob/iob_copyin.c

@@ -250,5 +250,6 @@ int iob_trycopyin(FAR struct iob_s *iob, FAR const uint8_t *src,
                   unsigned int len, unsigned int offset, bool throttled,
                   enum iob_user_e consumerid)
 {
-  return iob_copyin_internal(iob, src, len, offset, throttled, false, consumerid);
+  return iob_copyin_internal(iob, src, len, offset, throttled, false,
+                             consumerid);
 }

mm/iob/iob_free.c

@@ -169,7 +169,8 @@ FAR struct iob_s *iob_free(FAR struct iob_s *iob,
 
 #if CONFIG_IOB_THROTTLE > 0
   nxsem_post(&g_throttle_sem);
-  DEBUGASSERT(g_throttle_sem.semcount <= (CONFIG_IOB_NBUFFERS - CONFIG_IOB_THROTTLE));
+  DEBUGASSERT(g_throttle_sem.semcount <=
+              (CONFIG_IOB_NBUFFERS - CONFIG_IOB_THROTTLE));
 #endif
 
 #ifdef CONFIG_IOB_NOTIFIER

mm/iob/iob_navail.c

@@ -78,6 +78,7 @@ int iob_navail(bool throttled)
           ret -= CONFIG_IOB_THROTTLE;
         }
 #endif
+
       if (ret < 0)
         {
           ret = 0;

mm/iob/iob_statistics.c

@@ -107,7 +107,6 @@ void iob_stats_onfree(enum iob_user_e producerid)
   /* Increment the global statistic as well */
 
   g_iobuserstats[IOBUSER_GLOBAL].totalproduced++;
-
 }
 
 /****************************************************************************

mm/iob/iob_test.c

@@ -115,6 +115,7 @@ int main(int argc, char **argv)
     {
       buffer1[i] = (uint8_t)(i & 0xff);
     }
+
   memset(buffer2, 0xff, 4096);
 
   iob_copyin(iob, buffer2, 47, 0, false, IOBUSER_UNITTEST);

mm/mm_gran/mm_granalloc.c

@@ -213,7 +213,8 @@ FAR void *gran_alloc(GRAN_HANDLE handle, size_t size)
                 }
 
               /* We know that the first free bit is now within the lower 4 bits
-               * of 'curr'.  Check if we have the allocation at this bit position.
+               * of 'curr'.  Check if we have the allocation at this bit
+               * position.
                */
 
               else if ((curr & mask) == 0)

mm/mm_gran/mm_grancritical.c

@@ -86,5 +86,4 @@ void gran_leave_critical(FAR struct gran_s *priv)
 #endif
 }
 
-
 #endif /* CONFIG_GRAN */

mm/mm_gran/mm_pgalloc.c

@@ -51,7 +51,9 @@
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/
+
 /* Configuration ************************************************************/
+
 /* CONFIG_MM_PGALLOC - Enable page allocator support
  * CONFIG_MM_PGSIZE - The page size.  Must be one of {1024, 2048,
  *   4096, 8192, or 16384}.  This is easily extensible, but only those

mm/mm_heap/mm_extend.c

@@ -112,7 +112,8 @@ void mm_extend(FAR struct mm_heap_s *heap, FAR void *mem, size_t size,
 
   /* Get and initialize the new terminal node in the heap */
 
-  newnode            = (FAR struct mm_allocnode_s *)(blockend - SIZEOF_MM_ALLOCNODE);
+  newnode            = (FAR struct mm_allocnode_s *)
+                       (blockend - SIZEOF_MM_ALLOCNODE);
   newnode->size      = SIZEOF_MM_ALLOCNODE;
   newnode->preceding = oldnode->size | MM_ALLOC_BIT;
 

mm/mm_heap/mm_initialize.c

@@ -114,11 +114,13 @@ void mm_addregion(FAR struct mm_heap_s *heap, FAR void *heapstart,
   heap->mm_heapstart[IDX]->size      = SIZEOF_MM_ALLOCNODE;
   heap->mm_heapstart[IDX]->preceding = MM_ALLOC_BIT;
 
-  node                        = (FAR struct mm_freenode_s *)(heapbase + SIZEOF_MM_ALLOCNODE);
+  node                               = (FAR struct mm_freenode_s *)
+                                       (heapbase + SIZEOF_MM_ALLOCNODE);
   node->size                         = heapsize - 2*SIZEOF_MM_ALLOCNODE;
   node->preceding                    = SIZEOF_MM_ALLOCNODE;
 
-  heap->mm_heapend[IDX]              = (FAR struct mm_allocnode_s *)(heapend - SIZEOF_MM_ALLOCNODE);
+  heap->mm_heapend[IDX]              = (FAR struct mm_allocnode_s *)
+                                       (heapend - SIZEOF_MM_ALLOCNODE);
   heap->mm_heapend[IDX]->size        = SIZEOF_MM_ALLOCNODE;
   heap->mm_heapend[IDX]->preceding   = node->size | MM_ALLOC_BIT;
 

mm/mm_heap/mm_malloc.c

@@ -188,7 +188,7 @@ FAR void *mm_malloc(FAR struct mm_heap_s *heap, size_t size)
 #ifdef CONFIG_MM_FILL_ALLOCATIONS
   if (ret)
     {
-       memset(ret, 0xAA, alignsize - SIZEOF_MM_ALLOCNODE);
+       memset(ret, 0xaa, alignsize - SIZEOF_MM_ALLOCNODE);
     }
 #endif
 

mm/mm_heap/mm_memalign.c

@@ -135,7 +135,8 @@ FAR void *mm_memalign(FAR struct mm_heap_s *heap, size_t alignment,
 
       DEBUGASSERT(alignedchunk >= rawchunk + 8);
 
-      newnode = (FAR struct mm_allocnode_s *)(alignedchunk - SIZEOF_MM_ALLOCNODE);
+      newnode = (FAR struct mm_allocnode_s *)
+        (alignedchunk - SIZEOF_MM_ALLOCNODE);
 
       /* Preceding size is full size of the new 'node,' including
        * SIZEOF_MM_ALLOCNODE
@@ -154,7 +155,8 @@ FAR void *mm_memalign(FAR struct mm_heap_s *heap, size_t alignment,
       if (precedingsize < SIZEOF_MM_FREENODE)
         {
           alignedchunk += alignment;
-          newnode       = (FAR struct mm_allocnode_s *)(alignedchunk - SIZEOF_MM_ALLOCNODE);
+          newnode       = (FAR struct mm_allocnode_s *)
+                          (alignedchunk - SIZEOF_MM_ALLOCNODE);
           precedingsize = (size_t)newnode - (size_t)node;
         }
 

mm/mm_heap/mm_realloc.c

@@ -108,7 +108,8 @@ FAR void *mm_realloc(FAR struct mm_heap_s *heap, FAR void *oldmem,
 
   /* Map the memory chunk into an allocated node structure */
 
-  oldnode = (FAR struct mm_allocnode_s *)((FAR char *)oldmem - SIZEOF_MM_ALLOCNODE);
+  oldnode = (FAR struct mm_allocnode_s *)
+    ((FAR char *)oldmem - SIZEOF_MM_ALLOCNODE);
 
   /* We need to hold the MM semaphore while we muck with the nodelist. */
 
@@ -139,13 +140,15 @@ FAR void *mm_realloc(FAR struct mm_heap_s *heap, FAR void *oldmem,
    * best decision
    */
 
-  next = (FAR struct mm_freenode_s *)((FAR char *)oldnode + oldnode->size);
+  next = (FAR struct mm_freenode_s *)
+    ((FAR char *)oldnode + oldnode->size);
   if ((next->preceding & MM_ALLOC_BIT) == 0)
     {
       nextsize = next->size;
     }
 
-  prev = (FAR struct mm_freenode_s *)((FAR char *)oldnode - (oldnode->preceding & ~MM_ALLOC_BIT));
+  prev = (FAR struct mm_freenode_s *)
+    ((FAR char *)oldnode - (oldnode->preceding & ~MM_ALLOC_BIT));
   if ((prev->preceding & MM_ALLOC_BIT) == 0)
     {
       prevsize = prev->size;
@@ -233,7 +236,8 @@ FAR void *mm_realloc(FAR struct mm_heap_s *heap, FAR void *oldmem,
 
           /* Extend the node into the previous free chunk */
 
-          newnode = (FAR struct mm_allocnode_s *)((FAR char *)oldnode - takeprev);
+          newnode = (FAR struct mm_allocnode_s *)
+            ((FAR char *)oldnode - takeprev);
 
           /* Did we consume the entire preceding chunk? */
 
@@ -246,7 +250,8 @@ FAR void *mm_realloc(FAR struct mm_heap_s *heap, FAR void *oldmem,
               prev->size        -= takeprev;
               newnode->size      = oldsize + takeprev;
               newnode->preceding = prev->size | MM_ALLOC_BIT;
-              next->preceding    = newnode->size | (next->preceding & MM_ALLOC_BIT);
+              next->preceding    = newnode->size |
+                                   (next->preceding & MM_ALLOC_BIT);
 
               /* Return the previous free node to the nodelist (with the new size) */
 
@@ -258,7 +263,8 @@ FAR void *mm_realloc(FAR struct mm_heap_s *heap, FAR void *oldmem,
 
               newnode->size      += oldsize;
               newnode->preceding |= MM_ALLOC_BIT;
-              next->preceding     = newnode->size | (next->preceding & MM_ALLOC_BIT);
+              next->preceding     = newnode->size |
+                                    (next->preceding & MM_ALLOC_BIT);
             }
 
           /* Now we want to return newnode */
@@ -301,7 +307,8 @@ FAR void *mm_realloc(FAR struct mm_heap_s *heap, FAR void *oldmem,
           /* Extend the node into the next chunk */
 
           oldnode->size = oldsize + takenext;
-          newnode       = (FAR struct mm_freenode_s *)((FAR char *)oldnode + oldnode->size);
+          newnode       = (FAR struct mm_freenode_s *)
+                            ((FAR char *)oldnode + oldnode->size);
 
           /* Did we consume the entire preceding chunk? */
 
@@ -313,7 +320,8 @@ FAR void *mm_realloc(FAR struct mm_heap_s *heap, FAR void *oldmem,
 
               newnode->size        = nextsize - takenext;
               newnode->preceding   = oldnode->size;
-              andbeyond->preceding = newnode->size | (andbeyond->preceding & MM_ALLOC_BIT);
+              andbeyond->preceding = newnode->size |
+                                     (andbeyond->preceding & MM_ALLOC_BIT);
 
               /* Add the new free node to the nodelist (with the new size) */
 
@@ -323,7 +331,8 @@ FAR void *mm_realloc(FAR struct mm_heap_s *heap, FAR void *oldmem,
             {
               /* Yes, just update some pointers. */
 
-              andbeyond->preceding = oldnode->size | (andbeyond->preceding & MM_ALLOC_BIT);
+              andbeyond->preceding = oldnode->size |
+                                     (andbeyond->preceding & MM_ALLOC_BIT);
             }
         }
 

mm/mm_heap/mm_shrinkchunk.c

@@ -106,7 +106,8 @@ void  mm_shrinkchunk(FAR struct mm_heap_s *heap,
       newnode->size        = next->size + node->size - size;
       newnode->preceding   = size;
       node->size           = size;
-      andbeyond->preceding = newnode->size | (andbeyond->preceding & MM_ALLOC_BIT);
+      andbeyond->preceding = newnode->size |
+                             (andbeyond->preceding & MM_ALLOC_BIT);
 
       /* Add the new node to the freenodelist */
 

mm/umm_heap/umm_globals.c

@@ -66,3 +66,7 @@
 
 struct mm_heap_s g_mmheap;
 #endif
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/