Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Kill outdated comment.
[simgrid.git] / src / xbt / log.cpp
1 /* log - a generic logging facility in the spirit of log4j                  */
2
3 /* Copyright (c) 2004-2019. The SimGrid Team. All rights reserved.          */
4
5 /* This program is free software; you can redistribute it and/or modify it
6  * under the terms of the license (GNU LGPL) which comes with this package. */
7
8 #include "src/xbt_modinter.h"
9 #include "src/xbt/log_private.hpp"
10 #include "xbt/asserts.h"
11 #include "xbt/dynar.h"
12 #include "xbt/str.h"
13
14 #include <algorithm>
15 #include <mutex>
16 #include <string>
17 #include <vector>
18
19 int xbt_log_no_loc = 0; /* if set to true (with --log=no_loc), file localization will be omitted (for tesh tests) */
20 static std::recursive_mutex* log_cat_init_mutex = nullptr;
21
22 /** @addtogroup XBT_log
23  *
24  *  For more information, please refer to @ref outcomes_logs Section.
25  */
26
27 xbt_log_appender_t xbt_log_default_appender = nullptr; /* set in log_init */
28 xbt_log_layout_t xbt_log_default_layout     = nullptr; /* set in log_init */
29
30 struct xbt_log_setting_t {
31   std::string catname;
32   std::string fmt;
33   e_xbt_log_priority_t thresh = xbt_log_priority_uninitialized;
34   int additivity              = -1;
35   xbt_log_appender_t appender = nullptr;
36 };
37
38 static std::vector<xbt_log_setting_t> xbt_log_settings;
39
40 const char *xbt_log_priority_names[8] = {
41   "NONE",
42   "TRACE",
43   "DEBUG",
44   "VERBOSE",
45   "INFO",
46   "WARNING",
47   "ERROR",
48   "CRITICAL"
49 };
50
51 s_xbt_log_category_t _XBT_LOGV(XBT_LOG_ROOT_CAT) = {
52     nullptr /*parent */,
53     nullptr /* firstChild */,
54     nullptr /* nextSibling */,
55     "root",
56     "The common ancestor for all categories",
57     0 /*initialized */,
58     xbt_log_priority_uninitialized /* threshold */,
59     0 /* isThreshInherited */,
60     nullptr /* appender */,
61     nullptr /* layout */,
62     0 /* additivity */
63 };
64
65 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(log, xbt, "Loggings from the logging mechanism itself");
66
67 /* create the default appender and install it in the root category,
68    which were already created (damnit. Too slow little beetle) */
69 void xbt_log_preinit(void)
70 {
71   xbt_log_default_appender             = xbt_log_appender_file_new(nullptr);
72   xbt_log_default_layout               = xbt_log_layout_simple_new(nullptr);
73   _XBT_LOGV(XBT_LOG_ROOT_CAT).appender = xbt_log_default_appender;
74   _XBT_LOGV(XBT_LOG_ROOT_CAT).layout = xbt_log_default_layout;
75   log_cat_init_mutex                   = new std::recursive_mutex();
76 }
77
78 static void xbt_log_help(void);
79 static void xbt_log_help_categories(void);
80
81 /** @brief Get all logging settings from the command line
82  *
83  * xbt_log_control_set() is called on each string we got from cmd line
84  */
85 void xbt_log_init(int *argc, char **argv)
86 {
87   unsigned help_requested = 0;  /* 1: logs; 2: categories */
88   int j                   = 1;
89   int parse_args          = 1; // Stop parsing the parameters once we found '--'
90
91   /* Set logs and init log submodule */
92   for (int i = 1; i < *argc; i++) {
93     if (strcmp("--", argv[i]) == 0) {
94       parse_args = 0;
95       argv[j++]  = argv[i]; // Keep the '--' for sg_config
96     } else if (parse_args && strncmp(argv[i], "--log=", strlen("--log=")) == 0) {
97       char* opt = strchr(argv[i], '=');
98       opt++;
99       xbt_log_control_set(opt);
100       XBT_DEBUG("Did apply '%s' as log setting", opt);
101     } else if (parse_args && strcmp(argv[i], "--help-logs") == 0) {
102       help_requested |= 1U;
103     } else if (parse_args && strcmp(argv[i], "--help-log-categories") == 0) {
104       help_requested |= 2U;
105     } else {
106       argv[j++] = argv[i];
107     }
108   }
109   if (j < *argc) {
110     argv[j] = nullptr;
111     *argc = j;
112   }
113
114   if (help_requested) {
115     if (help_requested & 1)
116       xbt_log_help();
117     if (help_requested & 2)
118       xbt_log_help_categories();
119     exit(0);
120   }
121 }
122
123 static void log_cat_exit(xbt_log_category_t cat)
124 {
125   xbt_log_category_t child;
126
127   if (cat->appender) {
128     if (cat->appender->free_)
129       cat->appender->free_(cat->appender);
130     xbt_free(cat->appender);
131   }
132   if (cat->layout) {
133     if (cat->layout->free_)
134       cat->layout->free_(cat->layout);
135     xbt_free(cat->layout);
136   }
137
138   for (child = cat->firstChild; child != nullptr; child = child->nextSibling)
139     log_cat_exit(child);
140 }
141
142 void xbt_log_postexit(void)
143 {
144   XBT_VERB("Exiting log");
145   delete log_cat_init_mutex;
146   log_cat_exit(&_XBT_LOGV(XBT_LOG_ROOT_CAT));
147 }
148
149 /* Size of the static string in which we build the log string */
150 static constexpr size_t XBT_LOG_STATIC_BUFFER_SIZE = 2048;
151 /* Minimum size of the dynamic string in which we build the log string
152    (should be greater than XBT_LOG_STATIC_BUFFER_SIZE) */
153 static constexpr size_t XBT_LOG_DYNAMIC_BUFFER_SIZE = 4096;
154
155 void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...)
156 {
157   xbt_log_category_t cat = ev->cat;
158
159   xbt_assert(ev->priority >= 0, "Negative logging priority naturally forbidden");
160   xbt_assert(static_cast<size_t>(ev->priority) < sizeof(xbt_log_priority_names)/sizeof(xbt_log_priority_names[0]),
161              "Priority %d is greater than the biggest allowed value", ev->priority);
162
163   while (1) {
164     xbt_log_appender_t appender = cat->appender;
165
166     if (appender != nullptr) {
167       xbt_assert(cat->layout, "No valid layout for the appender of category %s", cat->name);
168
169       /* First, try with a static buffer */
170       int done = 0;
171       char buff[XBT_LOG_STATIC_BUFFER_SIZE];
172       ev->buffer      = buff;
173       ev->buffer_size = sizeof buff;
174       va_start(ev->ap, fmt);
175       done = cat->layout->do_layout(cat->layout, ev, fmt);
176       va_end(ev->ap);
177       if (done) {
178         appender->do_append(appender, buff);
179       } else {
180
181         /* The static buffer was too small, use a dynamically expanded one */
182         ev->buffer_size = XBT_LOG_DYNAMIC_BUFFER_SIZE;
183         ev->buffer      = static_cast<char*>(xbt_malloc(ev->buffer_size));
184         while (1) {
185           va_start(ev->ap, fmt);
186           done = cat->layout->do_layout(cat->layout, ev, fmt);
187           va_end(ev->ap);
188           if (done)
189             break; /* Got it */
190           ev->buffer_size *= 2;
191           ev->buffer = static_cast<char*>(xbt_realloc(ev->buffer, ev->buffer_size));
192         }
193         appender->do_append(appender, ev->buffer);
194         xbt_free(ev->buffer);
195       }
196     }
197
198     if (!cat->additivity)
199       break;
200     cat = cat->parent;
201   }
202 }
203
204 /* NOTE:
205  *
206  * The standard logging macros use _XBT_LOG_ISENABLED, which calls _xbt_log_cat_init().  Thus, if we want to avoid an
207  * infinite recursion, we can not use the standard logging macros in _xbt_log_cat_init(), and in all functions called
208  * from it.
209  *
210  * To circumvent the problem, we define the macro DISABLE_XBT_LOG_CAT_INIT() to hide the real _xbt_log_cat_init(). The
211  * macro has to be called at the beginning of the affected functions.
212  */
213 static int fake_xbt_log_cat_init(xbt_log_category_t, e_xbt_log_priority_t)
214 {
215   return 0;
216 }
217 #define DISABLE_XBT_LOG_CAT_INIT()                                                                                     \
218   int (*_xbt_log_cat_init)(xbt_log_category_t, e_xbt_log_priority_t) XBT_ATTRIB_UNUSED = fake_xbt_log_cat_init;
219
220 static void _xbt_log_cat_apply_set(xbt_log_category_t category, const xbt_log_setting_t& setting)
221 {
222   DISABLE_XBT_LOG_CAT_INIT();
223   if (setting.thresh != xbt_log_priority_uninitialized) {
224     xbt_log_threshold_set(category, setting.thresh);
225
226     XBT_DEBUG("Apply settings for category '%s': set threshold to %s (=%d)",
227            category->name, xbt_log_priority_names[category->threshold], category->threshold);
228   }
229
230   if (not setting.fmt.empty()) {
231     xbt_log_layout_set(category, xbt_log_layout_format_new(setting.fmt.c_str()));
232
233     XBT_DEBUG("Apply settings for category '%s': set format to %s", category->name, setting.fmt.c_str());
234   }
235
236   if (setting.additivity != -1) {
237     xbt_log_additivity_set(category, setting.additivity);
238
239     XBT_DEBUG("Apply settings for category '%s': set additivity to %s", category->name,
240               (setting.additivity ? "on" : "off"));
241   }
242   if (setting.appender) {
243     xbt_log_appender_set(category, setting.appender);
244     if (!category->layout)
245       xbt_log_layout_set(category, xbt_log_layout_simple_new(nullptr));
246     category->additivity = 0;
247     XBT_DEBUG("Set %p as appender of category '%s'", setting.appender, category->name);
248   }
249 }
250
251 /*
252  * This gets called the first time a category is referenced and performs the initialization.
253  * Also resets threshold to inherited!
254  */
255 int _xbt_log_cat_init(xbt_log_category_t category, e_xbt_log_priority_t priority)
256 {
257   DISABLE_XBT_LOG_CAT_INIT();
258   if (category->initialized)
259     return priority >= category->threshold;
260
261   if (log_cat_init_mutex != nullptr)
262     log_cat_init_mutex->lock();
263
264   XBT_DEBUG("Initializing category '%s' (firstChild=%s, nextSibling=%s)", category->name,
265          (category->firstChild ? category->firstChild->name : "none"),
266          (category->nextSibling ? category->nextSibling->name : "none"));
267
268   if (category == &_XBT_LOGV(XBT_LOG_ROOT_CAT)) {
269     category->threshold = xbt_log_priority_info;
270     category->appender = xbt_log_default_appender;
271     category->layout = xbt_log_default_layout;
272   } else {
273     if (!category->parent)
274       category->parent = &_XBT_LOGV(XBT_LOG_ROOT_CAT);
275
276     XBT_DEBUG("Set %s (%s) as father of %s ", category->parent->name,
277            (category->parent->initialized ? xbt_log_priority_names[category->parent->threshold] : "uninited"),
278            category->name);
279     xbt_log_parent_set(category, category->parent);
280
281     if (XBT_LOG_ISENABLED(log, xbt_log_priority_debug)) {
282       std::string res;
283       xbt_log_category_t cpp = category->parent->firstChild;
284       while (cpp) {
285         res += std::string(" ") + cpp->name;
286         cpp = cpp->nextSibling;
287       }
288
289       XBT_DEBUG("Children of %s:%s; nextSibling: %s", category->parent->name, res.c_str(),
290                 (category->parent->nextSibling ? category->parent->nextSibling->name : "none"));
291     }
292   }
293
294   /* Apply the control */
295   auto iset = std::find_if(begin(xbt_log_settings), end(xbt_log_settings),
296                            [category](const xbt_log_setting_t& s) { return s.catname == category->name; });
297   if (iset != xbt_log_settings.end()) {
298     _xbt_log_cat_apply_set(category, *iset);
299     xbt_log_settings.erase(iset);
300   } else {
301     XBT_DEBUG("Category '%s': inherited threshold = %s (=%d)", category->name,
302               xbt_log_priority_names[category->threshold], category->threshold);
303   }
304
305   category->initialized = 1;
306   if (log_cat_init_mutex != nullptr)
307     log_cat_init_mutex->unlock();
308   return priority >= category->threshold;
309 }
310
311 void xbt_log_parent_set(xbt_log_category_t cat, xbt_log_category_t parent)
312 {
313   xbt_assert(cat, "NULL category to be given a parent");
314   xbt_assert(parent, "The parent category of %s is NULL", cat->name);
315
316   /* if the category is initialized, unlink from current parent */
317   if (cat->initialized) {
318     xbt_log_category_t *cpp = &cat->parent->firstChild;
319
320     while (*cpp != cat && *cpp != nullptr) {
321       cpp = &(*cpp)->nextSibling;
322     }
323
324     xbt_assert(*cpp == cat);
325     *cpp = cat->nextSibling;
326   }
327
328   cat->parent = parent;
329   cat->nextSibling = parent->firstChild;
330
331   parent->firstChild = cat;
332
333   if (!parent->initialized)
334     _xbt_log_cat_init(parent, xbt_log_priority_uninitialized /* ignored */ );
335
336   cat->threshold = parent->threshold;
337
338   cat->isThreshInherited = 1;
339 }
340
341 static void _set_inherited_thresholds(xbt_log_category_t cat)
342 {
343   xbt_log_category_t child = cat->firstChild;
344
345   for (; child != nullptr; child = child->nextSibling) {
346     if (child->isThreshInherited) {
347       if (cat != &_XBT_LOGV(log))
348         XBT_VERB("Set category threshold of %s to %s (=%d)",
349               child->name, xbt_log_priority_names[cat->threshold], cat->threshold);
350       child->threshold = cat->threshold;
351       _set_inherited_thresholds(child);
352     }
353   }
354 }
355
356 void xbt_log_threshold_set(xbt_log_category_t cat, e_xbt_log_priority_t threshold)
357 {
358   cat->threshold = threshold;
359   cat->isThreshInherited = 0;
360
361   _set_inherited_thresholds(cat);
362 }
363
364 static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string)
365 {
366   const char *orig_control_string = control_string;
367   xbt_log_setting_t set;
368
369   if (!*control_string)
370     return set;
371   XBT_DEBUG("Parse log setting '%s'", control_string);
372
373   control_string += strspn(control_string, " ");
374   const char* name = control_string;
375   control_string += strcspn(control_string, ".:= ");
376   const char* option = control_string;
377   control_string += strcspn(control_string, ":= ");
378   const char* value = control_string;
379
380   xbt_assert(*option == '.' && (*value == '=' || *value == ':'), "Invalid control string '%s'", orig_control_string);
381
382   size_t name_len = option - name;
383   ++option;
384   size_t option_len = value - option;
385   ++value;
386
387   if (strncmp(option, "threshold", option_len) == 0) {
388     XBT_DEBUG("New priority name = %s", value);
389     int i;
390     for (i = 0; i < xbt_log_priority_infinite; i++) {
391       if (strcasecmp(value, xbt_log_priority_names[i]) == 0) {
392         XBT_DEBUG("This is priority %d", i);
393         break;
394       }
395     }
396
397     if(i<XBT_LOG_STATIC_THRESHOLD){
398       fprintf(stderr, "Priority '%s' (in setting '%s') is above allowed priority '%s'.\n\n"
399                       "Compiling SimGrid with -DNDEBUG forbids the levels 'trace' and 'debug'\n"
400                       "while -DNLOG forbids any logging, at any level.",
401               value, name, xbt_log_priority_names[XBT_LOG_STATIC_THRESHOLD]);
402       exit(1);
403     }else if (i < xbt_log_priority_infinite) {
404       set.thresh = (e_xbt_log_priority_t)i;
405     } else {
406       THROWF(arg_error, 0,
407              "Unknown priority name: %s (must be one of: trace,debug,verbose,info,warning,error,critical)", value);
408     }
409   } else if (strncmp(option, "additivity", option_len) == 0) {
410     if (strcasecmp(value, "ON") == 0 || strcasecmp(value, "YES") == 0 || strcmp(value, "1") == 0) {
411       set.additivity = 1;
412     } else {
413       set.additivity = 0;
414     }
415   } else if (strncmp(option, "appender", option_len) == 0) {
416     if (strncmp(value, "file:", 5) == 0) {
417       set.appender = xbt_log_appender_file_new(value + 5);
418     } else if (strncmp(value, "rollfile:", 9) == 0) {
419       set.appender = xbt_log_appender2_file_new(value + 9, 1);
420     } else if (strncmp(value, "splitfile:", 10) == 0) {
421       set.appender = xbt_log_appender2_file_new(value + 10, 0);
422     } else {
423       THROWF(arg_error, 0, "Unknown appender log type: '%s'", value);
424     }
425   } else if (strncmp(option, "fmt", option_len) == 0) {
426     set.fmt = std::string(value);
427   } else {
428     xbt_die("Unknown setting of the log category: '%.*s'", static_cast<int>(option_len), option);
429   }
430   set.catname = std::string(name, name_len);
431
432   XBT_DEBUG("This is for cat '%s'", set.catname.c_str());
433
434   return set;
435 }
436
437 static xbt_log_category_t _xbt_log_cat_searchsub(xbt_log_category_t cat, const char* name)
438 {
439   xbt_log_category_t child;
440   xbt_log_category_t res;
441
442   XBT_DEBUG("Search '%s' into '%s' (firstChild='%s'; nextSibling='%s')", name,
443          cat->name, (cat->firstChild ? cat->firstChild->name : "none"),
444          (cat->nextSibling ? cat->nextSibling->name : "none"));
445   if (strcmp(cat->name, name) == 0)
446     return cat;
447
448   for (child = cat->firstChild; child != nullptr; child = child->nextSibling) {
449     XBT_DEBUG("Dig into %s", child->name);
450     res = _xbt_log_cat_searchsub(child, name);
451     if (res)
452       return res;
453   }
454
455   return nullptr;
456 }
457
458 /**
459  * @ingroup XBT_log
460  * @param control_string What to parse
461  *
462  * Typically passed a command-line argument. The string has the syntax:
463  *
464  *      ( [category] "." [keyword] ":" value (" ")... )...
465  *
466  * where [category] is one the category names (see @ref XBT_log_cats for a complete list of the ones defined in the
467  * SimGrid library) and keyword is one of the following:
468  *
469  *    - thres: category's threshold priority. Possible values:
470  *             TRACE,DEBUG,VERBOSE,INFO,WARNING,ERROR,CRITICAL
471  *    - add or additivity: whether the logging actions must be passed to the parent category.
472  *      Possible values: 0, 1, no, yes, on, off.
473  *      Default value: yes.
474  *    - fmt: the format to use. See @ref log_use_conf_fmt for more information.
475  *    - app or appender: the appender to use. See @ref log_use_conf_app for more information.
476  */
477 void xbt_log_control_set(const char *control_string)
478 {
479   /* To split the string in commands, and the cursors */
480   xbt_dynar_t set_strings;
481   char *str;
482   unsigned int cpt;
483
484   if (!control_string)
485     return;
486   XBT_DEBUG("Parse log settings '%s'", control_string);
487
488   /* Special handling of no_loc request, which asks for any file localization to be omitted (for tesh runs) */
489   if (strcmp(control_string, "no_loc") == 0) {
490     xbt_log_no_loc = 1;
491     return;
492   }
493   /* split the string, and remove empty entries */
494   set_strings = xbt_str_split_quoted(control_string);
495
496   if (xbt_dynar_is_empty(set_strings)) {     /* vicious user! */
497     xbt_dynar_free(&set_strings);
498     return;
499   }
500
501   /* Parse each entry and either use it right now (if the category was already created), or store it for further use */
502   xbt_dynar_foreach(set_strings, cpt, str) {
503     xbt_log_setting_t set  = _xbt_log_parse_setting(str);
504     xbt_log_category_t cat = _xbt_log_cat_searchsub(&_XBT_LOGV(XBT_LOG_ROOT_CAT), set.catname.c_str());
505
506     if (cat) {
507       XBT_DEBUG("Apply directly");
508       _xbt_log_cat_apply_set(cat, set);
509     } else {
510       XBT_DEBUG("Store for further application");
511       XBT_DEBUG("push %p to the settings", &set);
512       xbt_log_settings.emplace_back(std::move(set));
513     }
514   }
515   xbt_dynar_free(&set_strings);
516 }
517
518 void xbt_log_appender_set(xbt_log_category_t cat, xbt_log_appender_t app)
519 {
520   if (cat->appender) {
521     if (cat->appender->free_)
522       cat->appender->free_(cat->appender);
523     xbt_free(cat->appender);
524   }
525   cat->appender = app;
526 }
527
528 void xbt_log_layout_set(xbt_log_category_t cat, xbt_log_layout_t lay)
529 {
530   DISABLE_XBT_LOG_CAT_INIT();
531   if (!cat->appender) {
532     XBT_VERB ("No appender to category %s. Setting the file appender as default", cat->name);
533     xbt_log_appender_set(cat, xbt_log_appender_file_new(nullptr));
534   }
535   if (cat->layout) {
536     if (cat->layout->free_) {
537       cat->layout->free_(cat->layout);
538     }
539     xbt_free(cat->layout);
540   }
541   cat->layout = lay;
542   xbt_log_additivity_set(cat, 0);
543 }
544
545 void xbt_log_additivity_set(xbt_log_category_t cat, int additivity)
546 {
547   cat->additivity = additivity;
548 }
549
550 static void xbt_log_help(void)
551 {
552   printf("Description of the logging output:\n"
553          "\n"
554          "   Threshold configuration: --log=CATEGORY_NAME.thres:PRIORITY_LEVEL\n"
555          "      CATEGORY_NAME: defined in code with function 'XBT_LOG_NEW_CATEGORY'\n"
556          "      PRIORITY_LEVEL: the level to print (trace,debug,verbose,info,warning,error,critical)\n"
557          "         -> trace: enter and return of some functions\n"
558          "         -> debug: crufty output\n"
559          "         -> verbose: verbose output for the user wanting more\n"
560          "         -> info: output about the regular functioning\n"
561          "         -> warning: minor issue encountered\n"
562          "         -> error: issue encountered\n"
563          "         -> critical: major issue encountered\n"
564          "      The default priority level is 'info'.\n"
565          "\n"
566          "   Format configuration: --log=CATEGORY_NAME.fmt:FORMAT\n"
567          "      FORMAT string may contain:\n"
568          "         -> %%%%: the %% char\n"
569          "         -> %%n: platform-dependent line separator (LOG4J compatible)\n"
570          "         -> %%e: plain old space (SimGrid extension)\n"
571          "\n"
572          "         -> %%m: user-provided message\n"
573          "\n"
574          "         -> %%c: Category name (LOG4J compatible)\n"
575          "         -> %%p: Priority name (LOG4J compatible)\n"
576          "\n"
577          "         -> %%h: Hostname (SimGrid extension)\n"
578          "         -> %%P: Process name (SimGrid extension)\n"
579          "         -> %%t: Thread \"name\" (LOG4J compatible -- actually the address of the thread in memory)\n"
580          "         -> %%i: Process PID (SimGrid extension -- this is a 'i' as in 'i'dea)\n"
581          "\n"
582          "         -> %%F: file name where the log event was raised (LOG4J compatible)\n"
583          "         -> %%l: location where the log event was raised (LOG4J compatible, like '%%F:%%L' -- this is a l as "
584          "in 'l'etter)\n"
585          "         -> %%L: line number where the log event was raised (LOG4J compatible)\n"
586          "         -> %%M: function name (LOG4J compatible -- called method name here of course).\n"
587          "\n"
588          "         -> %%b: full backtrace (Called %%throwable in LOG4J). Defined only under windows or when using the "
589          "GNU libc because\n"
590          "                 backtrace() is not defined elsewhere, and we only have a fallback for windows boxes, not "
591          "mac ones for example.\n"
592          "         -> %%B: short backtrace (only the first line of the %%b). Called %%throwable{short} in LOG4J; "
593          "defined where %%b is.\n"
594          "\n"
595          "         -> %%d: date (UNIX-like epoch)\n"
596          "         -> %%r: application age (time elapsed since the beginning of the application)\n"
597          "\n"
598          "   Miscellaneous:\n"
599          "      --help-log-categories    Display the current hierarchy of log categories.\n"
600          "      --log=no_loc             Don't print file names in messages (for tesh tests).\n"
601          "\n");
602 }
603
604 static void xbt_log_help_categories_rec(xbt_log_category_t category, const std::string& prefix)
605 {
606   if (!category)
607     return;
608
609   std::string this_prefix(prefix);
610   std::string child_prefix(prefix);
611   if (category->parent) {
612     this_prefix  += " \\_ ";
613     child_prefix += " |  ";
614   }
615
616   std::vector<xbt_log_category_t> cats;
617   for (xbt_log_category_t cat = category; cat != nullptr; cat = cat->nextSibling)
618     cats.push_back(cat);
619
620   std::sort(begin(cats), end(cats),
621             [](xbt_log_category_t a, xbt_log_category_t b) { return strcmp(a->name, b->name) < 0; });
622
623   for (auto const& cat : cats) {
624     printf("%s%s: %s\n", this_prefix.c_str(), cat->name, cat->description);
625     if (cat == cats.back() && category->parent)
626       child_prefix[child_prefix.rfind('|')] = ' ';
627     xbt_log_help_categories_rec(cat->firstChild, child_prefix);
628   }
629 }
630
631 static void xbt_log_help_categories(void)
632 {
633   printf("Current log category hierarchy:\n");
634   xbt_log_help_categories_rec(&_XBT_LOGV(XBT_LOG_ROOT_CAT), "   ");
635   printf("\n");
636 }