X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/db7a8812e4f680703698ef3c800504863f6a88d8..11047b815e4628f874c983e757821ca6445e14ce:/src/xbt/dynar.c

diff --git a/src/xbt/dynar.c b/src/xbt/dynar.c
index 812ff7f096..0519a4a494 100644
--- a/src/xbt/dynar.c
+++ b/src/xbt/dynar.c
@@ -1,8 +1,7 @@
-/* $Id$ */
-
 /* a generic DYNamic ARray implementation.                                  */
 
-/* Copyright (c) 2003, 2004 Martin Quinson. All rights reserved.            */
+/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team.
+ * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
@@ -54,7 +53,8 @@ static XBT_INLINE void _check_inbound_idx(xbt_dynar_t dynar, int idx)
   }
 }
 
-static XBT_INLINE void _check_sloppy_inbound_idx(xbt_dynar_t dynar, int idx)
+static XBT_INLINE void _check_sloppy_inbound_idx(xbt_dynar_t dynar,
+                                                 int idx)
 {
   if (idx > dynar->used) {
     _dynar_unlock(dynar);
@@ -75,13 +75,13 @@ static XBT_INLINE void _check_populated_dynar(xbt_dynar_t dynar)
 static void _dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op);
 
 static XBT_INLINE
-  void _xbt_clear_mem(void *const ptr, const unsigned long length)
+    void _xbt_clear_mem(void *const ptr, const unsigned long length)
 {
   memset(ptr, 0, length);
 }
 
 static XBT_INLINE
-  void _xbt_dynar_expand(xbt_dynar_t const dynar, const unsigned long nb)
+    void _xbt_dynar_expand(xbt_dynar_t const dynar, const unsigned long nb)
 {
   const unsigned long old_size = dynar->size;
 
@@ -94,7 +94,7 @@ static XBT_INLINE
     const unsigned long used_length = used * elmsize;
 
     const unsigned long new_size =
-      nb > (2 * (old_size + 1)) ? nb : (2 * (old_size + 1));
+        nb > (2 * (old_size + 1)) ? nb : (2 * (old_size + 1));
     const unsigned long new_length = new_size * elmsize;
     char *const new_data = (char *) xbt_malloc0(elmsize * new_size);
 
@@ -114,7 +114,7 @@ static XBT_INLINE
 }
 
 static XBT_INLINE
-  void *_xbt_dynar_elm(const xbt_dynar_t dynar, const unsigned long idx)
+    void *_xbt_dynar_elm(const xbt_dynar_t dynar, const unsigned long idx)
 {
   char *const data = (char *) dynar->data;
   const unsigned long elmsize = dynar->elmsize;
@@ -123,7 +123,7 @@ static XBT_INLINE
 }
 
 static XBT_INLINE
-  void
+    void
 _xbt_dynar_get_elm(void *const dst,
                    const xbt_dynar_t dynar, const unsigned long idx)
 {
@@ -133,7 +133,7 @@ _xbt_dynar_get_elm(void *const dst,
 }
 
 static XBT_INLINE
-  void
+    void
 _xbt_dynar_put_elm(const xbt_dynar_t dynar,
                    const unsigned long idx, const void *const src)
 {
@@ -144,7 +144,7 @@ _xbt_dynar_put_elm(const xbt_dynar_t dynar,
 }
 
 static XBT_INLINE
-  void
+    void
 _xbt_dynar_remove_at(xbt_dynar_t const dynar,
                      const unsigned long idx, void *const object)
 {
@@ -174,7 +174,8 @@ _xbt_dynar_remove_at(xbt_dynar_t const dynar,
 
   if (nb_shift) {
     offset = nb_shift * dynar->elmsize;
-    memmove(_xbt_dynar_elm(dynar, idx), _xbt_dynar_elm(dynar, idx + 1), offset);
+    memmove(_xbt_dynar_elm(dynar, idx), _xbt_dynar_elm(dynar, idx + 1),
+            offset);
   }
 
   dynar->used--;
@@ -183,7 +184,8 @@ _xbt_dynar_remove_at(xbt_dynar_t const dynar,
 void xbt_dynar_dump(xbt_dynar_t dynar)
 {
   INFO5("Dynar dump: size=%lu; used=%lu; elmsize=%lu; data=%p; free_f=%p",
-        dynar->size, dynar->used, dynar->elmsize, dynar->data, dynar->free_f);
+        dynar->size, dynar->used, dynar->elmsize, dynar->data,
+        dynar->free_f);
 }
 
 /** @brief Constructor
@@ -217,7 +219,8 @@ xbt_dynar_new(const unsigned long elmsize, void_f_pvoid_t const free_f)
  *
  */
 xbt_dynar_t
-xbt_dynar_new_sync(const unsigned long elmsize, void_f_pvoid_t const free_f)
+xbt_dynar_new_sync(const unsigned long elmsize,
+                   void_f_pvoid_t const free_f)
 {
   xbt_dynar_t res = xbt_dynar_new(elmsize, free_f);
   res->mutex = xbt_mutex_init();
@@ -301,7 +304,7 @@ void xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots_wanted)
   size_wanted = dynar->used + empty_slots_wanted;
   if (size_wanted != dynar->size) {
     dynar->size = size_wanted;
-    dynar->data = xbt_realloc(dynar->data, sizeof(void *) * dynar->size);
+    dynar->data = xbt_realloc(dynar->data, dynar->elmsize * dynar->size);
   }
   _dynar_unlock(dynar);
 }
@@ -336,6 +339,16 @@ XBT_INLINE unsigned long xbt_dynar_length(const xbt_dynar_t dynar)
   return (dynar ? (unsigned long) dynar->used : (unsigned long) 0);
 }
 
+/**@brief check if a dynar is empty
+ *
+ *\param dynar the dynat we want to check
+ */
+
+XBT_INLINE int xbt_dynar_is_empty(const xbt_dynar_t dynar)
+{
+  return (xbt_dynar_length(dynar) == 0);
+}
+
 /** @brief Retrieve a copy of the Nth element of a dynar.
  *
  * \param dynar information dealer
@@ -363,7 +376,8 @@ xbt_dynar_get_cpy(const xbt_dynar_t dynar,
  * \warning The returned value is the actual content of the dynar.
  * Make a copy before fooling with it.
  */
-XBT_INLINE void *xbt_dynar_get_ptr(const xbt_dynar_t dynar, const unsigned long idx)
+XBT_INLINE void *xbt_dynar_get_ptr(const xbt_dynar_t dynar,
+                                   const unsigned long idx)
 {
 
   void *res;
@@ -402,7 +416,8 @@ _xbt_dynar_set(xbt_dynar_t dynar,
  *
  * If you want to free the previous content, use xbt_dynar_replace().
  */
-XBT_INLINE void xbt_dynar_set(xbt_dynar_t dynar, const int idx, const void *const src)
+XBT_INLINE void xbt_dynar_set(xbt_dynar_t dynar, const int idx,
+                              const void *const src)
 {
 
   _dynar_lock(dynar);
@@ -426,7 +441,6 @@ xbt_dynar_replace(xbt_dynar_t dynar,
 {
   _dynar_lock(dynar);
   _sanity_check_dynar(dynar);
-  _sanity_check_idx(idx);
 
   if (idx < dynar->used && dynar->free_f) {
     void *const old_object = _xbt_dynar_elm(dynar, idx);
@@ -444,11 +458,10 @@ static XBT_INLINE void *_xbt_dynar_insert_at_ptr(xbt_dynar_t const dynar,
   void *res;
   unsigned long old_used;
   unsigned long new_used;
-  unsigned long nb_shift;
+  long nb_shift;
 
   _sanity_check_dynar(dynar);
   _sanity_check_idx(idx);
-  _check_sloppy_inbound_idx(dynar, idx);
 
   old_used = dynar->used;
   new_used = old_used + 1;
@@ -457,9 +470,10 @@ static XBT_INLINE void *_xbt_dynar_insert_at_ptr(xbt_dynar_t const dynar,
 
   nb_shift = old_used - idx;
 
-  if (nb_shift)
+  if (nb_shift>0) {
     memmove(_xbt_dynar_elm(dynar, idx + 1),
             _xbt_dynar_elm(dynar, idx), nb_shift * dynar->elmsize);
+  }
 
   dynar->used = new_used;
   res = _xbt_dynar_elm(dynar, idx);
@@ -521,7 +535,7 @@ xbt_dynar_remove_at(xbt_dynar_t const dynar,
  *
  * Raises not_found_error if not found.
  */
-int xbt_dynar_search(xbt_dynar_t const dynar, void *const elem)
+unsigned int xbt_dynar_search(xbt_dynar_t const dynar, void *const elem)
 {
   unsigned long it;
 
@@ -533,7 +547,8 @@ int xbt_dynar_search(xbt_dynar_t const dynar, void *const elem)
     }
 
   _dynar_unlock(dynar);
-  THROW2(not_found_error, 0, "Element %p not part of dynar %p", elem, dynar);
+  THROW2(not_found_error, 0, "Element %p not part of dynar %p", elem,
+         dynar);
 }
 
 /** @brief Returns a boolean indicating whether the element is part of the dynar */
@@ -573,11 +588,13 @@ XBT_INLINE void *xbt_dynar_push_ptr(xbt_dynar_t const dynar)
 }
 
 /** @brief Add an element at the end of the dynar */
-XBT_INLINE void xbt_dynar_push(xbt_dynar_t const dynar, const void *const src)
+XBT_INLINE void xbt_dynar_push(xbt_dynar_t const dynar,
+                               const void *const src)
 {
   _dynar_lock(dynar);
   /* checks done in xbt_dynar_insert_at_ptr */
-  memcpy(_xbt_dynar_insert_at_ptr(dynar, dynar->used), src, dynar->elmsize);
+  memcpy(_xbt_dynar_insert_at_ptr(dynar, dynar->used), src,
+         dynar->elmsize);
   _dynar_unlock(dynar);
 }
 
@@ -614,7 +631,8 @@ XBT_INLINE void xbt_dynar_pop(xbt_dynar_t const dynar, void *const dst)
  *
  * This is less efficient than xbt_dynar_push()
  */
-XBT_INLINE void xbt_dynar_unshift(xbt_dynar_t const dynar, const void *const src)
+XBT_INLINE void xbt_dynar_unshift(xbt_dynar_t const dynar,
+                                  const void *const src)
 {
 
   /* sanity checks done by insert_at */
@@ -653,7 +671,8 @@ static void _dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op)
  * operation, so make sure your function don't call any function
  * from xbt_dynar_* on it, or you'll get a deadlock.
  */
-XBT_INLINE void xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op)
+XBT_INLINE void xbt_dynar_map(const xbt_dynar_t dynar,
+                              void_f_pvoid_t const op)
 {
 
   _sanity_check_dynar(dynar);
@@ -669,7 +688,8 @@ XBT_INLINE void xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op)
  *
  * This function can be used while traversing without problem.
  */
-XBT_INLINE void xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int *const cursor)
+XBT_INLINE void xbt_dynar_cursor_rm(xbt_dynar_t dynar,
+                                    unsigned int *const cursor)
 {
 
   _xbt_dynar_remove_at(dynar, (*cursor)--, NULL);
@@ -686,6 +706,61 @@ XBT_INLINE void xbt_dynar_cursor_unlock(xbt_dynar_t dynar)
   _dynar_unlock(dynar);
 }
 
+/** @brief Sorts a dynar according to the function <tt>compar_fn</tt>
+ *
+ * \param dynar the dynar to sort
+ * \param compar_fn comparison function of type (int (compar_fn*) (void*) (void*)).
+ *
+ * Remark: if the elements stored in the dynar are structures, the compar_fn
+ * function has to retrieve the field to sort first.
+ */
+XBT_INLINE void xbt_dynar_sort(xbt_dynar_t dynar,
+                               int_f_cpvoid_cpvoid_t compar_fn)
+{
+
+  _dynar_lock(dynar);
+
+  qsort(dynar->data, dynar->used, dynar->elmsize, compar_fn);
+
+  _dynar_unlock(dynar);
+}
+
+/*
+ * Return 0 if d1 and d2 are equal and 1 if not equal
+ */
+XBT_INLINE int xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2,
+					int(*compar)(const void *, const void *))
+{
+	int i ;
+	int size;
+	if((!d1) && (!d2)) return 0;
+	if((!d1) || (!d2))
+	{
+		DEBUG2("NULL dynar d1=%p d2=%p",d1,d2);
+		return 1;
+	}
+	if((d1->elmsize)!=(d2->elmsize))
+	{
+		DEBUG2("Size of elmsize d1=%ld d2=%ld",d1->elmsize,d2->elmsize);
+		return 1; // xbt_die
+	}
+	if(xbt_dynar_length(d1) != xbt_dynar_length(d2))
+	{
+		DEBUG2("Size of dynar d1=%ld d2=%ld",xbt_dynar_length(d1),xbt_dynar_length(d2));
+		return 1;
+	}
+
+	size = xbt_dynar_length(d1);
+	for(i=0;i<size;i++)
+	{
+		void *data1 = xbt_dynar_get_as(d1, i, void *);
+		void *data2 = xbt_dynar_get_as(d2, i, void *);
+		DEBUG3("link[%d] d1=%p d2=%p",i,data1,data2);
+		if(compar(data1,data2)) return 1;
+	}
+	return 0;
+}
+
 #ifdef SIMGRID_TEST
 
 #define NB_ELEM 5000
@@ -707,13 +782,13 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   xbt_dynar_foreach(d, cursor, i) {
     xbt_assert0(0, "Damnit, there is something in the empty dynar");
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add1
-    ("==== Push %d int, set them again 3 times, traverse them, shift them",
-     NB_ELEM);
+      ("==== Push %d int, set them again 3 times, traverse them, shift them",
+       NB_ELEM);
   /* Populate_ints [doxygen cruft] */
   /* 1. Populate the dynar */
   d = xbt_dynar_new(sizeof(int), NULL);
@@ -771,9 +846,9 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   }
 
   /* 5. Free the resources */
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add1("==== Unshift/pop %d int", NB_ELEM);
   d = xbt_dynar_new(sizeof(int), NULL);
@@ -788,25 +863,25 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
                      i, cpt);
     xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
 
   xbt_test_add1
-    ("==== Push %d int, insert 1000 int in the middle, shift everything",
-     NB_ELEM);
+      ("==== Push %d int, insert 1000 int in the middle, shift everything",
+       NB_ELEM);
   d = xbt_dynar_new(sizeof(int), NULL);
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     xbt_dynar_push_as(d, int, cpt);
     DEBUG2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
   }
-  for (cpt = 0; cpt < 1000; cpt++) {
-    xbt_dynar_insert_at_as(d, 2500, int, cpt);
+  for (cpt = 0; cpt < NB_ELEM/5; cpt++) {
+    xbt_dynar_insert_at_as(d, NB_ELEM/2, int, cpt);
     DEBUG2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
   }
 
-  for (cpt = 0; cpt < 2500; cpt++) {
+  for (cpt = 0; cpt < NB_ELEM/2; cpt++) {
     xbt_dynar_shift(d, &i);
     xbt_test_assert2(i == cpt,
                      "The retrieved value is not the same than the injected one at the begining (%d!=%d)",
@@ -825,11 +900,12 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
                      "The retrieved value is not the same than the injected one at the end (%d!=%d)",
                      i, cpt);
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
-  xbt_test_add1("==== Push %d int, remove 2000-4000. free the rest", NB_ELEM);
+  xbt_test_add1("==== Push %d int, remove 2000-4000. free the rest",
+                NB_ELEM);
   d = xbt_dynar_new(sizeof(int), NULL);
   for (cpt = 0; cpt < NB_ELEM; cpt++)
     xbt_dynar_push_as(d, int, cpt);
@@ -840,9 +916,83 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
                      "Remove a bad value. Got %d, expected %d", i, cpt);
     DEBUG2("remove %d, length=%lu", cpt, xbt_dynar_length(d));
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
+}
+
+/*******************************************************************************/
+/*******************************************************************************/
+/*******************************************************************************/
+XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dynar_remove functions")
+{
+  xbt_dynar_t d = xbt_dynar_new(sizeof(int), NULL);
+  unsigned int cursor;
+  int cpt;
+
+  xbt_test_add1("==== Insert %d int, traverse them, remove them",NB_ELEM);
+  /* Populate_ints [doxygen cruft] */
+  /* 1. Populate the dynar */
+  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+    xbt_dynar_insert_at(d, cpt, &cpt);
+    xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
+  }
+
+  /* 3. Traverse the dynar */
+  xbt_dynar_foreach(d, cursor, cpt) {
+    xbt_test_assert2(cursor == cpt,
+                     "The retrieved value is not the same than the injected one (%d!=%d)",
+                     cursor, cpt);
+  }
+  /* end_of_traversal */
+
+  /* Re-fill with the same values using set_as (and re-verify) */
+  for (cpt = 0; cpt < NB_ELEM; cpt++)
+    xbt_dynar_set_as(d, cpt, int, cpt);
+  xbt_dynar_foreach(d, cursor, cpt)
+    xbt_test_assert2(cursor == cpt,
+                     "The retrieved value is not the same than the injected one (%d!=%d)",
+                     cursor, cpt);
+
+  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+    int val;
+    xbt_dynar_remove_at(d,0,&val);
+    xbt_test_assert2(cpt == val,
+                     "The retrieved value is not the same than the injected one (%d!=%d)",
+                     cursor, cpt);
+  }
+  xbt_test_assert1(xbt_dynar_length(d) == 0,
+                   "There is still %lu elements in the dynar after removing everything",
+                   xbt_dynar_length(d));
+  xbt_dynar_free(&d);
+
+  /* ********************* */
+  xbt_test_add1("==== Insert %d int in reverse order, traverse them, remove them",NB_ELEM);
+  d = xbt_dynar_new(sizeof(int), NULL);
+  for (cpt = NB_ELEM-1; cpt >=0; cpt--) {
+    xbt_dynar_replace(d, cpt, &cpt);
+    xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
+  }
+
+  /* 3. Traverse the dynar */
+  xbt_dynar_foreach(d, cursor, cpt) {
+    xbt_test_assert2(cursor == cpt,
+                     "The retrieved value is not the same than the injected one (%d!=%d)",
+                     cursor, cpt);
+  }
+  /* end_of_traversal */
+
+  for (cpt =NB_ELEM-1; cpt >=0; cpt--) {
+    int val;
+    xbt_dynar_remove_at(d,xbt_dynar_length(d)-1,&val);
+    xbt_test_assert2(cpt == val,
+                     "The retrieved value is not the same than the injected one (%d!=%d)",
+                     cursor, cpt);
+  }
+  xbt_test_assert1(xbt_dynar_length(d) == 0,
+                   "There is still %lu elements in the dynar after removing everything",
+                   xbt_dynar_length(d));
+  xbt_dynar_free(&d);
 }
 
 /*******************************************************************************/
@@ -858,11 +1008,12 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   xbt_test_add0("==== Traverse the empty dynar");
   d = xbt_dynar_new(sizeof(int), NULL);
   xbt_dynar_foreach(d, cursor, cpt) {
-    xbt_test_assert0(FALSE, "Damnit, there is something in the empty dynar");
+    xbt_test_assert0(FALSE,
+                     "Damnit, there is something in the empty dynar");
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add0("==== Push/shift 5000 doubles");
   d = xbt_dynar_new(sizeof(double), NULL);
@@ -883,9 +1034,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
                      "The retrieved value is not the same than the injected one (%f!=%f)",
                      d1, d2);
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add0("==== Unshift/pop 5000 doubles");
   d = xbt_dynar_new(sizeof(double), NULL);
@@ -900,14 +1051,14 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
                      "The retrieved value is not the same than the injected one (%f!=%f)",
                      d1, d2);
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
 
 
   xbt_test_add0
-    ("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything");
+      ("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything");
   d = xbt_dynar_new(sizeof(double), NULL);
   for (cpt = 0; cpt < 5000; cpt++) {
     d1 = (double) cpt;
@@ -940,9 +1091,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
                      "The retrieved value is not the same than the injected one at the end (%f!=%f)",
                      d1, d2);
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
 
   xbt_test_add0("==== Push 5000 double, remove 2000-4000. free the rest");
@@ -957,9 +1108,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
     xbt_test_assert2(d1 == d2,
                      "Remove a bad value. Got %f, expected %f", d2, d1);
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 }
 
 
@@ -979,11 +1130,12 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   xbt_test_add0("==== Traverse the empty dynar");
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
   xbt_dynar_foreach(d, iter, s1) {
-    xbt_test_assert0(FALSE, "Damnit, there is something in the empty dynar");
+    xbt_test_assert0(FALSE,
+                     "Damnit, there is something in the empty dynar");
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add1("==== Push %d strings, set them again 3 times, shift them",
                 NB_ELEM);
@@ -1018,9 +1170,9 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
                      buf, s2);
     free(s2);
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
   xbt_test_add1("==== Unshift, traverse and pop %d strings", NB_ELEM);
   d = xbt_dynar_new(sizeof(char **), &xbt_free_ref);
@@ -1046,14 +1198,14 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
     free(s2);
   }
   /* 4. Free the resources */
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
 
   xbt_test_add2
-    ("==== Push %d strings, insert %d strings in the middle, shift everything",
-     NB_ELEM, NB_ELEM / 5);
+      ("==== Push %d strings, insert %d strings in the middle, shift everything",
+       NB_ELEM, NB_ELEM / 5);
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     sprintf(buf, "%d", cpt);
@@ -1090,13 +1242,13 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
                      buf, s2);
     free(s2);
   }
-  xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
-  xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
-                                 /* in your code is naturally the way to go outside a regression test */
+  xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
+  xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
+  /* in your code is naturally the way to go outside a regression test */
 
 
-  xbt_test_add3("==== Push %d strings, remove %d-%d. free the rest", NB_ELEM,
-                2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5));
+  xbt_test_add3("==== Push %d strings, remove %d-%d. free the rest",
+                NB_ELEM, 2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5));
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     sprintf(buf, "%d", cpt);
@@ -1150,7 +1302,7 @@ static void poper_f(void *a)
 }
 
 
-XBT_TEST_UNIT("synchronized int", test_dynar_sync_int,"Synchronized dynars of integers")
+XBT_TEST_UNIT("synchronized int", test_dynar_sync_int, "Synchronized dynars of integers")
 {
   /* Vars_decl [doxygen cruft] */
   xbt_dynar_t d;
@@ -1158,11 +1310,11 @@ XBT_TEST_UNIT("synchronized int", test_dynar_sync_int,"Synchronized dynars of in
 
   xbt_test_add0("==== Have a pusher and a popper on the dynar");
   d = xbt_dynar_new_sync(sizeof(int), NULL);
-  pusher = xbt_thread_create("pusher", pusher_f, d,0/*not joinable*/);
-  poper = xbt_thread_create("poper", poper_f, d,0/*not joinable*/);
+  pusher = xbt_thread_create("pusher", pusher_f, d, 0 /*not joinable */ );
+  poper = xbt_thread_create("poper", poper_f, d, 0 /*not joinable */ );
   xbt_thread_join(pusher);
   xbt_thread_join(poper);
   xbt_dynar_free(&d);
 }
 
-#endif /* SIMGRID_TEST */
+#endif                          /* SIMGRID_TEST */