X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/0f5e8daaa6e9f74521068aa75837200bcd182ea6..7da44b26eb7f4da0d4ce7672f479dea4d01767b3:/src/xbt/dict.c

diff --git a/src/xbt/dict.c b/src/xbt/dict.c
index 6920797ffc..d591e01b9f 100644
--- a/src/xbt/dict.c
+++ b/src/xbt/dict.c
@@ -188,7 +188,7 @@ static void xbt_dict_rehash(xbt_dict_t dict)
   memset(&currcell[oldsize], 0, oldsize * sizeof(xbt_dictelm_t));       /* zero second half */
   dict->table_size = --newsize;
   dict->table = currcell;
-  DEBUG2("REHASH (%d->%d)", oldsize, newsize);
+  XBT_DEBUG("REHASH (%d->%d)", oldsize, newsize);
 
   for (i = 0; i < oldsize; i++, currcell++) {
     if (!*currcell)             /* empty cell */
@@ -223,8 +223,8 @@ static void xbt_dict_rehash(xbt_dict_t dict)
  * \param key the key to set the new data
  * \param key_len the size of the \a key
  * \param data the data to add in the dict
- * \param free_ctn function to call with (\a key as argument) when
- *        \a key is removed from the dictionary
+ * \param free_ctn function to call with (\a data as argument) when
+ *        \a data is removed from the dictionary
  *
  * Set the \a data in the structure under the \a key, which can be any kind
  * of data, as long as its length is provided in \a key_len.
@@ -239,7 +239,7 @@ XBT_INLINE void xbt_dict_set_ext(xbt_dict_t dict,
   xbt_dictelm_t current, previous = NULL;
   xbt_assert(dict);
 
-  DEBUG5("ADD %.*s hash = %d, size = %d, & = %d", key_len, key, hash_code,
+  XBT_DEBUG("ADD %.*s hash = %d, size = %d, & = %d", key_len, key, hash_code,
          dict->table_size, hash_code & dict->table_size);
   current = dict->table[hash_code & dict->table_size];
   while (current != NULL &&
@@ -263,7 +263,7 @@ XBT_INLINE void xbt_dict_set_ext(xbt_dict_t dict,
     }
   } else {
 
-    DEBUG6("Replace %.*s by %.*s under key %.*s",
+    XBT_DEBUG("Replace %.*s by %.*s under key %.*s",
            key_len, (char *) current->content,
            key_len, (char *) data, key_len, (char *) key);
     /* there is already an element with the same key: overwrite it */
@@ -281,8 +281,8 @@ XBT_INLINE void xbt_dict_set_ext(xbt_dict_t dict,
  * \param dict the dict
  * \param key the key to set the new data
  * \param data the data to add in the dict
- * \param free_ctn function to call with (\a key as argument) when
- *        \a key is removed from the dictionary
+ * \param free_ctn function to call with (\a data as argument) when
+ *        \a data is removed from the dictionary
  *
  * set the \a data in the structure under the \a key, which is a
  * null terminated string.
@@ -323,7 +323,7 @@ XBT_INLINE void *xbt_dict_get_ext(xbt_dict_t dict, const char *key,
   }
 
   if (current == NULL)
-    THROW2(not_found_error, 0, "key %.*s not found", key_len, key);
+    THROWF(not_found_error, 0, "key %.*s not found", key_len, key);
 
   return current->content;
 }
@@ -401,7 +401,7 @@ XBT_INLINE void *xbt_dict_get(xbt_dict_t dict, const char *key)
     current = current->next;
 
   if (current == NULL)
-    THROW1(not_found_error, 0, "key %s not found", key);
+    THROWF(not_found_error, 0, "key %s not found", key);
 
   return current->content;
 }
@@ -457,7 +457,7 @@ XBT_INLINE void xbt_dict_remove_ext(xbt_dict_t dict, const char *key,
   }
 
   if (current == NULL)
-    THROW2(not_found_error, 0, "key %.*s not found", key_len, key);
+    THROWF(not_found_error, 0, "key %.*s not found", key_len, key);
 
   if (previous != NULL) {
     previous->next = current->next;
@@ -491,13 +491,10 @@ XBT_INLINE void xbt_dict_remove(xbt_dict_t dict, const char *key)
  * \brief Add data to the dict (arbitrary key)
  * \param dict the container
  * \param key the key to set the new data
- * \param key_len the size of the \a key
  * \param data the data to add in the dict
- * \param free_ctn function to call with (\a key as argument) when
- *        \a key is removed from the dictionary
  *
- * Set the \a data in the structure under the \a key, which can be any kind
- * of data, as long as its length is provided in \a key_len.
+ * Set the \a data in the structure under the \a key.
+ * Both \a data and \a key are considered as uintptr_t.
  */
 XBT_INLINE void xbt_dicti_set(xbt_dict_t dict,
                               uintptr_t key, uintptr_t data)
@@ -509,13 +506,14 @@ XBT_INLINE void xbt_dicti_set(xbt_dict_t dict,
   xbt_dictelm_t current, previous = NULL;
   xbt_assert(dict);
 
-  DEBUG5("ADD %zu->%zu; hash = %d, size = %d, & = %d", key, data,
+  XBT_DEBUG("ADD %zu->%zu; hash = %d, size = %d, & = %d", key, data,
          hash_code, dict->table_size, hash_code & dict->table_size);
   current = dict->table[hash_code & dict->table_size];
   while (current != NULL &&
          (hash_code != current->hash_code
           || sizeof(uintptr_t) != current->key_len
           || (((uintptr_t) key) != ((uintptr_t) current->key)))) {
+    previous = current;
     current = current->next;
   }
 
@@ -593,7 +591,7 @@ XBT_INLINE void xbt_dicti_remove(xbt_dict_t dict, uintptr_t key)
   }
 
   if (current == NULL)
-    THROW1(not_found_error, 0, "key %zu not found", key);
+    THROWF(not_found_error, 0, "key %zu not found", key);
 
   if (previous != NULL) {
     previous->next = current->next;
@@ -850,7 +848,7 @@ static void debuged_add_ext(xbt_dict_t head, const char *key,
 {
   char *data = xbt_strdup(data_to_fill);
 
-  xbt_test_log2("Add %s under %s", PRINTF_STR(data_to_fill),
+  xbt_test_log("Add %s under %s", PRINTF_STR(data_to_fill),
                 PRINTF_STR(key));
 
   xbt_dict_set(head, key, data, &free);
@@ -867,7 +865,7 @@ static void debuged_add(xbt_dict_t head, const char *key)
 
 static void fill(xbt_dict_t * head)
 {
-  xbt_test_add0("Fill in the dictionnary");
+  xbt_test_add("Fill in the dictionnary");
 
   *head = xbt_dict_new();
   debuged_add(*head, "12");
@@ -886,15 +884,15 @@ static void search_ext(xbt_dict_t head, const char *key, const char *data)
 {
   void *found;
 
-  xbt_test_add1("Search %s", key);
+  xbt_test_add("Search %s", key);
   found = xbt_dict_get(head, key);
-  xbt_test_log1("Found %s", (char *) found);
+  xbt_test_log("Found %s", (char *) found);
   if (data)
-    xbt_test_assert1(found,
+    xbt_test_assert(found,
                      "data do not match expectations: found NULL while searching for %s",
                      data);
   if (found)
-    xbt_test_assert2(!strcmp((char *) data, found),
+    xbt_test_assert(!strcmp((char *) data, found),
                      "data do not match expectations: found %s while searching for %s",
                      (char *) found, data);
 }
@@ -907,7 +905,7 @@ static void search(xbt_dict_t head, const char *key)
 static void debuged_remove(xbt_dict_t head, const char *key)
 {
 
-  xbt_test_add1("Remove '%s'", PRINTF_STR(key));
+  xbt_test_add("Remove '%s'", PRINTF_STR(key));
   xbt_dict_remove(head, key);
   /*  xbt_dict_dump(head,(void (*)(void*))&printf); */
 }
@@ -922,12 +920,12 @@ static void traverse(xbt_dict_t head)
 
   xbt_dict_foreach(head, cursor, key, data) {
     if (!key || !data || strcmp(key, data)) {
-      xbt_test_log3("Seen #%d:  %s->%s", ++i, PRINTF_STR(key),
+      xbt_test_log("Seen #%d:  %s->%s", ++i, PRINTF_STR(key),
                     PRINTF_STR(data));
     } else {
-      xbt_test_log2("Seen #%d:  %s", ++i, PRINTF_STR(key));
+      xbt_test_log("Seen #%d:  %s", ++i, PRINTF_STR(key));
     }
-    xbt_test_assert2(!data || !strcmp(key, data),
+    xbt_test_assert(!data || !strcmp(key, data),
                      "Key(%s) != value(%s). Aborting", key, data);
   }
 }
@@ -937,19 +935,20 @@ static void search_not_found(xbt_dict_t head, const char *data)
   int ok = 0;
   xbt_ex_t e;
 
-  xbt_test_add1("Search %s (expected not to be found)", data);
+  xbt_test_add("Search %s (expected not to be found)", data);
 
   TRY {
     data = xbt_dict_get(head, data);
-    THROW1(unknown_error, 0,
+    THROWF(unknown_error, 0,
            "Found something which shouldn't be there (%s)", data);
-  } CATCH(e) {
+  }
+  CATCH(e) {
     if (e.category != not_found_error)
       xbt_test_exception(e);
     xbt_ex_free(e);
     ok = 1;
   }
-  xbt_test_assert0(ok, "Exception not raised");
+  xbt_test_assert(ok, "Exception not raised");
 }
 
 static void count(xbt_dict_t dict, int length)
@@ -960,15 +959,15 @@ static void count(xbt_dict_t dict, int length)
   int effective = 0;
 
 
-  xbt_test_add1("Count elements (expecting %d)", length);
-  xbt_test_assert2(xbt_dict_length(dict) == length,
+  xbt_test_add("Count elements (expecting %d)", length);
+  xbt_test_assert(xbt_dict_length(dict) == length,
                    "Announced length(%d) != %d.", xbt_dict_length(dict),
                    length);
 
   xbt_dict_foreach(dict, cursor, key, data)
       effective++;
 
-  xbt_test_assert2(effective == length, "Effective length(%d) != %d.",
+  xbt_test_assert(effective == length, "Effective length(%d) != %d.",
                    effective, length);
 
 }
@@ -976,27 +975,28 @@ static void count(xbt_dict_t dict, int length)
 static void count_check_get_key(xbt_dict_t dict, int length)
 {
   xbt_dict_cursor_t cursor;
-  char *key, *key2;
+  char *key;
+  _XBT_GNUC_UNUSED char *key2;
   void *data;
   int effective = 0;
 
 
-  xbt_test_add1
+  xbt_test_add
       ("Count elements (expecting %d), and test the getkey function",
        length);
-  xbt_test_assert2(xbt_dict_length(dict) == length,
+  xbt_test_assert(xbt_dict_length(dict) == length,
                    "Announced length(%d) != %d.", xbt_dict_length(dict),
                    length);
 
   xbt_dict_foreach(dict, cursor, key, data) {
     effective++;
     key2 = xbt_dict_get_key(dict, data);
-    xbt_assert2(!strcmp(key, key2),
+    xbt_assert(!strcmp(key, key2),
                 "The data was registered under %s instead of %s as expected",
                 key2, key);
   }
 
-  xbt_test_assert2(effective == length, "Effective length(%d) != %d.",
+  xbt_test_assert(effective == length, "Effective length(%d) != %d.",
                    effective, length);
 
 }
@@ -1008,22 +1008,23 @@ char *data;
 
 XBT_TEST_UNIT("basic", test_dict_basic, "Basic usage: change, retrieve, traverse")
 {
-  xbt_test_add0("Traversal the null dictionary");
+  xbt_test_add("Traversal the null dictionary");
   traverse(head);
 
-  xbt_test_add0("Traversal and search the empty dictionary");
+  xbt_test_add("Traversal and search the empty dictionary");
   head = xbt_dict_new();
   traverse(head);
   TRY {
     debuged_remove(head, "12346");
-  } CATCH(e) {
+  }
+  CATCH(e) {
     if (e.category != not_found_error)
       xbt_test_exception(e);
     xbt_ex_free(e);
   }
   xbt_dict_free(&head);
 
-  xbt_test_add0("Traverse the full dictionary");
+  xbt_test_add("Traverse the full dictionary");
   fill(&head);
   count_check_get_key(head, 7);
 
@@ -1034,34 +1035,34 @@ XBT_TEST_UNIT("basic", test_dict_basic, "Basic usage: change, retrieve, traverse
   search(head, "12a");
   traverse(head);
 
-  xbt_test_add0("Free the dictionary (twice)");
+  xbt_test_add("Free the dictionary (twice)");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 
   /* CHANGING */
   fill(&head);
   count_check_get_key(head, 7);
-  xbt_test_add0("Change 123 to 'Changed 123'");
+  xbt_test_add("Change 123 to 'Changed 123'");
   xbt_dict_set(head, "123", strdup("Changed 123"), &free);
   count_check_get_key(head, 7);
 
-  xbt_test_add0("Change 123 back to '123'");
+  xbt_test_add("Change 123 back to '123'");
   xbt_dict_set(head, "123", strdup("123"), &free);
   count_check_get_key(head, 7);
 
-  xbt_test_add0("Change 12a to 'Dummy 12a'");
+  xbt_test_add("Change 12a to 'Dummy 12a'");
   xbt_dict_set(head, "12a", strdup("Dummy 12a"), &free);
   count_check_get_key(head, 7);
 
-  xbt_test_add0("Change 12a to '12a'");
+  xbt_test_add("Change 12a to '12a'");
   xbt_dict_set(head, "12a", strdup("12a"), &free);
   count_check_get_key(head, 7);
 
-  xbt_test_add0("Traverse the resulting dictionary");
+  xbt_test_add("Traverse the resulting dictionary");
   traverse(head);
 
   /* RETRIEVE */
-  xbt_test_add0("Search 123");
+  xbt_test_add("Search 123");
   data = xbt_dict_get(head, "123");
   xbt_test_assert(data);
   xbt_test_assert(!strcmp("123", data));
@@ -1077,16 +1078,16 @@ XBT_TEST_UNIT("basic", test_dict_basic, "Basic usage: change, retrieve, traverse
   search(head, "1234");
   search(head, "123457");
 
-  xbt_test_add0("Traverse the resulting dictionary");
+  xbt_test_add("Traverse the resulting dictionary");
   traverse(head);
 
   /*  xbt_dict_dump(head,(void (*)(void*))&printf); */
 
-  xbt_test_add0("Free the dictionary twice");
+  xbt_test_add("Free the dictionary twice");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 
-  xbt_test_add0("Traverse the resulting dictionary");
+  xbt_test_add("Traverse the resulting dictionary");
   traverse(head);
 }
 
@@ -1094,7 +1095,7 @@ XBT_TEST_UNIT("remove", test_dict_remove, "Removing some values")
 {
   fill(&head);
   count(head, 7);
-  xbt_test_add0("Remove non existing data");
+  xbt_test_add("Remove non existing data");
   TRY {
     debuged_remove(head, "Does not exist");
   }
@@ -1107,7 +1108,7 @@ XBT_TEST_UNIT("remove", test_dict_remove, "Removing some values")
 
   xbt_dict_free(&head);
 
-  xbt_test_add0
+  xbt_test_add
       ("Remove each data manually (traversing the resulting dictionary each time)");
   fill(&head);
   debuged_remove(head, "12a");
@@ -1147,7 +1148,7 @@ XBT_TEST_UNIT("remove", test_dict_remove, "Removing some values")
   }
   traverse(head);
 
-  xbt_test_add0
+  xbt_test_add
       ("Free dict, create new fresh one, and then reset the dict");
   xbt_dict_free(&head);
   fill(&head);
@@ -1155,7 +1156,7 @@ XBT_TEST_UNIT("remove", test_dict_remove, "Removing some values")
   count(head, 0);
   traverse(head);
 
-  xbt_test_add0("Free the dictionary twice");
+  xbt_test_add("Free the dictionary twice");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 }
@@ -1164,11 +1165,11 @@ XBT_TEST_UNIT("nulldata", test_dict_nulldata, "NULL data management")
 {
   fill(&head);
 
-  xbt_test_add0("Store NULL under 'null'");
+  xbt_test_add("Store NULL under 'null'");
   xbt_dict_set(head, "null", NULL, NULL);
   search_ext(head, "null", NULL);
 
-  xbt_test_add0("Check whether I see it while traversing...");
+  xbt_test_add("Check whether I see it while traversing...");
   {
     xbt_dict_cursor_t cursor = NULL;
     char *key;
@@ -1176,15 +1177,15 @@ XBT_TEST_UNIT("nulldata", test_dict_nulldata, "NULL data management")
 
     xbt_dict_foreach(head, cursor, key, data) {
       if (!key || !data || strcmp(key, data)) {
-        xbt_test_log2("Seen:  %s->%s", PRINTF_STR(key), PRINTF_STR(data));
+        xbt_test_log("Seen:  %s->%s", PRINTF_STR(key), PRINTF_STR(data));
       } else {
-        xbt_test_log1("Seen:  %s", PRINTF_STR(key));
+        xbt_test_log("Seen:  %s", PRINTF_STR(key));
       }
 
       if (!strcmp(key, "null"))
         found = 1;
     }
-    xbt_test_assert0(found,
+    xbt_test_assert(found,
                      "the key 'null', associated to NULL is not found");
   }
   xbt_dict_free(&head);
@@ -1193,7 +1194,7 @@ XBT_TEST_UNIT("nulldata", test_dict_nulldata, "NULL data management")
 static void debuged_addi(xbt_dict_t head, uintptr_t key, uintptr_t data)
 {
   uintptr_t stored_data = 0;
-  xbt_test_log2("Add %zu under %zu", data, key);
+  xbt_test_log("Add %zu under %zu", data, key);
 
   xbt_dicti_set(head, key, data);
   if (XBT_LOG_ISENABLED(xbt_dict, xbt_log_priority_debug)) {
@@ -1201,14 +1202,14 @@ static void debuged_addi(xbt_dict_t head, uintptr_t key, uintptr_t data)
     fflush(stdout);
   }
   stored_data = xbt_dicti_get(head, key);
-  xbt_test_assert3(stored_data == data,
+  xbt_test_assert(stored_data == data,
                    "Retrieved data (%zu) is not what I just stored (%zu) under key %zu",
                    stored_data, data, key);
 }
 
 XBT_TEST_UNIT("dicti", test_dict_scalar, "Scalar data and key management")
 {
-  xbt_test_add0("Fill in the dictionnary");
+  xbt_test_add("Fill in the dictionnary");
 
   head = xbt_dict_new();
   debuged_addi(head, 12, 12);
@@ -1250,22 +1251,21 @@ static int countelems(xbt_dict_t head)
 XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
 {
   xbt_dict_t head = NULL;
-  int i, j, k, nb;
+  int i, j, k;
   char *key;
   void *data;
 
   srand((unsigned int) time(NULL));
 
   for (i = 0; i < 10; i++) {
-    xbt_test_add2("CRASH test number %d (%d to go)", i + 1, 10 - i - 1);
-    xbt_test_log0
+    xbt_test_add("CRASH test number %d (%d to go)", i + 1, 10 - i - 1);
+    xbt_test_log
         ("Fill the struct, count its elems and frees the structure");
-    xbt_test_log1
+    xbt_test_log
         ("using 1000 elements with %d chars long randomized keys.",
          SIZEOFKEY);
     head = xbt_dict_new();
     /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */
-    nb = 0;
     for (j = 0; j < 1000; j++) {
       char *data = NULL;
       key = xbt_malloc(SIZEOFKEY);
@@ -1280,7 +1280,7 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
 
       xbt_dict_set(head, key, key, &free);
       data = xbt_dict_get(head, key);
-      xbt_test_assert2(!strcmp(key, data),
+      xbt_test_assert(!strcmp(key, data),
                        "Retrieved value (%s) != Injected value (%s)", key,
                        data);
 
@@ -1294,7 +1294,7 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
 
 
   head = xbt_dict_new();
-  xbt_test_add1("Fill %d elements, with keys being the number of element",
+  xbt_test_add("Fill %d elements, with keys being the number of element",
                 NB_ELM);
   for (j = 0; j < NB_ELM; j++) {
     /* if (!(j%1000)) { printf("."); fflush(stdout); } */
@@ -1306,12 +1306,12 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
   }
   /*xbt_dict_dump(head,(void (*)(void*))&printf); */
 
-  xbt_test_add0
+  xbt_test_add
       ("Count the elements (retrieving the key and data for each)");
   i = countelems(head);
-  xbt_test_log1("There is %d elements", i);
+  xbt_test_log("There is %d elements", i);
 
-  xbt_test_add1("Search my %d elements 20 times", NB_ELM);
+  xbt_test_add("Search my %d elements 20 times", NB_ELM);
   key = xbt_malloc(10);
   for (i = 0; i < 20; i++) {
     /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */
@@ -1319,17 +1319,17 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
 
       sprintf(key, "%d", j);
       data = xbt_dict_get(head, key);
-      xbt_test_assert2(!strcmp(key, (char *) data),
+      xbt_test_assert(!strcmp(key, (char *) data),
                        "with get, key=%s != data=%s", key, (char *) data);
       data = xbt_dict_get_ext(head, key, strlen(key));
-      xbt_test_assert2(!strcmp(key, (char *) data),
+      xbt_test_assert(!strcmp(key, (char *) data),
                        "with get_ext, key=%s != data=%s", key,
                        (char *) data);
     }
   }
   free(key);
 
-  xbt_test_add1("Remove my %d elements", NB_ELM);
+  xbt_test_add("Remove my %d elements", NB_ELM);
   key = xbt_malloc(10);
   for (j = 0; j < NB_ELM; j++) {
     /* if (!(j%10000)) printf("."); fflush(stdout); */
@@ -1340,7 +1340,7 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
   free(key);
 
 
-  xbt_test_add0("Free the structure (twice)");
+  xbt_test_add("Free the structure (twice)");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 }
@@ -1368,8 +1368,8 @@ XBT_TEST_UNIT("multicrash", test_dict_multicrash, "Multi-dict crash test")
   char *key;
 
 
-  xbt_test_add0("Generic multicache CRASH test");
-  xbt_test_log4
+  xbt_test_add("Generic multicache CRASH test");
+  xbt_test_log
       (" Fill the struct and frees it %d times, using %d elements, "
        "depth of multicache=%d, key size=%d", NB_TEST, NB_ELM, DEPTH,
        KEY_SIZE);
@@ -1381,7 +1381,7 @@ XBT_TEST_UNIT("multicrash", test_dict_multicrash, "Multi-dict crash test")
 
   for (i = 0; i < NB_TEST; i++) {
     mdict = xbt_dict_new();
-    VERB1("mdict=%p", mdict);
+    XBT_VERB("mdict=%p", mdict);
     if (verbose > 0)
       printf("Test %d\n", i);
     /* else if (i%10) printf("."); else printf("%d",i/10); */
@@ -1408,7 +1408,7 @@ XBT_TEST_UNIT("multicrash", test_dict_multicrash, "Multi-dict crash test")
 
       data = xbt_multidict_get(mdict, keys);
 
-      xbt_test_assert2(data && !strcmp((char *) data, key),
+      xbt_test_assert(data && !strcmp((char *) data, key),
                        "Retrieved value (%s) does not match the given one (%s)\n",
                        (char *) data, key);
     }