Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
cosmetics
[simgrid.git] / src / xbt / log.c
1 /* $Id$ */
2
3 /* log - a generic logging facility in the spirit of log4j                  */
4
5 /* Copyright (c) 2003, 2004 Martin Quinson. All rights reserved.            */
6
7 /* This program is free software; you can redistribute it and/or modify it
8  * under the terms of the license (GNU LGPL) which comes with this package. */
9
10 #include <stdarg.h>
11 #include <ctype.h>
12
13 #include "xbt_modinter.h"
14
15 #include "xbt/misc.h"
16 #include "xbt/sysdep.h"
17 #include "xbt/log.h"
18 #include "xbt/error.h"
19 #include "xbt/dynar.h"
20
21
22 /** \defgroup XBT_log Logging support.
23  *  \brief A generic logging facility in the spirit of log4j
24  *
25  *  This section describes the API to the log functions used 
26  *  everywhere in this project.
27      
28 <h3>Overview</h3>
29      
30 This is an adaptation of the log4c project, which is dead upstream, and
31 which I was given the permission to fork under the LGPL licence by the
32 authors. log4c itself was loosely based on the Apache project's Log4J,
33 Log4CC, etc. project. Because C is not object oriented, a lot had to change.
34     
35 There is 3 main concepts: category, priority and appender. These three
36 concepts work together to enable developers to log messages according to
37 message type and priority, and to control at runtime how these messages are
38 formatted and where they are reported.
39
40 <h3>Category hierarchy</h3>
41
42 The first and foremost advantage of any logging API over plain printf()
43 resides in its ability to disable certain log statements while allowing
44 others to print unhindered. This capability assumes that the logging space,
45 that is, the space of all possible logging statements, is categorized
46 according to some developer-chosen criteria. 
47           
48 This observation led to choosing category as the central concept of the
49 system. Every category is declared by providing a name and an optional
50 parent. If no parent is explicitly named, the root category, LOG_ROOT_CAT is
51 the category's parent. 
52       
53 A category is created by a macro call at the top level of a file.  A
54 category can be created with any one of the following macros:
55
56  - \ref XBT_LOG_NEW_CATEGORY(MyCat); Create a new root
57  - \ref XBT_LOG_NEW_SUBCATEGORY(MyCat, ParentCat);
58     Create a new category being child of the category ParentCat
59  - \ref XBT_LOG_NEW_DEFAULT_CATEGORY(MyCat);
60     Like XBT_LOG_NEW_CATEGORY, but the new category is the default one
61       in this file
62  -  \ref XBT_LOG_NEW_DEFAULT_SUBCATEGORY(MyCat, ParentCat);
63     Like XBT_LOG_NEW_SUBCATEGORY, but the new category is the default one
64       in this file
65             
66 The parent cat can be defined in the same file or in another file (in
67 which case you want to use the \ref XBT_LOG_EXTERNAL_CATEGORY macro to make
68 it visible in the current file), but each category may have only one
69 definition.
70       
71 Typically, there will be a Category for each module and sub-module, so you
72 can independently control logging for each module.
73
74 <h3>Priority</h3>
75
76 A category may be assigned a threshold priorty. The set of priorites are
77 defined by the \ref e_xbt_log_priority_t enum. All logging request under
78 this priority will be discarded.
79           
80 If a given category is not assigned a threshold priority, then it inherits
81 one from its closest ancestor with an assigned threshold. To ensure that all
82 categories can eventually inherit a threshold, the root category always has
83 an assigned threshold priority.
84
85 Logging requests are made by invoking a logging macro on a category.  All of
86 the macros have a printf-style format string followed by arguments. If you
87 compile with the -Wall option, gcc will warn you for unmatched arguments, ie
88 when you pass a pointer to a string where an integer was specified by the
89 format. This is usualy a good idea.
90
91 Because most C compilers do not support vararg macros, there is a version of
92 the macro for any number of arguments from 0 to 6. The macro name ends with
93 the total number of arguments.
94         
95 Here is an example of the most basic type of macro. This is a logging
96 request with priority <i>warning</i>.
97
98 <code>CLOG5(MyCat, gras_log_priority_warning, "Values are: %d and '%s'", 5,
99 "oops");</code>
100
101 A logging request is said to be enabled if its priority is higher than or
102 equal to the threshold priority of its category. Otherwise, the request is
103 said to be disabled. A category without an assigned priority will inherit
104 one from the hierarchy. 
105       
106 It is possible to use any non-negative integer as a priority. If, as in the
107 example, one of the standard priorites is used, then there is a convenience
108 macro that is typically used instead. For example, the above example is
109 equivalent to the shorter:
110
111 <code>CWARN4(MyCat, "Values are: %d and '%s'", 5, "oops");</code>
112
113 <h3>Default category</h3>
114   
115 If \ref XBT_LOG_NEW_DEFAULT_SUBCATEGORY(MyCat, Parent) or
116 \ref XBT_LOG_NEW_DEFAULT_CATEGORY(MyCat) is used to create the
117 category, then the even shorter form can be used:
118
119 <code>WARN3("Values are: %d and '%s'", 5, "oops");</code>
120
121 Only one default category can be created per file, though multiple
122 non-defaults can be created and used.
123
124 <h3>Example</h3>
125
126 Here is a more complete example:
127
128 \verbatim
129 #include "xbt/log.h"
130
131 / * create a category and a default subcategory * /
132 XBT_LOG_NEW_CATEGORY(VSS);
133 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(SA, VSS);
134
135 int main() {
136        / * Now set the parent's priority.  (the string would typcially be a runtime option) * /
137        xbt_log_control_set("SA.thresh=3");
138
139        / * This request is enabled, because WARNING &gt;= INFO. * /
140        CWARN2(VSS, "Low fuel level.");
141
142        / * This request is disabled, because DEBUG &lt; INFO. * /
143        CDEBUG2(VSS, "Starting search for nearest gas station.");
144
145        / * The default category SA inherits its priority from VSS. Thus,
146           the following request is enabled because INFO &gt;= INFO.  * /
147        INFO1("Located nearest gas station.");
148
149        / * This request is disabled, because DEBUG &lt; INFO. * /
150        DEBUG1("Exiting gas station search"); 
151 }
152 \endverbatim
153
154 <h3>Configuration</h3>
155 Configuration is typically done during program initialization by invoking
156 the xbt_log_control_set() method. The control string passed to it typically
157 comes from the command line. Look at the documentation for that function for
158 the format of the control string.
159
160 Any SimGrid program can furthermore be configured at run time by passing a
161 --xbt-log argument on the command line (--gras-log, --msg-log and
162 --surf-log are synonyms). You can provide several of those arguments to
163 change the setting of several categories.
164
165 <h3>Performance</h3>
166
167 Clever design insures efficiency. Except for the first invocation, a
168 disabled logging request requires an a single comparison of a static
169 variable to a constant.
170
171 There is also compile time constant, \ref XBT_LOG_STATIC_THRESHOLD, which
172 causes all logging requests with a lower priority to be optimized to 0 cost
173 by the compiler. By setting it to gras_log_priority_infinite, all logging
174 requests are statically disabled and cost nothing. Released executables
175 might be compiled with
176 \verbatim-DXBT_LOG_STATIC_THRESHOLD=gras_log_priority_infinite\endverbatim
177
178 Compiling with the \verbatim-DNLOG\endverbatim option disables all logging 
179 requests at compilation time while the \verbatim-DNDEBUG\endverbatim disables 
180 the requests of priority below INFO.
181  
182 <h3>Appenders</h3>
183
184 Each category has an optional appender. An appender is a pointer to a
185 structure which starts with a pointer to a doAppend() function. DoAppend()
186 prints a message to a log.
187
188 When a category is passed a message by one of the logging macros, the
189 category performs the following actions:
190
191   - if the category has an appender, the message is passed to the
192     appender's doAppend() function,
193   - if 'willLogToParent' is true for the category, the message is passed
194     to the category's parent.
195     
196 By default, only the root category have an appender, and 'willLogToParent'
197 is true for any other category. This situation causes all messages to be
198 logged by the root category's appender.
199
200 The default appender function currently prints to stderr, and no other one
201 exist, even if more would be needed, like the one able to send the logs to a
202 remote dedicated server, or other ones offering different output formats.
203 This is on our TODO list for quite a while now, but your help would be
204 welcome here.
205
206 <h3>Misc and Caveats</h3>
207
208   - Do not use any of the macros that start with '_'.
209   - Log4J has a 'rolling file appender' which you can select with a run-time
210     option and specify the max file size. This would be a nice default for
211     non-kernel applications.
212   - Careful, category names are global variables.
213
214 */
215
216 /*
217 FAIRE DES ZOLIS LOGS
218 --------------------
219 Dans gras, tu ne te contente pas d'écrire des choses à l'écran, mais tu
220 écris sur un sujet particulier (notion de canal) des choses d'une gravité
221 particulière. Il y a 7 niveaux de gravité.
222  trace: tracer les entrées dans une fonction, retour de fonction
223         (famille de macros XBT_IN/XBT_OUT)
224  debug: pour t'aider à mettre au point le module, potentiellement tres bavard
225  verbose: quelques infos succintes sur les internals du module
226  info: niveau normal, ton de la conversation
227  warning: problème potentiel, mais auquel on a su faire face
228  error: problème qui t'as empêché de faire ton job
229  critical: juste avant de mourir
230
231 Quand on compile avec -DNDEBUG (par défaut dans le paquet Debian), tout ce
232 qui est '>= verbose' est supprimé au moment de la compilation. Retiré du
233 binaire, killé.
234
235 Ensuite, tu écris dans un canal particulier. Tous les canaux sont rangés en
236 arbre. Il faudrait faire un ptit script qui fouille les sources à la
237 recherche des macros XBT_LOG_NEW_* utilisées pour créer des canaux. Le
238 dernier argument de ces macros est ignoré dans le source. Il est destiné à
239 être la documentation de la chose en une ligne. En gros, ca fait:
240 root
241  +--xbt
242  |   +--config
243  |   +--dict
244  |   |   +--dict_cursor
245  |   |   +--dict_elm
246  |   |   ...
247  |   +--dynar
248  |   +--set
249  |   +--log
250  |   +--module
251  +--gras
252      +--datadesc
253      |   +--ddt_cbps
254      |   +--ddt_convert
255      |   +--ddt_exchange
256      |   +--ddt_parse
257      |       +--lexer
258      +--msg
259      +--transport
260          +--raw_trp (Je devrais tuer ce module, un jour)
261          +--trp_buf
262          +--trp_sg
263          +--trp_file
264          +--trp_tcp
265          
266 Et ensuite les utilisateurs peuvent choisir le niveau de gravité qui les
267 interresse sur tel ou tel sujet.
268
269 Toute la mécanique de logging repose sur des variables statiques dont le nom
270 dépend du nom du canal.
271  => attention aux conflits de nom de canal
272  => il faut une macro XBT_LOG dans chaque fichier où tu fais des logs.
273  
274 XBT_LOG_NEW_CATEGORY: nouveau canal sous "root". Rare, donc.
275 XBT_LOG_NEW_SUBCATEGORY: nouveau canal dont on précise le père.
276 XBT_LOG_DEFAULT_CATEGORY: indique quel est le canal par défaut dans ce fichier
277 XBT_LOG_NEW_DEFAULT_CATEGORY: Crèe un canal et l'utilise par défaut
278 XBT_LOG_NEW_DEFAULT_SUBCATEGORY: devine
279 XBT_LOG_EXTERNAL_CATEGORY: quand tu veux utiliser par défaut un canal créé
280                            dans un autre fichier.
281
282 Une fois que ton canal est créé, tu l'utilise avec les macros LOG, DEBUG,
283 VERB, WARN, ERROR et CRITICAL. Il faut que tu donne le nombre d'arguments
284 après le nom de macro. Exemple: LOG2("My name is %s %s","Martin","Quinson")
285 Si tu veux préciser explicitement le canal où écrire, ajoute un C devant le
286 nom de la macro. Exemple: CCRITICAL0(module, "Cannot initialize GRAS")
287
288 Toutes ces macros (enfin, ce en quoi elles se réécrivent) vérifient leurs
289 arguments comme printf le fait lorsqu'on compile avec gcc. 
290 LOG1("name: %d","toto"); donne un warning, et donc une erreur en mode
291 mainteneur.
292
293 Enfin, tu peux tester si un canal est ouvert à une priorité donnée (pour
294 préparer plus de débug, par exemple. Dans le parseur, je fais du pretty
295 printing sur ce qu'il faut parser dans ce cas).
296 XBT_LOG_ISENABLED(catName, priority) Le second argument doit être une valeur
297 de e_xbt_log_priority_t (log.h). Par exemple: xbt_log_priority_verbose
298
299 Voila sur comment mettre des logs dans ton code. N'hesite pas à faire pleins
300 de canaux différents pour des aspects différents de ton code. En
301 particulier, dans les dict, j'ai un canal pour l'ajout, le retrait, le
302 netoyage du code après suppression et ainsi de suite. De cette façon, je
303 peux choisir qui m'interresse.
304
305
306 Pour utiliser les logs, tu déjà faire, non ? Tu colle sur la ligne de
307 commande un ou plusieurs arguments de la forme
308   --gras-log="<réglage> [<reglage>+]" (ou sans " si t'as pas d'espace)
309 chaque réglage étant de la forme:
310   <canal>.thres=<priorité>
311 Les différents réglages sont lus de gauche à droite.
312 "root.thres=debug root.thres=critical" ferme tout, normalement.
313
314 */
315
316 typedef struct {
317   char *catname;
318   e_xbt_log_priority_t thresh;
319 } s_xbt_log_setting_t,*xbt_log_setting_t;
320
321 static xbt_dynar_t xbt_log_settings=NULL;
322 static void _free_setting(void *s) {
323   xbt_log_setting_t set=(xbt_log_setting_t)s;
324   if (set) {
325     xbt_free(set->catname);
326 /*    xbt_free(set); FIXME: uncommenting this leads to segfault when more than one chunk is passed as gras-log */
327   }
328 }
329
330 const char *xbt_log_priority_names[8] = {
331   "NONE",
332   "TRACE",
333   "DEBUG",
334   "VERBOSE",
335   "INFO",
336   "WARNING",
337   "ERROR",
338   "CRITICAL"
339 };
340
341 s_xbt_log_category_t _XBT_LOGV(XBT_LOG_ROOT_CAT) = {
342   0, 0, 0,
343   "root", xbt_log_priority_uninitialized, 0,
344   NULL, 0
345 };
346
347 XBT_LOG_NEW_SUBCATEGORY(xbt,XBT_LOG_ROOT_CAT,"All XBT categories (simgrid toolbox)");
348 XBT_LOG_NEW_SUBCATEGORY(surf,XBT_LOG_ROOT_CAT,"All SURF categories");
349 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(log,xbt,"Loggings from the logging mecanism itself");
350
351 void xbt_log_init(int *argc,char **argv, const char *defaultlog) {
352   int i,j;
353   char *opt;
354   int found=0;
355
356   /* Set logs and init log submodule */
357   for (i=1; i<*argc; i++) {
358     if (!strncmp(argv[i],"--gras-log=",strlen("--gras-log=")) ||
359         !strncmp(argv[i],"--surf-log=",strlen("--surf-log=")) ||
360         !strncmp(argv[i],"--msg-log=",strlen("--msg-log=")) ||
361         !strncmp(argv[i],"--xbt-log=",strlen("--xbt-log="))) {
362       found = 1;
363       opt=strchr(argv[i],'=');
364       opt++;
365       xbt_log_control_set(opt);
366       DEBUG1("Did apply '%s' as log setting",opt);
367       /*remove this from argv*/
368       for (j=i+1; j<*argc; j++) {
369         argv[j-1] = argv[j];
370       } 
371       argv[j-1] = NULL;
372       (*argc)--;
373       i--; /* compensate effect of next loop incrementation */
374     }
375   }
376   if (!found && defaultlog) {
377      xbt_log_control_set(defaultlog);
378   }
379 }
380
381 void xbt_log_exit(void) {
382   VERB0("Exiting log");
383   xbt_dynar_free(&xbt_log_settings);
384   VERB0("Exited log");
385 }
386
387 static void _apply_control(xbt_log_category_t cat) {
388   int cursor;
389   xbt_log_setting_t setting=NULL;
390   int found = 0;
391
392   if (!xbt_log_settings)
393     return;
394
395   xbt_assert0(cat,"NULL category");
396   xbt_assert(cat->name);
397
398   xbt_dynar_foreach(xbt_log_settings,cursor,setting) {
399     xbt_assert0(setting,"Damnit, NULL cat in the list");
400     xbt_assert1(setting->catname,"NULL setting(=%p)->catname",(void*)setting);
401
402     if (!strcmp(setting->catname,cat->name)) {
403       found = 1;
404
405       xbt_log_threshold_set(cat, setting->thresh);
406       xbt_dynar_cursor_rm(xbt_log_settings,&cursor);
407
408       if (cat->threshold <= xbt_log_priority_verbose) {
409         s_xbt_log_event_t _log_ev = 
410           {cat,xbt_log_priority_verbose,__FILE__,_XBT_GNUC_FUNCTION,__LINE__};
411         _xbt_log_event_log(&_log_ev,
412                  "Apply settings for category '%s': set threshold to %s (=%d)",
413                  cat->name, 
414                  xbt_log_priority_names[cat->threshold], cat->threshold);
415       }
416     }
417   }
418   if (!found && cat->threshold <= xbt_log_priority_verbose) {
419     s_xbt_log_event_t _log_ev = 
420       {cat,xbt_log_priority_verbose,__FILE__,_XBT_GNUC_FUNCTION,__LINE__};
421     _xbt_log_event_log(&_log_ev,
422                         "Category '%s': inherited threshold = %s (=%d)",
423                         cat->name,
424                         xbt_log_priority_names[cat->threshold], cat->threshold);
425   }
426
427 }
428
429 void _xbt_log_event_log( xbt_log_event_t ev, const char *fmt, ...) {
430   xbt_log_category_t cat = ev->cat;
431   va_start(ev->ap, fmt);
432   while(1) {
433     xbt_log_appender_t appender = cat->appender;
434     if (appender != NULL) {
435       appender->do_append(appender, ev, fmt);
436     }
437     if (!cat->willLogToParent)
438       break;
439
440     cat = cat->parent;
441   } 
442   va_end(ev->ap);
443 }
444
445 static void _cat_init(xbt_log_category_t category) {
446   if (category == &_XBT_LOGV(XBT_LOG_ROOT_CAT)) {
447     category->threshold = xbt_log_priority_info;
448     category->appender = xbt_log_default_appender;
449   } else {
450     xbt_log_parent_set(category, category->parent);
451   }
452   _apply_control(category);
453 }
454
455 /*
456  * This gets called the first time a category is referenced and performs the
457  * initialization. 
458  * Also resets threshold to inherited!
459  */
460 int _xbt_log_cat_init(e_xbt_log_priority_t priority,
461                        xbt_log_category_t   category) {
462     
463   _cat_init(category);
464         
465   return priority >= category->threshold;
466 }
467
468 void xbt_log_parent_set(xbt_log_category_t cat,
469                          xbt_log_category_t parent) {
470
471   xbt_assert0(cat,"NULL category to be given a parent");
472   xbt_assert1(parent,"The parent category of %s is NULL",cat->name);
473
474   /* unlink from current parent */
475   if (cat->threshold != xbt_log_priority_uninitialized) {
476     xbt_log_category_t* cpp = &parent->firstChild;
477     while(*cpp != cat && *cpp != NULL) {
478       cpp = &(*cpp)->nextSibling;
479     }
480     xbt_assert(*cpp == cat);
481     *cpp = cat->nextSibling;
482   }
483
484   /* Set new parent */
485   cat->parent = parent;
486   cat->nextSibling = parent->firstChild;
487   parent->firstChild = cat;
488
489   /* Make sure parent is initialized */
490   if (parent->threshold == xbt_log_priority_uninitialized) {
491     _cat_init(parent);
492   }
493     
494   /* Reset priority */
495   cat->threshold = parent->threshold;
496   cat->isThreshInherited = 1;
497 } /* log_setParent */
498
499 static void _set_inherited_thresholds(xbt_log_category_t cat) {
500   xbt_log_category_t child = cat->firstChild;
501   for( ; child != NULL; child = child->nextSibling) {
502     if (child->isThreshInherited) {
503       if (cat != &_XBT_LOGV(log))
504         VERB3("Set category threshold of %s to %s (=%d)",
505               child->name,xbt_log_priority_names[cat->threshold],cat->threshold);
506       child->threshold = cat->threshold;
507       _set_inherited_thresholds(child);
508     }
509   }
510 }
511
512 void xbt_log_threshold_set(xbt_log_category_t   cat,
513                             e_xbt_log_priority_t threshold) {
514   cat->threshold = threshold;
515   cat->isThreshInherited = 0;
516   _set_inherited_thresholds(cat);
517 }
518
519 static void _xbt_log_parse_setting(const char*        control_string,
520                                     xbt_log_setting_t set) {
521   const char *name, *dot, *eq;
522   
523   set->catname=NULL;
524   if (!*control_string) 
525     return;
526   DEBUG1("Parse log setting '%s'",control_string);
527
528   control_string += strspn(control_string, " ");
529   name = control_string;
530   control_string += strcspn(control_string, ".= ");
531   dot = control_string;
532   control_string += strcspn(control_string, "= ");
533   eq = control_string;
534   control_string += strcspn(control_string, " ");
535
536   xbt_assert1(*dot == '.' && *eq == '=',
537                "Invalid control string '%s'",control_string);
538
539   if (!strncmp(dot + 1, "thresh", min(eq - dot - 1,strlen("thresh")))) {
540     int i;
541     char *neweq=xbt_strdup(eq+1);
542     char *p=neweq-1;
543     
544     while (*(++p) != '\0') {
545       if (*p >= 'a' && *p <= 'z') {
546         *p-='a'-'A';
547       }
548     }
549     
550     DEBUG1("New priority name = %s",neweq);
551     for (i=0; i<xbt_log_priority_infinite-1; i++) {
552       if (!strncmp(xbt_log_priority_names[i],neweq,p-eq)) {
553         DEBUG1("This is priority %d",i);
554         break;
555       }
556     }
557     if (i<xbt_log_priority_infinite-1) {
558       set->thresh=i;
559     } else {
560       xbt_assert1(FALSE,"Unknown priority name: %s",eq+1);
561     }
562     xbt_free(neweq);
563   } else {
564     char buff[512];
565     snprintf(buff,min(512,eq - dot - 1),"%s",dot+1);
566     xbt_assert1(FALSE,"Unknown setting of the log category: %s",buff);
567   }
568   set->catname=(char*)xbt_malloc(dot - name+1);
569     
570   strncpy(set->catname,name,dot-name);
571   set->catname[dot-name]='\0'; /* Just in case */
572   DEBUG1("This is for cat '%s'", set->catname);
573 }
574
575 static xbt_error_t _xbt_log_cat_searchsub(xbt_log_category_t cat,char *name,
576                                             /*OUT*/xbt_log_category_t*whereto) {
577   xbt_error_t errcode;
578   xbt_log_category_t child;
579   
580   if (!strcmp(cat->name,name)) {
581     *whereto=cat;
582     return no_error;
583   }
584   for(child=cat->firstChild ; child != NULL; child = child->nextSibling) {
585     errcode=_xbt_log_cat_searchsub(child,name,whereto);
586     if (errcode==no_error)
587       return no_error;
588   }
589   return mismatch_error;
590 }
591
592 static void _cleanup_double_spaces(char *s) {
593   char *p = s;
594   int   e = 0;
595   
596   while (1) {
597     if (!*p)
598       goto end;
599     
600     if (!isspace(*p))
601       break;
602     
603     p++;
604   }
605   
606   e = 1;
607   
608   do {
609     if (e)
610       *s++ = *p;
611     
612     if (!*++p)
613       goto end;
614     
615     if (e ^ !isspace(*p))
616       if ((e = !e))
617         *s++ = ' ';
618   } while (1);
619
620  end:
621   *s = '\0';
622 }
623
624 /**
625  * \ingroup XBT_log  
626  * \param control_string What to parse
627  *
628  * Typically passed a command-line argument. The string has the syntax:
629  *
630  *      ( [category] "." [keyword] "=" value (" ")... )...
631  *
632  * where [category] is one the category names and keyword is one of the
633  * following:
634  *
635  *      thresh          value is an integer priority level. Sets the category's
636  *                        threshold priority.
637  *
638  * \warning
639  * This routine may only be called once and that must be before any other
640  * logging command! Typically, this is done from main().
641  */
642 void xbt_log_control_set(const char* control_string) {
643   xbt_error_t errcode;
644   xbt_log_setting_t set;
645   char *cs;
646   char *p;
647   int done = 0;
648   
649   DEBUG1("Parse log settings '%s'",control_string);
650   if (control_string == NULL)
651     return;
652   if (xbt_log_settings == NULL)
653     xbt_log_settings = xbt_dynar_new(sizeof(xbt_log_setting_t),
654                                        _free_setting);
655
656   set = xbt_new(s_xbt_log_setting_t,1);
657   cs=xbt_strdup(control_string);
658
659   _cleanup_double_spaces(cs);
660
661   while (!done) {
662     xbt_log_category_t cat;
663     
664     p=strrchr(cs,' ');
665     if (p) {
666       *p='\0';
667       *p++;
668     } else {
669       p=cs;
670       done = 1;
671     }
672     _xbt_log_parse_setting(p,set);
673     
674     errcode = _xbt_log_cat_searchsub(&_XBT_LOGV(root),set->catname,&cat);
675     if (errcode == mismatch_error) {
676       DEBUG0("Store for further application");
677       DEBUG1("push %p to the settings",(void*)set);
678       xbt_dynar_push(xbt_log_settings,&set);
679       /* malloc in advance the next slot */
680       set = xbt_new(s_xbt_log_setting_t,1);
681     } else {
682       DEBUG0("Apply directly");
683       xbt_free(set->catname);
684       xbt_log_threshold_set(cat,set->thresh);
685     }
686   }
687   xbt_free(set);
688   xbt_free(cs);
689
690
691 void xbt_log_appender_set(xbt_log_category_t cat, xbt_log_appender_t app) {
692   cat->appender = app;
693 }
694