Kill "if" before free, and useless cast of free argument.

[simgrid.git] / src / gras / DataDesc / ddt_create.c

diff --git a/src/gras/DataDesc/ddt_create.c b/src/gras/DataDesc/ddt_create.c
index 3dbd91a..ece97c0 100644 (file)
--- a/src/gras/DataDesc/ddt_create.c
+++ b/src/gras/DataDesc/ddt_create.c
@@ -34,7 +34,7 @@ static gras_datadesc_type_t gras_ddt_new(const char *name)
 {
   gras_datadesc_type_t res;
 
-  XBT_IN_F("(%s)", name);
+  XBT_IN("(%s)", name);
   res = xbt_new0(s_gras_datadesc_type_t, 1);
 
   res->name = (char *) strdup(name);
@@ -43,7 +43,7 @@ static gras_datadesc_type_t gras_ddt_new(const char *name)
 
   xbt_set_add(gras_datadesc_set_local, (xbt_set_elm_t) res,
               gras_ddt_freev);
-  XBT_OUT;
+  XBT_OUT();
   return res;
 }
 
@@ -55,7 +55,8 @@ gras_datadesc_type_t gras_datadesc_by_name_or_null(const char *name)
 
   TRY {
     res = gras_datadesc_by_name(name);
-  } CATCH(e) {
+  }
+  CATCH(e) {
     res = NULL;
     xbt_ex_free(e);
   }
@@ -75,13 +76,14 @@ gras_datadesc_type_t gras_datadesc_by_name(const char *name)
         (gras_datadesc_type_t) xbt_set_get_by_name(gras_datadesc_set_local,
                                                    name);
     found = 1;
-  } CATCH(e) {
+  }
+  CATCH(e) {
     if (e.category != not_found_error)
       RETHROW;
     xbt_ex_free(e);
   }
   if (!found)
-    THROW1(not_found_error, 0, "No registred datatype of that name: %s",
+    THROWF(not_found_error, 0, "No registred datatype of that name: %s",
            name);
 
   return res;
@@ -98,7 +100,8 @@ gras_datadesc_type_t gras_datadesc_by_id(long int code)
     res =
         (gras_datadesc_type_t) xbt_set_get_by_id(gras_datadesc_set_local,
                                                  code);
-  } CATCH(e) {
+  }
+  CATCH(e) {
     if (e.category != not_found_error)
       RETHROW;
     xbt_ex_free(e);
@@ -119,14 +122,14 @@ 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,
+    xbt_assert(res->category_code == e_gras_datadesc_type_cat_scalar,
                 "Redefinition of type %s does not match", name);
-    xbt_assert1(res->category.scalar_data.encoding == encoding,
+    xbt_assert(res->category.scalar_data.encoding == encoding,
                 "Redefinition of type %s does not match", name);
-    xbt_assert1(res->category.scalar_data.type == type,
+    xbt_assert(res->category.scalar_data.type == type,
                 "Redefinition of type %s does not match", name);
     XBT_VERB("Discarding redefinition of %s", name);
     return res;
@@ -143,7 +146,7 @@ gras_datadesc_scalar(const char *name,
   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;
 }
@@ -153,13 +156,12 @@ 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->name);
     free(field);
   }
-  XBT_OUT;
+  XBT_OUT();
 }
 
 /** \brief Declare a new structure description */
@@ -169,11 +171,11 @@ gras_datadesc_type_t gras_datadesc_struct(const char *name)
   gras_datadesc_type_t res;
   long int arch;
 
-  XBT_IN_F("(%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,
+    xbt_assert(res->category_code == e_gras_datadesc_type_cat_struct,
                 "Redefinition of type %s does not match", name);
     XBT_DEBUG("Discarding redefinition of %s", name);
     return res;
@@ -189,7 +191,7 @@ gras_datadesc_type_t gras_datadesc_struct(const char *name)
   res->category.struct_data.fields =
       xbt_dynar_new(sizeof(gras_dd_cat_field_t), gras_dd_cat_field_free);
 
-  XBT_OUT;
+  XBT_OUT();
   return res;
 }
 
@@ -203,10 +205,10 @@ gras_datadesc_struct_append(gras_datadesc_type_t struct_type,
   gras_dd_cat_field_t field;
   int arch;
 
-  xbt_assert2(field_type,
+  xbt_assert(field_type,
               "Cannot add the field '%s' into struct '%s': its type is NULL",
               name, struct_type->name);
-  XBT_IN_F("(%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) {
     XBT_DEBUG
         ("Ignoring request to add field to struct %s (closed. Redefinition?)",
@@ -214,7 +216,7 @@ gras_datadesc_struct_append(gras_datadesc_type_t struct_type,
     return;
   }
 
-  xbt_assert1(field_type->size[GRAS_THISARCH] >= 0,
+  xbt_assert(field_type->size[GRAS_THISARCH] >= 0,
               "Cannot add a dynamically sized field in structure %s",
               struct_type->name);
 
@@ -256,7 +258,7 @@ gras_datadesc_struct_append(gras_datadesc_type_t struct_type,
          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
@@ -266,7 +268,7 @@ 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];
@@ -312,16 +314,16 @@ gras_datadesc_union(const char *name, gras_datadesc_type_cb_int_t selector)
   gras_datadesc_type_t res;
   int arch;
 
-  XBT_IN_F("(%s)", name);
-  xbt_assert0(selector,
+  XBT_IN("(%s)", name);
+  xbt_assert(selector,
               "Attempt to creat an union without field_count function");
 
   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_union,
+    xbt_assert(res->category_code == e_gras_datadesc_type_cat_union,
                 "Redefinition of type %s does not match", name);
-    xbt_assert1(res->category.union_data.selector == selector,
+    xbt_assert(res->category.union_data.selector == selector,
                 "Redefinition of type %s does not match", name);
     XBT_VERB("Discarding redefinition of %s", name);
     return res;
@@ -352,8 +354,8 @@ void gras_datadesc_union_append(gras_datadesc_type_t union_type,
   gras_dd_cat_field_t field;
   int arch;
 
-  XBT_IN_F("(%s %s.%s;)", field_type->name, union_type->name, name);
-  xbt_assert1(field_type->size[GRAS_THISARCH] >= 0,
+  XBT_IN("(%s %s.%s;)", field_type->name, union_type->name, name);
+  xbt_assert(field_type->size[GRAS_THISARCH] >= 0,
               "Cannot add a dynamically sized field in union %s",
               union_type->name);
 
@@ -418,14 +420,14 @@ gras_datadesc_ref(const char *name, gras_datadesc_type_t referenced_type)
       gras_datadesc_by_name("data pointer");
   int arch;
 
-  XBT_IN_F("(%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,
+    xbt_assert(res->category_code == e_gras_datadesc_type_cat_ref,
                 "Redefinition of %s does not match", name);
-    xbt_assert1(res->category.ref_data.type == referenced_type,
+    xbt_assert(res->category.ref_data.type == referenced_type,
                 "Redefinition of %s does not match", name);
-    xbt_assert1(res->category.ref_data.selector == NULL,
+    xbt_assert(res->category.ref_data.selector == NULL,
                 "Redefinition of %s does not match", name);
     XBT_DEBUG("Discarding redefinition of %s", name);
     return res;
@@ -433,7 +435,7 @@ gras_datadesc_ref(const char *name, gras_datadesc_type_t referenced_type)
 
   res = gras_ddt_new(name);
 
-  xbt_assert0(pointer_type, "Cannot get the description of data pointer");
+  xbt_assert(pointer_type, "Cannot get the description of data pointer");
 
   for (arch = 0; arch < gras_arch_count; arch++) {
     res->size[arch] = pointer_type->size[arch];
@@ -464,22 +466,22 @@ gras_datadesc_ref_generic(const char *name,
       gras_datadesc_by_name("data pointer");
   int arch;
 
-  XBT_IN_F("(%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,
+    xbt_assert(res->category_code == e_gras_datadesc_type_cat_ref,
                 "Redefinition of type %s does not match", name);
-    xbt_assert1(res->category.ref_data.type == NULL,
+    xbt_assert(res->category.ref_data.type == NULL,
                 "Redefinition of type %s does not match", name);
-    xbt_assert1(res->category.ref_data.selector == selector,
+    xbt_assert(res->category.ref_data.selector == selector,
                 "Redefinition of type %s does not match", name);
     XBT_VERB("Discarding redefinition of %s", name);
     return res;
   }
   res = gras_ddt_new(name);
 
-  xbt_assert0(pointer_type, "Cannot get the description of data pointer");
+  xbt_assert(pointer_type, "Cannot get the description of data pointer");
 
   for (arch = 0; arch < gras_arch_count; arch++) {
     res->size[arch] = pointer_type->size[arch];
@@ -505,10 +507,10 @@ gras_datadesc_array_fixed(const char *name,
   gras_datadesc_type_t res;
   int arch;
 
-  XBT_IN_F("(%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,
+    xbt_assert(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) {
@@ -519,9 +521,9 @@ gras_datadesc_array_fixed(const char *name,
       gras_datadesc_type_dump(element_type);
     }
 
-    xbt_assert1(res->category.array_data.fixed_size == fixed_size,
+    xbt_assert(res->category.array_data.fixed_size == fixed_size,
                 "Redefinition of type %s does not match", name);
-    xbt_assert1(res->category.array_data.dynamic_size == NULL,
+    xbt_assert(res->category.array_data.dynamic_size == NULL,
                 "Redefinition of type %s does not match", name);
     XBT_VERB("Discarding redefinition of %s", name);
 
@@ -529,7 +531,7 @@ gras_datadesc_array_fixed(const char *name,
   }
   res = gras_ddt_new(name);
 
-  xbt_assert1(fixed_size >= 0, "'%s' is a array of negative fixed size",
+  xbt_assert(fixed_size >= 0, "'%s' is a array of negative fixed size",
               name);
   for (arch = 0; arch < gras_arch_count; arch++) {
     res->size[arch] = fixed_size * element_type->aligned_size[arch];
@@ -557,19 +559,19 @@ gras_datadesc_type_t gras_datadesc_array_dyn(const char *name,
   gras_datadesc_type_t res;
   int arch;
 
-  XBT_IN_F("(%s)", name);
-  xbt_assert1(dynamic_size,
+  XBT_IN("(%s)", name);
+  xbt_assert(dynamic_size,
               "'%s' is a dynamic array without size discriminant", name);
 
   res = gras_datadesc_by_name_or_null(name);
   if (res) {
-    xbt_assert1(res->category_code == e_gras_datadesc_type_cat_array,
+    xbt_assert(res->category_code == e_gras_datadesc_type_cat_array,
                 "Redefinition of type %s does not match", name);
-    xbt_assert1(res->category.array_data.type == element_type,
+    xbt_assert(res->category.array_data.type == element_type,
                 "Redefinition of type %s does not match", name);
-    xbt_assert1(res->category.array_data.fixed_size == -1,
+    xbt_assert(res->category.array_data.fixed_size == -1,
                 "Redefinition of type %s does not match", name);
-    xbt_assert1(res->category.array_data.dynamic_size == dynamic_size,
+    xbt_assert(res->category.array_data.dynamic_size == dynamic_size,
                 "Redefinition of type %s does not match", name);
     XBT_VERB("Discarding redefinition of %s", name);