X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c0bf08270464302ec402873aed75a459b08e0a8c..64561039d3dec9e50b4eaf1b78b3edef71898383:/src/xbt/mmalloc/mmcheck.c

diff --git a/src/xbt/mmalloc/mmcheck.c b/src/xbt/mmalloc/mmcheck.c
index 3467c1c0e0..46b48a6aec 100644
--- a/src/xbt/mmalloc/mmcheck.c
+++ b/src/xbt/mmalloc/mmcheck.c
@@ -16,12 +16,12 @@
    can specify an alternate function to be called instead (and probably will
    want to). */
 
-extern void abort (void);
+extern void abort(void);
 
 /* Arbitrary magical numbers.  */
 
-#define MAGICWORD	(unsigned int) 0xfedabeeb	/* Active chunk */
-#define MAGICWORDFREE	(unsigned int) 0xdeadbeef	/* Inactive chunk */
+#define MAGICWORD	(unsigned int) 0xfedabeeb       /* Active chunk */
+#define MAGICWORDFREE	(unsigned int) 0xdeadbeef       /* Inactive chunk */
 #define MAGICBYTE	((char) 0xd7)
 
 /* Each memory allocation is bounded by a header structure and a trailer
@@ -33,90 +33,82 @@ extern void abort (void);
    user's allocation area.  The magic word can be tested to detect
    buffer underruns and the magic byte can be tested to detect overruns. */
 
-struct hdr
-  {
-    size_t size;		/* Exact size requested by user.  */
-    unsigned long int magic;	/* Magic number to check header integrity.  */
-  };
+struct hdr {
+  size_t size;                  /* Exact size requested by user.  */
+  unsigned long int magic;      /* Magic number to check header integrity.  */
+};
 
-static void checkhdr (struct mdesc *mdp, const struct hdr *hdr);
-static void mfree_check (void* md, void* ptr);
-static void* mmalloc_check (void* md, size_t size);
-static void* mrealloc_check (void* md, void* ptr, size_t size);
+static void checkhdr(struct mdesc *mdp, const struct hdr *hdr);
+static void mfree_check(void *md, void *ptr);
+static void *mmalloc_check(void *md, size_t size);
+static void *mrealloc_check(void *md, void *ptr, size_t size);
 
 /* Check the magicword and magicbyte, and if either is corrupted then
    call the emergency abort function specified for the heap in use. */
 
-static void
-checkhdr (struct mdesc *mdp, const struct hdr *hdr)
+static void checkhdr(struct mdesc *mdp, const struct hdr *hdr)
 {
-  if (hdr -> magic != MAGICWORD ||
-      ((char *) &hdr[1])[hdr -> size] != MAGICBYTE)
-    {
-      (*mdp -> abortfunc)();
-    }
+  if (hdr->magic != MAGICWORD ||
+      ((char *) &hdr[1])[hdr->size] != MAGICBYTE) {
+    (*mdp->abortfunc) ();
+  }
 }
 
-static void
-mfree_check (void *md, void *ptr)
+static void mfree_check(void *md, void *ptr)
 {
   struct hdr *hdr = ((struct hdr *) ptr) - 1;
   struct mdesc *mdp;
 
-  mdp = MD_TO_MDP (md);
-  checkhdr (mdp, hdr);
-  hdr -> magic = MAGICWORDFREE;
-  mdp -> mfree_hook = NULL;
-  mfree (md, (void*)hdr);
-  mdp -> mfree_hook = mfree_check;
+  mdp = MD_TO_MDP(md);
+  checkhdr(mdp, hdr);
+  hdr->magic = MAGICWORDFREE;
+  mdp->mfree_hook = NULL;
+  mfree(md, (void *) hdr);
+  mdp->mfree_hook = mfree_check;
 }
 
-static void*
-mmalloc_check (void *md, size_t size)
+static void *mmalloc_check(void *md, size_t size)
 {
   struct hdr *hdr;
   struct mdesc *mdp;
   size_t nbytes;
 
-  mdp = MD_TO_MDP (md);
-  mdp -> mmalloc_hook = NULL;
-  nbytes = sizeof (struct hdr) + size + 1;
-  hdr = (struct hdr *) mmalloc (md, nbytes);
-  mdp -> mmalloc_hook = mmalloc_check;
-  if (hdr != NULL)
-    {
-      hdr -> size = size;
-      hdr -> magic = MAGICWORD;
-      hdr++;
-      *((char *) hdr + size) = MAGICBYTE;
-    }
-  return ((void*) hdr);
+  mdp = MD_TO_MDP(md);
+  mdp->mmalloc_hook = NULL;
+  nbytes = sizeof(struct hdr) + size + 1;
+  hdr = (struct hdr *) mmalloc(md, nbytes);
+  mdp->mmalloc_hook = mmalloc_check;
+  if (hdr != NULL) {
+    hdr->size = size;
+    hdr->magic = MAGICWORD;
+    hdr++;
+    *((char *) hdr + size) = MAGICBYTE;
+  }
+  return ((void *) hdr);
 }
 
-static void*
-mrealloc_check (void* md, void* ptr, size_t size)
+static void *mrealloc_check(void *md, void *ptr, size_t size)
 {
   struct hdr *hdr = ((struct hdr *) ptr) - 1;
   struct mdesc *mdp;
   size_t nbytes;
 
-  mdp = MD_TO_MDP (md);
-  checkhdr (mdp, hdr);
-  mdp -> mfree_hook = NULL;
-  mdp -> mmalloc_hook = NULL;
-  mdp -> mrealloc_hook = NULL;
-  nbytes = sizeof (struct hdr) + size + 1;
-  hdr = (struct hdr *) mrealloc (md, (void*) hdr, nbytes);
-  mdp -> mfree_hook = mfree_check;
-  mdp -> mmalloc_hook = mmalloc_check;
-  mdp -> mrealloc_hook = mrealloc_check;
-  if (hdr != NULL)
-    {
-      hdr -> size = size;
-      hdr++;
-      *((char *) hdr + size) = MAGICBYTE;
-    }
-  return ((void*) hdr);
+  mdp = MD_TO_MDP(md);
+  checkhdr(mdp, hdr);
+  mdp->mfree_hook = NULL;
+  mdp->mmalloc_hook = NULL;
+  mdp->mrealloc_hook = NULL;
+  nbytes = sizeof(struct hdr) + size + 1;
+  hdr = (struct hdr *) mrealloc(md, (void *) hdr, nbytes);
+  mdp->mfree_hook = mfree_check;
+  mdp->mmalloc_hook = mmalloc_check;
+  mdp->mrealloc_hook = mrealloc_check;
+  if (hdr != NULL) {
+    hdr->size = size;
+    hdr++;
+    *((char *) hdr + size) = MAGICBYTE;
+  }
+  return ((void *) hdr);
 }
 
 /* Turn on default checking for mmalloc/mrealloc/mfree, for the heap specified
@@ -149,37 +141,32 @@ mrealloc_check (void* md, void* ptr, size_t size)
 
    Returns non-zero if checking is successfully enabled, zero otherwise. */
 
-int
-mmcheckf (void *md, void (*func)(void), int force)
+int mmcheckf(void *md, void (*func) (void), int force)
 {
   struct mdesc *mdp;
   int rtnval;
 
-  mdp = MD_TO_MDP (md);
+  mdp = MD_TO_MDP(md);
 
   /* We can safely set or update the abort function at any time, regardless
      of whether or not we successfully do anything else. */
 
-  mdp -> abortfunc = (func != NULL ? func : abort);
+  mdp->abortfunc = (func != NULL ? func : abort);
 
   /* If we haven't yet called mmalloc the first time for this heap, or if we
      have hooks that were previously installed, then allow the hooks to be
      initialized or updated. */
 
   if (force ||
-      !(mdp -> flags & MMALLOC_INITIALIZED) ||
-      (mdp -> mfree_hook != NULL))
-    {
-      mdp -> mfree_hook = mfree_check;
-      mdp -> mmalloc_hook = mmalloc_check;
-      mdp -> mrealloc_hook = mrealloc_check;
-      mdp -> flags |= MMALLOC_MMCHECK_USED;
-      rtnval = 1;
-    }
-  else
-    {
-      rtnval = 0;
-    }
+      !(mdp->flags & MMALLOC_INITIALIZED) || (mdp->mfree_hook != NULL)) {
+    mdp->mfree_hook = mfree_check;
+    mdp->mmalloc_hook = mmalloc_check;
+    mdp->mrealloc_hook = mrealloc_check;
+    mdp->flags |= MMALLOC_MMCHECK_USED;
+    rtnval = 1;
+  } else {
+    rtnval = 0;
+  }
 
   return (rtnval);
 }
@@ -187,11 +174,10 @@ mmcheckf (void *md, void (*func)(void), int force)
 /* This routine is for backwards compatibility only, in case there are
    still callers to the original mmcheck function. */
 
-int
-mmcheck (void *md, void (*func) (void))
+int mmcheck(void *md, void (*func) (void))
 {
   int rtnval;
 
-  rtnval = mmcheckf (md, func, 0);
+  rtnval = mmcheckf(md, func, 0);
   return (rtnval);
 }