X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/87bf71ddfe2611ffedaabe6c3a9030957ae4a080..6a6157abf9619875297ff1d16c1e5c63c526d4c1:/src/gras/DataDesc/ddt_create.c

diff --git a/src/gras/DataDesc/ddt_create.c b/src/gras/DataDesc/ddt_create.c
index 311917683f..3d6e18aff8 100644
--- a/src/gras/DataDesc/ddt_create.c
+++ b/src/gras/DataDesc/ddt_create.c
@@ -34,15 +34,16 @@ static gras_datadesc_type_t gras_ddt_new(const char *name)
 {
   gras_datadesc_type_t res;
 
-  XBT_IN1("(%s)", name);
+  XBT_IN("(%s)", name);
   res = xbt_new0(s_gras_datadesc_type_t, 1);
 
   res->name = (char *) strdup(name);
   res->name_len = strlen(name);
   res->cycle = 0;
 
-  xbt_set_add(gras_datadesc_set_local, (xbt_set_elm_t) res, gras_ddt_freev);
-  XBT_OUT;
+  xbt_set_add(gras_datadesc_set_local, (xbt_set_elm_t) res,
+              gras_ddt_freev);
+  XBT_OUT();
   return res;
 }
 
@@ -71,8 +72,8 @@ gras_datadesc_type_t gras_datadesc_by_name(const char *name)
   volatile int found = 0;
   TRY {
     res =
-      (gras_datadesc_type_t) xbt_set_get_by_name(gras_datadesc_set_local,
-                                                 name);
+        (gras_datadesc_type_t) xbt_set_get_by_name(gras_datadesc_set_local,
+                                                   name);
     found = 1;
   } CATCH(e) {
     if (e.category != not_found_error)
@@ -95,7 +96,8 @@ gras_datadesc_type_t gras_datadesc_by_id(long int code)
   gras_datadesc_type_t res = NULL;
   TRY {
     res =
-      (gras_datadesc_type_t) xbt_set_get_by_id(gras_datadesc_set_local, code);
+        (gras_datadesc_type_t) xbt_set_get_by_id(gras_datadesc_set_local,
+                                                 code);
   } CATCH(e) {
     if (e.category != not_found_error)
       RETHROW;
@@ -117,7 +119,7 @@ gras_datadesc_scalar(const char *name,
   gras_datadesc_type_t res;
   long int arch;
 
-  XBT_IN;
+  XBT_IN("");
   res = gras_datadesc_by_name_or_null(name);
   if (res) {
     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_scalar,
@@ -126,7 +128,7 @@ gras_datadesc_scalar(const char *name,
                 "Redefinition of type %s does not match", name);
     xbt_assert1(res->category.scalar_data.type == type,
                 "Redefinition of type %s does not match", name);
-    VERB1("Discarding redefinition of %s", name);
+    XBT_VERB("Discarding redefinition of %s", name);
     return res;
   }
   res = gras_ddt_new(name);
@@ -135,13 +137,13 @@ gras_datadesc_scalar(const char *name,
     res->size[arch] = gras_arches[arch].sizeofs[type];
     res->alignment[arch] = gras_arches[arch].boundaries[type];
     res->aligned_size[arch] =
-      ddt_aligned(res->size[arch], res->alignment[arch]);
+        ddt_aligned(res->size[arch], res->alignment[arch]);
   }
 
   res->category_code = e_gras_datadesc_type_cat_scalar;
   res->category.scalar_data.encoding = encoding;
   res->category.scalar_data.type = type;
-  XBT_OUT;
+  XBT_OUT();
 
   return res;
 }
@@ -151,13 +153,13 @@ gras_datadesc_scalar(const char *name,
 void gras_dd_cat_field_free(void *f)
 {
   gras_dd_cat_field_t field = *(gras_dd_cat_field_t *) f;
-  XBT_IN;
+  XBT_IN("");
   if (field) {
     if (field->name)
       free(field->name);
     free(field);
   }
-  XBT_OUT;
+  XBT_OUT();
 }
 
 /** \brief Declare a new structure description */
@@ -167,13 +169,13 @@ gras_datadesc_type_t gras_datadesc_struct(const char *name)
   gras_datadesc_type_t res;
   long int arch;
 
-  XBT_IN1("(%s)", name);
+  XBT_IN("(%s)", name);
   res = gras_datadesc_by_name_or_null(name);
   if (res) {
     /* FIXME: Check that field redefinition matches */
     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_struct,
                 "Redefinition of type %s does not match", name);
-    VERB1("Discarding redefinition of %s", name);
+    XBT_DEBUG("Discarding redefinition of %s", name);
     return res;
   }
   res = gras_ddt_new(name);
@@ -185,16 +187,17 @@ gras_datadesc_type_t gras_datadesc_struct(const char *name)
   }
   res->category_code = e_gras_datadesc_type_cat_struct;
   res->category.struct_data.fields =
-    xbt_dynar_new(sizeof(gras_dd_cat_field_t), gras_dd_cat_field_free);
+      xbt_dynar_new(sizeof(gras_dd_cat_field_t), gras_dd_cat_field_free);
 
-  XBT_OUT;
+  XBT_OUT();
   return res;
 }
 
 /** \brief Append a new field to a structure description */
 void
 gras_datadesc_struct_append(gras_datadesc_type_t struct_type,
-                            const char *name, gras_datadesc_type_t field_type)
+                            const char *name,
+                            gras_datadesc_type_t field_type)
 {
 
   gras_dd_cat_field_t field;
@@ -203,11 +206,11 @@ gras_datadesc_struct_append(gras_datadesc_type_t struct_type,
   xbt_assert2(field_type,
               "Cannot add the field '%s' into struct '%s': its type is NULL",
               name, struct_type->name);
-  XBT_IN3("(%s %s.%s;)", field_type->name, struct_type->name, name);
+  XBT_IN("(%s %s.%s;)", field_type->name, struct_type->name, name);
   if (struct_type->category.struct_data.closed) {
-    VERB1
-      ("Ignoring request to add field to struct %s (closed. Redefinition?)",
-       struct_type->name);
+    XBT_DEBUG
+        ("Ignoring request to add field to struct %s (closed. Redefinition?)",
+         struct_type->name);
     return;
   }
 
@@ -218,8 +221,8 @@ gras_datadesc_struct_append(gras_datadesc_type_t struct_type,
   field = xbt_new(s_gras_dd_cat_field_t, 1);
   field->name = (char *) strdup(name);
 
-  DEBUG0("----------------");
-  DEBUG3("PRE s={size=%ld,align=%ld,asize=%ld}",
+  XBT_DEBUG("----------------");
+  XBT_DEBUG("PRE s={size=%ld,align=%ld,asize=%ld}",
          struct_type->size[GRAS_THISARCH],
          struct_type->alignment[GRAS_THISARCH],
          struct_type->aligned_size[GRAS_THISARCH]);
@@ -242,17 +245,18 @@ gras_datadesc_struct_append(gras_datadesc_type_t struct_type,
 
   xbt_dynar_push(struct_type->category.struct_data.fields, &field);
 
-  DEBUG3("Push a %s into %s at offset %ld.",
-         field_type->name, struct_type->name, field->offset[GRAS_THISARCH]);
-  DEBUG3("  f={size=%ld,align=%ld,asize=%ld}",
+  XBT_DEBUG("Push a %s into %s at offset %ld.",
+         field_type->name, struct_type->name,
+         field->offset[GRAS_THISARCH]);
+  XBT_DEBUG("  f={size=%ld,align=%ld,asize=%ld}",
          field_type->size[GRAS_THISARCH],
          field_type->alignment[GRAS_THISARCH],
          field_type->aligned_size[GRAS_THISARCH]);
-  DEBUG3("  s={size=%ld,align=%ld,asize=%ld}",
+  XBT_DEBUG("  s={size=%ld,align=%ld,asize=%ld}",
          struct_type->size[GRAS_THISARCH],
          struct_type->alignment[GRAS_THISARCH],
          struct_type->aligned_size[GRAS_THISARCH]);
-  XBT_OUT;
+  XBT_OUT();
 }
 
 /** \brief Close a structure description
@@ -262,12 +266,12 @@ gras_datadesc_struct_append(gras_datadesc_type_t struct_type,
 void gras_datadesc_struct_close(gras_datadesc_type_t struct_type)
 {
   int arch;
-  XBT_IN;
+  XBT_IN("");
   struct_type->category.struct_data.closed = 1;
   for (arch = 0; arch < gras_arch_count; arch++) {
     struct_type->size[arch] = struct_type->aligned_size[arch];
   }
-  DEBUG4("structure %s closed. size=%ld,align=%ld,asize=%ld",
+  XBT_DEBUG("structure %s closed. size=%ld,align=%ld,asize=%ld",
          struct_type->name,
          struct_type->size[GRAS_THISARCH],
          struct_type->alignment[GRAS_THISARCH],
@@ -308,7 +312,7 @@ gras_datadesc_union(const char *name, gras_datadesc_type_cb_int_t selector)
   gras_datadesc_type_t res;
   int arch;
 
-  XBT_IN1("(%s)", name);
+  XBT_IN("(%s)", name);
   xbt_assert0(selector,
               "Attempt to creat an union without field_count function");
 
@@ -319,7 +323,7 @@ gras_datadesc_union(const char *name, gras_datadesc_type_cb_int_t selector)
                 "Redefinition of type %s does not match", name);
     xbt_assert1(res->category.union_data.selector == selector,
                 "Redefinition of type %s does not match", name);
-    VERB1("Discarding redefinition of %s", name);
+    XBT_VERB("Discarding redefinition of %s", name);
     return res;
   }
 
@@ -333,7 +337,7 @@ gras_datadesc_union(const char *name, gras_datadesc_type_cb_int_t selector)
 
   res->category_code = e_gras_datadesc_type_cat_union;
   res->category.union_data.fields =
-    xbt_dynar_new(sizeof(gras_dd_cat_field_t *), gras_dd_cat_field_free);
+      xbt_dynar_new(sizeof(gras_dd_cat_field_t *), gras_dd_cat_field_free);
   res->category.union_data.selector = selector;
 
   return res;
@@ -348,13 +352,13 @@ void gras_datadesc_union_append(gras_datadesc_type_t union_type,
   gras_dd_cat_field_t field;
   int arch;
 
-  XBT_IN3("(%s %s.%s;)", field_type->name, union_type->name, name);
+  XBT_IN("(%s %s.%s;)", field_type->name, union_type->name, name);
   xbt_assert1(field_type->size[GRAS_THISARCH] >= 0,
               "Cannot add a dynamically sized field in union %s",
               union_type->name);
 
   if (union_type->category.union_data.closed) {
-    VERB1("Ignoring request to add field to union %s (closed)",
+    XBT_VERB("Ignoring request to add field to union %s (closed)",
           union_type->name);
     return;
   }
@@ -373,7 +377,8 @@ void gras_datadesc_union_append(gras_datadesc_type_t union_type,
     union_type->alignment[arch] = max(union_type->alignment[arch],
                                       field_type->alignment[arch]);
     union_type->aligned_size[arch] = ddt_aligned(union_type->size[arch],
-                                                 union_type->alignment[arch]);
+                                                 union_type->alignment
+                                                 [arch]);
   }
 }
 
@@ -409,10 +414,11 @@ gras_datadesc_ref(const char *name, gras_datadesc_type_t referenced_type)
 {
 
   gras_datadesc_type_t res;
-  gras_datadesc_type_t pointer_type = gras_datadesc_by_name("data pointer");
+  gras_datadesc_type_t pointer_type =
+      gras_datadesc_by_name("data pointer");
   int arch;
 
-  XBT_IN1("(%s)", name);
+  XBT_IN("(%s)", name);
   res = gras_datadesc_by_name_or_null(name);
   if (res) {
     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_ref,
@@ -421,7 +427,7 @@ gras_datadesc_ref(const char *name, gras_datadesc_type_t referenced_type)
                 "Redefinition of %s does not match", name);
     xbt_assert1(res->category.ref_data.selector == NULL,
                 "Redefinition of %s does not match", name);
-    VERB1("Discarding redefinition of %s", name);
+    XBT_DEBUG("Discarding redefinition of %s", name);
     return res;
   }
 
@@ -449,14 +455,16 @@ gras_datadesc_ref(const char *name, gras_datadesc_type_t referenced_type)
  * callback and expects it to return the type description to use.
  */
 gras_datadesc_type_t
-gras_datadesc_ref_generic(const char *name, gras_datadesc_selector_t selector)
+gras_datadesc_ref_generic(const char *name,
+                          gras_datadesc_selector_t selector)
 {
 
   gras_datadesc_type_t res;
-  gras_datadesc_type_t pointer_type = gras_datadesc_by_name("data pointer");
+  gras_datadesc_type_t pointer_type =
+      gras_datadesc_by_name("data pointer");
   int arch;
 
-  XBT_IN1("(%s)", name);
+  XBT_IN("(%s)", name);
   res = gras_datadesc_by_name_or_null(name);
 
   if (res) {
@@ -466,7 +474,7 @@ gras_datadesc_ref_generic(const char *name, gras_datadesc_selector_t selector)
                 "Redefinition of type %s does not match", name);
     xbt_assert1(res->category.ref_data.selector == selector,
                 "Redefinition of type %s does not match", name);
-    VERB1("Discarding redefinition of %s", name);
+    XBT_VERB("Discarding redefinition of %s", name);
     return res;
   }
   res = gras_ddt_new(name);
@@ -497,15 +505,16 @@ gras_datadesc_array_fixed(const char *name,
   gras_datadesc_type_t res;
   int arch;
 
-  XBT_IN1("(%s)", name);
+  XBT_IN("(%s)", name);
   res = gras_datadesc_by_name_or_null(name);
   if (res) {
     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_array,
                 "Redefinition of type %s does not match", name);
 
     if (res->category.array_data.type != element_type) {
-      ERROR1("Redefinition of type %s does not match: array elements differ",
-             name);
+      XBT_ERROR
+          ("Redefinition of type %s does not match: array elements differ",
+           name);
       gras_datadesc_type_dump(res->category.array_data.type);
       gras_datadesc_type_dump(element_type);
     }
@@ -514,7 +523,7 @@ gras_datadesc_array_fixed(const char *name,
                 "Redefinition of type %s does not match", name);
     xbt_assert1(res->category.array_data.dynamic_size == NULL,
                 "Redefinition of type %s does not match", name);
-    VERB1("Discarding redefinition of %s", name);
+    XBT_VERB("Discarding redefinition of %s", name);
 
     return res;
   }
@@ -548,7 +557,7 @@ gras_datadesc_type_t gras_datadesc_array_dyn(const char *name,
   gras_datadesc_type_t res;
   int arch;
 
-  XBT_IN1("(%s)", name);
+  XBT_IN("(%s)", name);
   xbt_assert1(dynamic_size,
               "'%s' is a dynamic array without size discriminant", name);
 
@@ -562,7 +571,7 @@ gras_datadesc_type_t gras_datadesc_array_dyn(const char *name,
                 "Redefinition of type %s does not match", name);
     xbt_assert1(res->category.array_data.dynamic_size == dynamic_size,
                 "Redefinition of type %s does not match", name);
-    VERB1("Discarding redefinition of %s", name);
+    XBT_VERB("Discarding redefinition of %s", name);
 
     return res;
   }
@@ -609,8 +618,8 @@ gras_datadesc_type_t gras_datadesc_array_dyn(const char *name,
 gras_datadesc_type_t
 gras_datadesc_ref_pop_arr(gras_datadesc_type_t element_type)
 {
-  int cpt=0;
-  gras_datadesc_type_t res,ddt2;
+  int cpt = 0;
+  gras_datadesc_type_t res, ddt2;
   char *name = (char *) xbt_malloc(strlen(element_type->name) + 4);
 
   sprintf(name, "%s[]", element_type->name);
@@ -619,19 +628,19 @@ gras_datadesc_ref_pop_arr(gras_datadesc_type_t element_type)
 
   while (ddt2) {
     free(name);
-    name=bprintf("%s[]_%d",element_type->name,cpt++);
-    ddt2=gras_datadesc_by_name_or_null(name);
+    name = bprintf("%s[]_%d", element_type->name, cpt++);
+    ddt2 = gras_datadesc_by_name_or_null(name);
   }
 
   res = gras_datadesc_array_dyn(name, element_type, gras_datadesc_cb_pop);
 
   sprintf(name, "%s[]*", element_type->name);
-  cpt=0;
+  cpt = 0;
   ddt2 = gras_datadesc_by_name_or_null(name);
   while (ddt2) {
     free(name);
-    name=bprintf("%s[]*_%d",element_type->name,cpt++);
-    ddt2=gras_datadesc_by_name_or_null(name);
+    name = bprintf("%s[]*_%d", element_type->name, cpt++);
+    ddt2 = gras_datadesc_by_name_or_null(name);
   }
 
   res = gras_datadesc_ref(name, res);
@@ -662,7 +671,7 @@ static void gras_datadesc_dynar_cb(gras_datadesc_type_t typedesc,
   subtype = subtype->category.ref_data.type;
   subtype = subtype->category.array_data.type;
 
-  DEBUG1("subtype is %s", subtype->name);
+  XBT_DEBUG("subtype is %s", subtype->name);
 
   dynar->elmsize = subtype->size[GRAS_THISARCH];
   dynar->size = dynar->used;
@@ -685,7 +694,7 @@ gras_datadesc_dynar(gras_datadesc_type_t elm_t, void_f_pvoid_t free_func)
   char *buffname;
   gras_datadesc_type_t res;
 
-  asprintf(&buffname, "s_xbt_dynar_of_%s", elm_t->name);
+  buffname = bprintf("s_xbt_dynar_of_%s", elm_t->name);
 
   res = gras_datadesc_struct(buffname);
 
@@ -698,7 +707,8 @@ gras_datadesc_dynar(gras_datadesc_type_t elm_t, void_f_pvoid_t free_func)
   gras_datadesc_struct_append(res, "elmsize",
                               gras_datadesc_by_name("unsigned long int"));
 
-  gras_datadesc_struct_append(res, "data", gras_datadesc_ref_pop_arr(elm_t));
+  gras_datadesc_struct_append(res, "data",
+                              gras_datadesc_ref_pop_arr(elm_t));
 
   gras_datadesc_struct_append(res, "free_f",
                               gras_datadesc_by_name("function pointer"));
@@ -714,7 +724,7 @@ gras_datadesc_dynar(gras_datadesc_type_t elm_t, void_f_pvoid_t free_func)
 
   /* build a ref to it */
   free(buffname);
-  asprintf(&buffname, "xbt_dynar_of_%s", elm_t->name);
+  buffname = bprintf("xbt_dynar_of_%s", elm_t->name);
   res = gras_datadesc_ref(buffname, res);
   free(buffname);
   return res;
@@ -736,18 +746,19 @@ static void gras_datadesc_matrix_cb(gras_datadesc_type_t typedesc,
   subtype = subtype->category.ref_data.type;
   subtype = subtype->category.array_data.type;
 
-  DEBUG1("subtype is %s", subtype->name);
+  XBT_DEBUG("subtype is %s", subtype->name);
 
   matrix->elmsize = subtype->size[GRAS_THISARCH];
 }
 
 gras_datadesc_type_t
-gras_datadesc_matrix(gras_datadesc_type_t elm_t, void_f_pvoid_t const free_f)
+gras_datadesc_matrix(gras_datadesc_type_t elm_t,
+                     void_f_pvoid_t const free_f)
 {
   char *buffname;
   gras_datadesc_type_t res;
 
-  asprintf(&buffname, "s_xbt_matrix_t(%s)", elm_t->name);
+  buffname = bprintf("s_xbt_matrix_t(%s)", elm_t->name);
   res = gras_datadesc_struct(buffname);
 
   gras_datadesc_struct_append(res, "lines",
@@ -758,7 +769,8 @@ gras_datadesc_matrix(gras_datadesc_type_t elm_t, void_f_pvoid_t const free_f)
   gras_datadesc_struct_append(res, "elmsize",
                               gras_datadesc_by_name("unsigned long int"));
 
-  gras_datadesc_struct_append(res, "data", gras_datadesc_ref_pop_arr(elm_t));
+  gras_datadesc_struct_append(res, "data",
+                              gras_datadesc_ref_pop_arr(elm_t));
   gras_datadesc_struct_append(res, "free_f",
                               gras_datadesc_by_name("function pointer"));
   gras_datadesc_struct_close(res);
@@ -771,7 +783,7 @@ gras_datadesc_matrix(gras_datadesc_type_t elm_t, void_f_pvoid_t const free_f)
 
   /* build a ref to it */
   free(buffname);
-  asprintf(&buffname, "xbt_matrix_t(%s)", elm_t->name);
+  buffname = bprintf("xbt_matrix_t(%s)", elm_t->name);
   res = gras_datadesc_ref(buffname, res);
   free(buffname);
   return res;
@@ -779,7 +791,8 @@ gras_datadesc_matrix(gras_datadesc_type_t elm_t, void_f_pvoid_t const free_f)
 
 gras_datadesc_type_t
 gras_datadesc_import_nws(const char *name,
-                         const DataDescriptor * desc, unsigned long howmany)
+                         const DataDescriptor * desc,
+                         unsigned long howmany)
 {
   THROW_UNIMPLEMENTED;
 }
@@ -820,7 +833,7 @@ gras_dd_find_field(gras_datadesc_type_t type, const char *field_name)
   } else if (type->category_code == e_gras_datadesc_type_cat_struct) {
     field_array = type->category.struct_data.fields;
   } else {
-    ERROR2("%s (%p) is not a struct nor an union. There is no field.",
+    XBT_ERROR("%s (%p) is not a struct nor an union. There is no field.",
            type->name, (void *) type);
     xbt_abort();
   }
@@ -829,7 +842,7 @@ gras_dd_find_field(gras_datadesc_type_t type, const char *field_name)
       return field;
     }
   }
-  ERROR2("No field named '%s' in '%s'", field_name, type->name);
+  XBT_ERROR("No field named '%s' in '%s'", field_name, type->name);
   xbt_abort();
 
 }
@@ -860,7 +873,7 @@ void gras_datadesc_cb_field_push(gras_datadesc_type_t type,
   gras_dd_cat_field_t field = gras_dd_find_field(type, field_name);
   gras_datadesc_type_t sub_type = field->type;
 
-  DEBUG3("add a PUSHy cb to '%s' field (type '%s') of '%s'",
+  XBT_DEBUG("add a PUSHy cb to '%s' field (type '%s') of '%s'",
          field_name, sub_type->name, type->name);
   if (!strcmp("int", sub_type->name)) {
     field->send = gras_datadesc_cb_push_int;
@@ -871,9 +884,9 @@ void gras_datadesc_cb_field_push(gras_datadesc_type_t type,
   } else if (!strcmp("unsigned long int", sub_type->name)) {
     field->send = gras_datadesc_cb_push_ulint;
   } else {
-    ERROR1
-      ("Field %s is not an int, unsigned int, long int neither unsigned long int",
-       sub_type->name);
+    XBT_ERROR
+        ("Field %s is not an int, unsigned int, long int neither unsigned long int",
+         sub_type->name);
     xbt_abort();
   }
 }
@@ -893,7 +906,7 @@ void gras_datadesc_cb_field_push_multiplier(gras_datadesc_type_t type,
   gras_dd_cat_field_t field = gras_dd_find_field(type, field_name);
   gras_datadesc_type_t sub_type = field->type;
 
-  DEBUG3("add a MPUSHy cb to '%s' field (type '%s') of '%s'",
+  XBT_DEBUG("add a MPUSHy cb to '%s' field (type '%s') of '%s'",
          field_name, sub_type->name, type->name);
   if (!strcmp("int", sub_type->name)) {
     field->send = gras_datadesc_cb_push_int_mult;
@@ -904,9 +917,9 @@ void gras_datadesc_cb_field_push_multiplier(gras_datadesc_type_t type,
   } else if (!strcmp("unsigned long int", sub_type->name)) {
     field->send = gras_datadesc_cb_push_ulint_mult;
   } else {
-    ERROR1
-      ("Field %s is not an int, unsigned int, long int neither unsigned long int",
-       sub_type->name);
+    XBT_ERROR
+        ("Field %s is not an int, unsigned int, long int neither unsigned long int",
+         sub_type->name);
     xbt_abort();
   }
 }
@@ -930,7 +943,7 @@ void gras_datadesc_cb_field_recv(gras_datadesc_type_t type,
 void gras_datadesc_free(gras_datadesc_type_t * type)
 {
 
-  DEBUG1("Let's free ddt %s", (*type)->name);
+  XBT_DEBUG("Let's free ddt %s", (*type)->name);
 
   switch ((*type)->category_code) {
   case e_gras_datadesc_type_cat_scalar:
@@ -976,57 +989,57 @@ int gras_datadesc_type_cmp(const gras_datadesc_type_t d1,
     return 0;                   /* easy optimization */
 
   if (!d1 && d2) {
-    DEBUG0("ddt_cmp: !d1 && d2 => 1");
+    XBT_DEBUG("ddt_cmp: !d1 && d2 => 1");
     return 1;
   }
   if (!d1 && !d2) {
-    DEBUG0("ddt_cmp: !d1 && !d2 => 0");
+    XBT_DEBUG("ddt_cmp: !d1 && !d2 => 0");
     return 0;
   }
   if (d1 && !d2) {
-    DEBUG0("ddt_cmp: d1 && !d2 => -1");
+    XBT_DEBUG("ddt_cmp: d1 && !d2 => -1");
     return -1;
   }
 
   for (cpt = 0; cpt < gras_arch_count; cpt++) {
     if (d1->size[cpt] != d2->size[cpt]) {
-      DEBUG5("ddt_cmp: %s->size=%ld  !=  %s->size=%ld (on %s)",
+      XBT_DEBUG("ddt_cmp: %s->size=%ld  !=  %s->size=%ld (on %s)",
              d1->name, d1->size[cpt], d2->name, d2->size[cpt],
              gras_arches[cpt].name);
       return d1->size[cpt] > d2->size[cpt] ? 1 : -1;
     }
 
     if (d1->alignment[cpt] != d2->alignment[cpt]) {
-      DEBUG5("ddt_cmp: %s->alignment=%ld  !=  %s->alignment=%ld (on %s)",
+      XBT_DEBUG("ddt_cmp: %s->alignment=%ld  !=  %s->alignment=%ld (on %s)",
              d1->name, d1->alignment[cpt], d2->name, d2->alignment[cpt],
              gras_arches[cpt].name);
       return d1->alignment[cpt] > d2->alignment[cpt] ? 1 : -1;
     }
 
     if (d1->aligned_size[cpt] != d2->aligned_size[cpt]) {
-      DEBUG5
-        ("ddt_cmp: %s->aligned_size=%ld  !=  %s->aligned_size=%ld (on %s)",
-         d1->name, d1->aligned_size[cpt], d2->name, d2->aligned_size[cpt],
-         gras_arches[cpt].name);
+      XBT_DEBUG
+          ("ddt_cmp: %s->aligned_size=%ld  !=  %s->aligned_size=%ld (on %s)",
+           d1->name, d1->aligned_size[cpt], d2->name,
+           d2->aligned_size[cpt], gras_arches[cpt].name);
       return d1->aligned_size[cpt] > d2->aligned_size[cpt] ? 1 : -1;
     }
   }
 
   if (d1->category_code != d2->category_code) {
-    DEBUG4("ddt_cmp: %s->cat=%s  !=  %s->cat=%s",
+    XBT_DEBUG("ddt_cmp: %s->cat=%s  !=  %s->cat=%s",
            d1->name, gras_datadesc_cat_names[d1->category_code],
            d2->name, gras_datadesc_cat_names[d2->category_code]);
     return d1->category_code > d2->category_code ? 1 : -1;
   }
 
   if (d1->send != d2->send) {
-    DEBUG4("ddt_cmp: %s->send=%p  !=  %s->send=%p",
+    XBT_DEBUG("ddt_cmp: %s->send=%p  !=  %s->send=%p",
            d1->name, (void *) d1->send, d2->name, (void *) d2->send);
     return 1;                   /* ISO C forbids ordered comparisons of pointers to functions */
   }
 
   if (d1->recv != d2->recv) {
-    DEBUG4("ddt_cmp: %s->recv=%p  !=  %s->recv=%p",
+    XBT_DEBUG("ddt_cmp: %s->recv=%p  !=  %s->recv=%p",
            d1->name, (void *) d1->recv, d2->name, (void *) d2->recv);
     return 1;                   /* ISO C forbids ordered comparisons of pointers to functions */
   }
@@ -1036,29 +1049,29 @@ int gras_datadesc_type_cmp(const gras_datadesc_type_t d1,
     if (d1->category.scalar_data.encoding !=
         d2->category.scalar_data.encoding)
       return d1->category.scalar_data.encoding >
-        d2->category.scalar_data.encoding ? 1 : -1;
+          d2->category.scalar_data.encoding ? 1 : -1;
     break;
 
   case e_gras_datadesc_type_cat_struct:
     if (xbt_dynar_length(d1->category.struct_data.fields) !=
         xbt_dynar_length(d2->category.struct_data.fields)) {
-      DEBUG4("ddt_cmp: %s (having %lu fields) !=  %s (having %lu fields)",
+      XBT_DEBUG("ddt_cmp: %s (having %lu fields) !=  %s (having %lu fields)",
              d1->name, xbt_dynar_length(d1->category.struct_data.fields),
              d2->name, xbt_dynar_length(d2->category.struct_data.fields));
 
       return xbt_dynar_length(d1->category.struct_data.fields) >
-        xbt_dynar_length(d2->category.struct_data.fields) ? 1 : -1;
+          xbt_dynar_length(d2->category.struct_data.fields) ? 1 : -1;
     }
     xbt_dynar_foreach(d1->category.struct_data.fields, cpt, field1) {
 
       field2 =
-        xbt_dynar_get_as(d2->category.struct_data.fields, cpt,
-                         gras_dd_cat_field_t);
+          xbt_dynar_get_as(d2->category.struct_data.fields, cpt,
+                           gras_dd_cat_field_t);
       field_desc_1 = field1->type;
       field_desc_2 = field2->type;
       ret = gras_datadesc_type_cmp(field_desc_1, field_desc_2);
       if (ret) {
-        DEBUG6("%s->field[%d]=%s != %s->field[%d]=%s",
+        XBT_DEBUG("%s->field[%d]=%s != %s->field[%d]=%s",
                d1->name, cpt, field1->name, d2->name, cpt, field2->name);
         return ret;
       }
@@ -1067,19 +1080,20 @@ int gras_datadesc_type_cmp(const gras_datadesc_type_t d1,
     break;
 
   case e_gras_datadesc_type_cat_union:
-    if (d1->category.union_data.selector != d2->category.union_data.selector)
+    if (d1->category.union_data.selector !=
+        d2->category.union_data.selector)
       return 1;                 /* ISO C forbids ordered comparisons of pointers to functions */
 
     if (xbt_dynar_length(d1->category.union_data.fields) !=
         xbt_dynar_length(d2->category.union_data.fields))
       return xbt_dynar_length(d1->category.union_data.fields) >
-        xbt_dynar_length(d2->category.union_data.fields) ? 1 : -1;
+          xbt_dynar_length(d2->category.union_data.fields) ? 1 : -1;
 
     xbt_dynar_foreach(d1->category.union_data.fields, cpt, field1) {
 
       field2 =
-        xbt_dynar_get_as(d2->category.union_data.fields, cpt,
-                         gras_dd_cat_field_t);
+          xbt_dynar_get_as(d2->category.union_data.fields, cpt,
+                           gras_dd_cat_field_t);
       field_desc_1 = field1->type;
       field_desc_2 = field2->type;
       ret = gras_datadesc_type_cmp(field_desc_1, field_desc_2);
@@ -1095,18 +1109,19 @@ int gras_datadesc_type_cmp(const gras_datadesc_type_t d1,
       return 1;                 /* ISO C forbids ordered comparisons of pointers to functions */
 
     if (d1->category.ref_data.type != d2->category.ref_data.type)
-      return d1->category.ref_data.type > d2->category.ref_data.type ? 1 : -1;
+      return d1->category.ref_data.type >
+          d2->category.ref_data.type ? 1 : -1;
     break;
 
   case e_gras_datadesc_type_cat_array:
     if (d1->category.array_data.type != d2->category.array_data.type)
       return d1->category.array_data.type >
-        d2->category.array_data.type ? 1 : -1;
+          d2->category.array_data.type ? 1 : -1;
 
     if (d1->category.array_data.fixed_size !=
         d2->category.array_data.fixed_size)
       return d1->category.array_data.fixed_size >
-        d2->category.array_data.fixed_size ? 1 : -1;
+          d2->category.array_data.fixed_size ? 1 : -1;
 
     if (d1->category.array_data.dynamic_size !=
         d2->category.array_data.dynamic_size)