Sanitize the XBT log chans, too. Arnaud did so for MSG+SURF, I did so for AMOK+GRAS...

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@2619 48e7efb5-ca39-0410-a469-dd3cf9ba447f

diff --git a/src/xbt/config.c b/src/xbt/config.c
index 505ce0f..9e982a9 100644 (file)
--- a/src/xbt/config.c
+++ b/src/xbt/config.c
@@ -19,7 +19,7 @@
 
 #include "xbt/config.h" /* prototypes of this module */
 
 
 #include "xbt/config.h" /* prototypes of this module */
 

-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(config,xbt,"configuration support");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_cfg,xbt,"configuration support");

 
 /* xbt_cfgelm_t: the typedef corresponding to a config variable. 
 
 
 /* xbt_cfgelm_t: the typedef corresponding to a config variable. 
 

diff --git a/src/xbt/context.c b/src/xbt/context.c
index c33311c..6ea5172 100644 (file)
--- a/src/xbt/context.c
+++ b/src/xbt/context.c
@@ -15,7 +15,7 @@
 #include "xbt/dynar.h"
 #include "gras_config.h"
 
 #include "xbt/dynar.h"
 #include "gras_config.h"
 

-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(context, xbt, "Context");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_ctx, xbt, "Context");

 
 #define VOIRP(expr) DEBUG1("  {" #expr " = %p }", expr)
 
 
 #define VOIRP(expr) DEBUG1("  {" #expr " = %p }", expr)
 

diff --git a/src/xbt/dict.c b/src/xbt/dict.c
index b1bb6ea..8810081 100644 (file)
--- a/src/xbt/dict.c
+++ b/src/xbt/dict.c
@@ -10,7 +10,7 @@
 #include "xbt/ex.h"
 #include "dict_private.h"
 
 #include "xbt/ex.h"
 #include "dict_private.h"
 

-XBT_LOG_NEW_SUBCATEGORY(dict,xbt,
+XBT_LOG_NEW_SUBCATEGORY(xbt_dict,xbt,

    "Dictionaries provide the same functionnalities than hash tables");
 /*####[ Private prototypes ]#################################################*/
 
    "Dictionaries provide the same functionnalities than hash tables");
 /*####[ Private prototypes ]#################################################*/
 


@@ -213,8 +213,8 @@ xbt_dict_dump(xbt_dict_t     dict,
 #include "xbt/ex.h"
 #include "portable.h"
 
 #include "xbt/ex.h"
 #include "portable.h"
 

-XBT_LOG_EXTERNAL_CATEGORY(dict);
-XBT_LOG_DEFAULT_CATEGORY(dict);
+XBT_LOG_EXTERNAL_CATEGORY(xbt_dict);
+XBT_LOG_DEFAULT_CATEGORY(xbt_dict);

 
 XBT_TEST_SUITE("dict","Dict data container");
 
 
 XBT_TEST_SUITE("dict","Dict data container");
 


@@ -229,7 +229,7 @@ static void debuged_add(xbt_dict_t head,const char*key)
   xbt_test_log1("Add %s",PRINTF_STR(key));
 
   xbt_dict_set(head,key,data,&free);
   xbt_test_log1("Add %s",PRINTF_STR(key));
 
   xbt_dict_set(head,key,data,&free);

-  if (XBT_LOG_ISENABLED(dict,xbt_log_priority_debug)) {
+  if (XBT_LOG_ISENABLED(xbt_dict,xbt_log_priority_debug)) {

     xbt_dict_dump(head,(void (*)(void*))&printf);
     fflush(stdout);
   }
     xbt_dict_dump(head,(void (*)(void*))&printf);
     fflush(stdout);
   }

diff --git a/src/xbt/dict_cursor.c b/src/xbt/dict_cursor.c
index 1827eeb..ee1bfb4 100644 (file)
--- a/src/xbt/dict_cursor.c
+++ b/src/xbt/dict_cursor.c
@@ -13,8 +13,8 @@
 
 #include <string.h> /* strlen() */
 
 
 #include <string.h> /* strlen() */
 

-XBT_LOG_EXTERNAL_CATEGORY(dict);
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(dict_cursor,dict,"To traverse dictionaries");
+XBT_LOG_EXTERNAL_CATEGORY(xbt_dict);
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict_cursor,xbt_dict,"To traverse dictionaries");

 
 
 /*####[ Dict cursor functions ]#############################################*/
 
 
 /*####[ Dict cursor functions ]#############################################*/


@@ -92,7 +92,7 @@ _cursor_push_keys(xbt_dict_cursor_t cursor,
   int                  i       = 0;
   static volatile int  count   = 0; /* ??? */
 
   int                  i       = 0;
   static volatile int  count   = 0; /* ??? */
 

-  CDEBUG3(dict_cursor, "Push childs of %p (%.*s) in the cursor", (void*)elm, elm->key_len, elm->key);
+  CDEBUG3(xbt_dict_cursor, "Push childs of %p (%.*s) in the cursor", (void*)elm, elm->key_len, elm->key);

 
   if (!elm->internal) {
     xbt_dynar_push(cursor->keys,     &elm->key    );
 
   if (!elm->internal) {
     xbt_dynar_push(cursor->keys,     &elm->key    );


@@ -105,14 +105,14 @@ _cursor_push_keys(xbt_dict_cursor_t cursor,
       _cursor_push_keys(cursor, child);
   }
 
       _cursor_push_keys(cursor, child);
   }
 

-  CDEBUG1(dict_cursor, "Count = %d", count);
+  CDEBUG1(xbt_dict_cursor, "Count = %d", count);

 }
 
 /** @brief Reinitialize the cursor. Mandatory after removal or add in dict. */
 void
 xbt_dict_cursor_rewind(xbt_dict_cursor_t cursor) {
 
 }
 
 /** @brief Reinitialize the cursor. Mandatory after removal or add in dict. */
 void
 xbt_dict_cursor_rewind(xbt_dict_cursor_t cursor) {
 

-  CDEBUG0(dict_cursor, "xbt_dict_cursor_rewind");
+  CDEBUG0(xbt_dict_cursor, "xbt_dict_cursor_rewind");

   xbt_assert(cursor);
 
   xbt_dynar_reset(cursor->keys);
   xbt_assert(cursor);
 
   xbt_dynar_reset(cursor->keys);

diff --git a/src/xbt/dict_elm.c b/src/xbt/dict_elm.c
index 267cf35..eaa1c3a 100644 (file)
--- a/src/xbt/dict_elm.c
+++ b/src/xbt/dict_elm.c
@@ -11,13 +11,13 @@
 #include "portable.h" /* PRINTF_STR */
 #include "dict_private.h"  /* prototypes of this module */
 
 #include "portable.h" /* PRINTF_STR */
 #include "dict_private.h"  /* prototypes of this module */
 

-XBT_LOG_EXTERNAL_CATEGORY(dict);
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(dict_elm,dict,"Dictionaries internals");
+XBT_LOG_EXTERNAL_CATEGORY(xbt_dict);
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict_elm,xbt_dict,"Dictionaries internals");

 
 

-XBT_LOG_NEW_SUBCATEGORY(dict_add,dict,"Dictionaries internals: elements addition");
-XBT_LOG_NEW_SUBCATEGORY(dict_search,dict,"Dictionaries internals: searching");
-XBT_LOG_NEW_SUBCATEGORY(dict_remove,dict,"Dictionaries internals: elements removal");
-XBT_LOG_NEW_SUBCATEGORY(dict_collapse,dict,"Dictionaries internals: post-removal cleanup");
+XBT_LOG_NEW_SUBCATEGORY(xbt_dict_add,xbt_dict,"Dictionaries internals: elements addition");
+XBT_LOG_NEW_SUBCATEGORY(xbt_dict_search,xbt_dict,"Dictionaries internals: searching");
+XBT_LOG_NEW_SUBCATEGORY(xbt_dict_remove,xbt_dict,"Dictionaries internals: elements removal");
+XBT_LOG_NEW_SUBCATEGORY(xbt_dict_collapse,xbt_dict,"Dictionaries internals: post-removal cleanup");

 
 /*####[ Private prototypes ]#################################################*/
 
 
 /*####[ Private prototypes ]#################################################*/
 


@@ -281,7 +281,7 @@ _dict_child_cmp(s_xbt_dictelm_t *p_dict,
     cmp =  1;
   }
 
     cmp =  1;
   }
 

-  CDEBUG6(dict_search, "Cmp '%.*s' and '%.*s' (offset=%d) => %d", 
+  CDEBUG6(xbt_dict_search, "Cmp '%.*s' and '%.*s' (offset=%d) => %d", 

          p_child->key_len - *p_offset, p_child->key + *p_offset,
          key_len - *p_offset, key + *p_offset,
          *p_offset,cmp);
          p_child->key_len - *p_offset, p_child->key + *p_offset,
          key_len - *p_offset, key + *p_offset,
          *p_offset,cmp);


@@ -329,7 +329,7 @@ _xbt_dictelm_child_search(s_xbt_dictelm_t *p_elm,
   int          len     = 0;
 
   
   int          len     = 0;
 
   

-  CDEBUG6(dict_search, "search child [%.*s] under [%.*s]=%p (len=%lu)",
+  CDEBUG6(xbt_dict_search, "search child [%.*s] under [%.*s]=%p (len=%lu)",

          key_len, key,
           p_elm ? (p_elm->key_len?p_elm->key_len:6) : 6, 
          p_elm ? PRINTF_STR(p_elm->key) : "(head)",
          key_len, key,
           p_elm ? (p_elm->key_len?p_elm->key_len:6) : 6, 
          p_elm ? PRINTF_STR(p_elm->key) : "(head)",


@@ -385,7 +385,7 @@ _xbt_dictelm_child_search(s_xbt_dictelm_t *p_elm,
   *p_offset = o;
   *p_pos    = p;
   *p_match  = m;
   *p_offset = o;
   *p_pos    = p;
   *p_match  = m;

-  CDEBUG6(dict_search, "search [%.*s] in [%.*s]=%p => %s",
+  CDEBUG6(xbt_dict_search, "search [%.*s] in [%.*s]=%p => %s",

          key_len, key,
           p_elm?(p_elm->key_len?p_elm->key_len:6):6, p_elm?PRINTF_STR(p_elm->key):"(head)",
          p_elm,
          key_len, key,
           p_elm?(p_elm->key_len?p_elm->key_len:6):6, p_elm?PRINTF_STR(p_elm->key):"(head)",
          p_elm,


@@ -443,7 +443,7 @@ _xbt_dictelm_set_rec(s_xbt_dictelm_t     *p_head,
   int          pos        = 0;
   const int    old_offset = offset;
 
   int          pos        = 0;
   const int    old_offset = offset;
 

-  CDEBUG6(dict_add, "--> Insert '%.*s' after '%.*s' (offset=%d) in tree %p",
+  CDEBUG6(xbt_dict_add, "--> Insert '%.*s' after '%.*s' (offset=%d) in tree %p",

          key_len, key, 
          ((p_head && p_head->key) ? p_head->key_len : 6),
          ((p_head && p_head->key) ? p_head->key : "(head)"), 
          key_len, key, 
          ((p_head && p_head->key) ? p_head->key_len : 6),
          ((p_head && p_head->key) ? p_head->key : "(head)"), 


@@ -454,7 +454,7 @@ _xbt_dictelm_set_rec(s_xbt_dictelm_t     *p_head,
   /* there is no key (we did enough recursion), change the value of head */
   if (offset >= key_len) {
 
   /* there is no key (we did enough recursion), change the value of head */
   if (offset >= key_len) {
 

-    CDEBUG0(dict_add, "--> Change the value of head");
+    CDEBUG0(xbt_dict_add, "--> Change the value of head");

 
     _xbt_dictelm_change_value(p_head, data, free_f);
     free(key); /* Keep the key used in the tree */
 
     _xbt_dictelm_change_value(p_head, data, free_f);
     free(key); /* Keep the key used in the tree */


@@ -465,7 +465,7 @@ _xbt_dictelm_set_rec(s_xbt_dictelm_t     *p_head,
   /*** Search where to add this child, and how ***/
   _xbt_dictelm_child_search(p_head, key, key_len, &pos, &offset, &match);
 
   /*** Search where to add this child, and how ***/
   _xbt_dictelm_child_search(p_head, key, key_len, &pos, &offset, &match);
 

-  CDEBUG3(dict_add, "child_search => pos=%d, offset=%d, match=%d",
+  CDEBUG3(xbt_dict_add, "child_search => pos=%d, offset=%d, match=%d",

          pos, offset, match);
 
   switch (match) {
          pos, offset, match);
 
   switch (match) {


@@ -475,7 +475,7 @@ _xbt_dictelm_set_rec(s_xbt_dictelm_t     *p_head,
       s_xbt_dictelm_t *p_child = NULL;
 
       _xbt_dictelm_alloc(key, key_len, offset, FALSE, data, free_f, &p_child);
       s_xbt_dictelm_t *p_child = NULL;
 
       _xbt_dictelm_alloc(key, key_len, offset, FALSE, data, free_f, &p_child);

-      CDEBUG1(dict_add, "-> Add a child %p", (void*)p_child);
+      CDEBUG1(xbt_dict_add, "-> Add a child %p", (void*)p_child);

       xbt_dynar_insert_at(p_head->sub, pos, &p_child);
 
       return;
       xbt_dynar_insert_at(p_head->sub, pos, &p_child);
 
       return;


@@ -486,7 +486,7 @@ _xbt_dictelm_set_rec(s_xbt_dictelm_t     *p_head,
       s_xbt_dictelm_t *p_child = NULL;
 
       p_child = xbt_dynar_get_as(p_head->sub, pos, s_xbt_dictelm_t*);
       s_xbt_dictelm_t *p_child = NULL;
 
       p_child = xbt_dynar_get_as(p_head->sub, pos, s_xbt_dictelm_t*);

-      CDEBUG1(dict_add, "-> Change the value of the child %p", (void*)p_child);
+      CDEBUG1(xbt_dict_add, "-> Change the value of the child %p", (void*)p_child);

       _xbt_dictelm_change_value(p_child, data, free_f);
 
       free(key);
       _xbt_dictelm_change_value(p_child, data, free_f);
 
       free(key);


@@ -499,7 +499,7 @@ _xbt_dictelm_set_rec(s_xbt_dictelm_t     *p_head,
       s_xbt_dictelm_t *p_child = NULL;
 
       p_child=xbt_dynar_get_as(p_head->sub, pos, s_xbt_dictelm_t*);
       s_xbt_dictelm_t *p_child = NULL;
 
       p_child=xbt_dynar_get_as(p_head->sub, pos, s_xbt_dictelm_t*);

-      CDEBUG2(dict_add,"-> Recurse on %p (offset=%d)", (void*)p_child, offset);
+      CDEBUG2(xbt_dict_add,"-> Recurse on %p (offset=%d)", (void*)p_child, offset);

 
       _xbt_dictelm_set_rec(p_child, key, key_len, 
                            offset, data, free_f);
 
       _xbt_dictelm_set_rec(p_child, key, key_len, 
                            offset, data, free_f);


@@ -514,7 +514,7 @@ _xbt_dictelm_set_rec(s_xbt_dictelm_t     *p_head,
       p_child=xbt_dynar_get_as(p_head->sub, pos, s_xbt_dictelm_t*);
       _xbt_dictelm_alloc(key, key_len, old_offset, FALSE, data, free_f, &p_new);
 
       p_child=xbt_dynar_get_as(p_head->sub, pos, s_xbt_dictelm_t*);
       _xbt_dictelm_alloc(key, key_len, old_offset, FALSE, data, free_f, &p_new);
 

-      CDEBUG2(dict_add, "-> The child %p become child of new dict (%p)",
+      CDEBUG2(xbt_dict_add, "-> The child %p become child of new dict (%p)",

               (void*)p_child, (void*)p_new);
 
       xbt_dynar_push(p_new->sub, &p_child);
               (void*)p_child, (void*)p_new);
 
       xbt_dynar_push(p_new->sub, &p_child);


@@ -543,7 +543,7 @@ _xbt_dictelm_set_rec(s_xbt_dictelm_t     *p_head,
 
       _xbt_dictelm_alloc(anc_key, anc_key_len, old_offset, TRUE, NULL, NULL, &p_anc);
 
 
       _xbt_dictelm_alloc(anc_key, anc_key_len, old_offset, TRUE, NULL, NULL, &p_anc);
 

-      CDEBUG3(dict_add, "-> Make a common ancestor %p (%.*s)",
+      CDEBUG3(xbt_dict_add, "-> Make a common ancestor %p (%.*s)",

              (void*)p_anc, anc_key_len, anc_key);
 
       if (key[offset] < p_child->key[offset]) {
              (void*)p_anc, anc_key_len, anc_key);
 
       if (key[offset] < p_child->key[offset]) {


@@ -594,12 +594,12 @@ xbt_dictelm_set_ext(s_xbt_dictelm_t **pp_head,
   if (!p_head) {
     s_xbt_dictelm_t *p_child = NULL;
 
   if (!p_head) {
     s_xbt_dictelm_t *p_child = NULL;
 

-    CDEBUG0(dict_add, "Create an head");
+    CDEBUG0(xbt_dict_add, "Create an head");

 
     /* The head is priviledged by being the only one with a NULL key */
     _xbt_dictelm_alloc(NULL, 0, 0, TRUE, NULL, NULL, &p_head);
 
 
     /* The head is priviledged by being the only one with a NULL key */
     _xbt_dictelm_alloc(NULL, 0, 0, TRUE, NULL, NULL, &p_head);
 

-    CDEBUG2(dict_add, "Push %.*s as child of this head",key_len,key);
+    CDEBUG2(xbt_dict_add, "Push %.*s as child of this head",key_len,key);

     _xbt_dictelm_alloc(key, key_len, 0, FALSE, data, free_f, &p_child);
     xbt_dynar_insert_at(p_head->sub, 0, &p_child);
 
     _xbt_dictelm_alloc(key, key_len, 0, FALSE, data, free_f, &p_child);
     xbt_dynar_insert_at(p_head->sub, 0, &p_child);
 


@@ -647,7 +647,7 @@ _xbt_dictelm_get_rec(s_xbt_dictelm_t *p_head,
                      int             key_len,
                      int             offset) {
 
                      int             key_len,
                      int             offset) {
 

-  CDEBUG3(dict_search, "Search %.*s in %p", key_len, key, (void*)p_head); 
+  CDEBUG3(xbt_dict_search, "Search %.*s in %p", key_len, key, (void*)p_head); 

 
   /*** The trivial case first ***/
 
 
   /*** The trivial case first ***/
 


@@ -740,7 +740,7 @@ _collapse_if_need(xbt_dictelm_t head,
                  int            offset) {
   xbt_dictelm_t child = NULL;
 
                  int            offset) {
   xbt_dictelm_t child = NULL;
 

-  CDEBUG2(dict_collapse, "Collapse %d of %p... ", pos, (void*)head);
+  CDEBUG2(xbt_dict_collapse, "Collapse %d of %p... ", pos, (void*)head);

 
   if (pos >= 0) {
     /* Remove the child if |it's key| == 0 (meaning it's dead) */
 
   if (pos >= 0) {
     /* Remove the child if |it's key| == 0 (meaning it's dead) */


@@ -751,27 +751,27 @@ _collapse_if_need(xbt_dictelm_t head,
       xbt_assert0(xbt_dynar_length(child->sub) == 0,
                   "Found a dead child with grand childs. Internal error");
 
       xbt_assert0(xbt_dynar_length(child->sub) == 0,
                   "Found a dead child with grand childs. Internal error");
 

-      CDEBUG1(dict_collapse, "Remove dead child %p.... ", (void*)child);
+      CDEBUG1(xbt_dict_collapse, "Remove dead child %p.... ", (void*)child);

       xbt_dynar_remove_at(head->sub, pos, &child);
       xbt_dictelm_free(&child);
     }
   }
 
   if (!head->key) {
       xbt_dynar_remove_at(head->sub, pos, &child);
       xbt_dictelm_free(&child);
     }
   }
 
   if (!head->key) {

-    CDEBUG0(dict_collapse, "Do not collapse the head, you stupid programm");
+    CDEBUG0(xbt_dict_collapse, "Do not collapse the head, you stupid programm");

     return;
   }
 
   if (head->content || head->free_f ||
       xbt_dynar_length(head->sub) != 1) {
     return;
   }
 
   if (head->content || head->free_f ||
       xbt_dynar_length(head->sub) != 1) {

-    CDEBUG0(dict_collapse, "Cannot collapse");
+    CDEBUG0(xbt_dict_collapse, "Cannot collapse");

     return; /* cannot collapse */
   }
 
   child = xbt_dynar_get_as(head->sub, 0, xbt_dictelm_t);
 
   /* Get the child's key as new key */
     return; /* cannot collapse */
   }
 
   child = xbt_dynar_get_as(head->sub, 0, xbt_dictelm_t);
 
   /* Get the child's key as new key */

-  CDEBUG2(dict_collapse,
+  CDEBUG2(xbt_dict_collapse,

          "Do collapse with only child %.*s", child->key_len, child->key);
 
   head->content  = child->content;
          "Do collapse with only child %.*s", child->key_len, child->key);
 
   head->content  = child->content;

diff --git a/src/xbt/dict_multi.c b/src/xbt/dict_multi.c
index c317b81..90ff8bf 100644 (file)
--- a/src/xbt/dict_multi.c
+++ b/src/xbt/dict_multi.c
@@ -9,7 +9,7 @@
 
 #include "dict_private.h"
 
 
 #include "dict_private.h"
 

-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(dict_multi,dict, "Dictionaries of multiple keys");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict_multi,xbt_dict, "Dictionaries of multiple keys");

 
 static void _free_dict(void*d) {
   VERB1("free dict %p",d);
 
 static void _free_dict(void*d) {
   VERB1("free dict %p",d);

diff --git a/src/xbt/dynar.c b/src/xbt/dynar.c
index eeb022e..ede8618 100644 (file)
--- a/src/xbt/dynar.c
+++ b/src/xbt/dynar.c
@@ -18,7 +18,7 @@
 #include "xbt/dynar_private.h" /* type definition, which we share with the 
                                  code in charge of sending this across the net */
 
 #include "xbt/dynar_private.h" /* type definition, which we share with the 
                                  code in charge of sending this across the net */
 

-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(dynar,xbt,"Dynamic arrays");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dyn,xbt,"Dynamic arrays");

 
 
 #define __sanity_check_dynar(dynar)       \
 
 
 #define __sanity_check_dynar(dynar)       \


@@ -596,8 +596,8 @@ void xbt_dynar_cursor_rm(xbt_dynar_t dynar,
 #define NB_ELEM 5000
 
 XBT_TEST_SUITE("dynar","Dynar data container");
 #define NB_ELEM 5000
 
 XBT_TEST_SUITE("dynar","Dynar data container");

-XBT_LOG_EXTERNAL_CATEGORY(dynar);
-XBT_LOG_DEFAULT_CATEGORY(dynar);
+XBT_LOG_EXTERNAL_CATEGORY(xbt_dyn);
+XBT_LOG_DEFAULT_CATEGORY(xbt_dyn);

 
 XBT_TEST_UNIT("int",test_dynar_int,"Dyars of integers") {
    /* Vars_decl [doxygen cruft] */
 
 XBT_TEST_UNIT("int",test_dynar_int,"Dyars of integers") {
    /* Vars_decl [doxygen cruft] */

diff --git a/src/xbt/fifo.c b/src/xbt/fifo.c
index 252d2d1..2cd4f79 100644 (file)
--- a/src/xbt/fifo.c
+++ b/src/xbt/fifo.c
@@ -9,7 +9,7 @@
 #include "xbt/log.h"
 #include "fifo_private.h"
 
 #include "xbt/log.h"
 #include "fifo_private.h"
 

-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(fifo,xbt,"FIFO");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_fifo,xbt,"FIFO");

 
 /** Constructor
  * \return a new fifo
 
 /** Constructor
  * \return a new fifo

diff --git a/src/xbt/graph.c b/src/xbt/graph.c
index 025c5a5..61aee25 100644 (file)
--- a/src/xbt/graph.c
+++ b/src/xbt/graph.c
@@ -20,7 +20,7 @@
 
 
 
 
 
 

-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(graph, xbt, "Graph");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_graph, xbt, "Graph");

 
 
 
 
 
 

diff --git a/src/xbt/set.c b/src/xbt/set.c
index 1ba5dc2..9b58df2 100644 (file)
--- a/src/xbt/set.c
+++ b/src/xbt/set.c
@@ -16,7 +16,7 @@
 
 #include "xbt/set.h"
 
 
 #include "xbt/set.h"
 

-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(set,xbt,
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_set,xbt,

             "set: data container consisting in dict+dynar");
 
 /*####[ Type definition ]####################################################*/
             "set: data container consisting in dict+dynar");
 
 /*####[ Type definition ]####################################################*/


@@ -64,6 +64,8 @@ void xbt_set_add    (xbt_set_t      set,
   xbt_set_elm_t found_in_dict = NULL;
   xbt_ex_t e;
 
   xbt_set_elm_t found_in_dict = NULL;
   xbt_ex_t e;
 

+  DEBUG1("add %s to the set",elm->name);
+   

   if (elm->name_len <= 0) {
     elm->name_len = strlen(elm->name);
   }
   if (elm->name_len <= 0) {
     elm->name_len = strlen(elm->name);
   }