include/xbt/log.h

   1 /* log - a generic logging facility in the spirit of log4j                  */
   2
   3 /* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team.
   4  * All rights reserved.                                                     */
   5
   6 /* This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the license (GNU LGPL) which comes with this package. */
   8
   9 /** @addtogroup XBT_log
  10  *  @brief A generic logging facility in the spirit of log4j (grounding feature)
  11  *
  12  *
  13  */
  14
  15 /** \defgroup XBT_log_cats Existing log categories
  16  *  \ingroup XBT_log
  17  *  \brief (automatically extracted)
  18  *
  19  *  This is the list of all existing log categories in SimGrid.
  20  *  This list was automatically extracted from the source code by
  21  *  the src/xbt_log_extract_hierarchy utility.
  22  *
  23  *  You can thus be certain that it is uptodate, but it may somehow
  24  *  lack a final manual touch.
  25  *  Anyway, nothing's perfect ;)
  26  */
  27
  28 /* XBT_LOG_MAYDAY: define this to replace the logging facilities with basic
  29    printf function. Useful to debug the logging facilities themselves */
  30 #undef XBT_LOG_MAYDAY
  31 //#define XBT_LOG_MAYDAY
  32
  33 #ifndef _XBT_LOG_H_
  34 #define _XBT_LOG_H_
  35
  36 #include "simgrid_config.h"
  37
  38 #include <stdarg.h>
  39 SG_BEGIN_DECL()
  40 /**\brief Log priorities
  41  * \ingroup XBT_log
  42  *
  43  * The different existing priorities.
  44 */
  45 typedef enum {
  46   xbt_log_priority_none = 0,    /* used internally (don't poke with) */
  47   xbt_log_priority_trace = 1,          /**< enter and return of some functions */
  48   xbt_log_priority_debug = 2,          /**< crufty output  */
  49   xbt_log_priority_verbose = 3,        /**< verbose output for the user wanting more */
  50   xbt_log_priority_info = 4,           /**< output about the regular functionning */
  51   xbt_log_priority_warning = 5,        /**< minor issue encountered */
  52   xbt_log_priority_error = 6,          /**< issue encountered */
  53   xbt_log_priority_critical = 7,       /**< major issue encountered */
  54
  55   xbt_log_priority_infinite = 8,       /**< value for XBT_LOG_STATIC_THRESHOLD to not log */
  56
  57   xbt_log_priority_uninitialized = -1   /* used internally (don't poke with) */
  58 } e_xbt_log_priority_t;
  59
  60
  61 /*
  62  * define NLOG to disable at compilation time any logging request
  63  * define NDEBUG to disable at compilation time any logging request of priority below INFO
  64  */
  65
  66
  67 /**
  68  * @def XBT_LOG_STATIC_THRESHOLD
  69  * @ingroup XBT_log
  70  *
  71  * All logging requests with priority < XBT_LOG_STATIC_THRESHOLD are disabled at
  72  * compile time, i.e., compiled out.
  73  */
  74 #ifdef NLOG
  75 #  define XBT_LOG_STATIC_THRESHOLD xbt_log_priority_infinite
  76 #else
  77
  78 #  ifdef NDEBUG
  79 #    define XBT_LOG_STATIC_THRESHOLD xbt_log_priority_verbose
  80 #  else                         /* !NLOG && !NDEBUG */
  81
  82 #    ifndef XBT_LOG_STATIC_THRESHOLD
  83 #      define XBT_LOG_STATIC_THRESHOLD xbt_log_priority_none
  84 #    endif                      /* !XBT_LOG_STATIC_THRESHOLD */
  85 #  endif                        /* NDEBUG */
  86 #endif                          /* !defined(NLOG) */
  87
  88 /* Transforms a category name to a global variable name. */
  89 #define _XBT_LOGV(cat)   _XBT_LOG_CONCAT(_simgrid_log_category__, cat)
  90 #define _XBT_LOG_CONCAT(x,y) x ## y
  91
  92 /* The root of the category hierarchy. */
  93 #define XBT_LOG_ROOT_CAT   root
  94
  95 /* The whole tree of categories is connected by setting the address of
  96  * the parent category as a field of the child one.
  97  *
  98  * In strict ansi C, we are allowed to initialize a variable with "a
  99  * pointer to an lvalue designating an object of static storage
 100  * duration" [ISO/IEC 9899:1999, Section 6.6].
 101  *
 102  * Unfortunately, Visual C builder does not target any standard
 103  * compliance, and C99 is not an exception to this unfortunate rule.
 104  *
 105  * So, we work this around by adding a XBT_LOG_CONNECT() macro,
 106  * allowing to connect a child to its parent. It should be used
 107  * during the initialization of the code, before the child category
 108  * gets used.
 109  *
 110  * When compiling with gcc, this is not necessary (XBT_LOG_CONNECT
 111  * defines to nothing). When compiling with MSVC, this is needed if
 112  * you don't want to see your child category become a child of root
 113  * directly.
 114  */
 115 #if defined(_MSC_VER)
 116 # define _XBT_LOG_PARENT_INITIALIZER(parent) NULL
 117 # define XBT_LOG_CONNECT(parent_cat,child)       _XBT_LOGV(child).parent = &_XBT_LOGV(parent_cat)
 118 #else
 119 # define _XBT_LOG_PARENT_INITIALIZER(parent) &_XBT_LOGV(parent)
 120 # define XBT_LOG_CONNECT(parent_cat,child)      /*  xbt_assert(_XBT_LOGV(child).parent == &_XBT_LOGV(parent_cat)) */
 121 #endif
 122
 123 /* XBT_LOG_NEW_SUBCATEGORY_helper:
 124  * Implementation of XBT_LOG_NEW_SUBCATEGORY, which must declare "extern parent" in addition
 125  * to avoid an extra declaration of root when XBT_LOG_NEW_SUBCATEGORY is called by
 126  * XBT_LOG_NEW_CATEGORY */
 127 #define XBT_LOG_NEW_SUBCATEGORY_helper(catName, parent, desc) \
 128     XBT_EXPORT_NO_IMPORT(s_xbt_log_category_t) _XBT_LOGV(catName) = {       \
 129         _XBT_LOG_PARENT_INITIALIZER(parent),            \
 130         NULL /* firstChild */,                          \
 131         NULL /* nextSibling */,                         \
 132         #catName,                                       \
 133         xbt_log_priority_uninitialized /* threshold */, \
 134         1 /* isThreshInherited */,                      \
 135         NULL /* appender */,                            \
 136         NULL /* layout */,                              \
 137         1 /* additivity */                              \
 138     }
 139 /**
 140  * \ingroup XBT_log
 141  * \param catName name of new category
 142  * \param parent father of the new category in the tree
 143  * \param desc string describing the purpose of this category
 144  * \hideinitializer
 145  *
 146  * Defines a new subcategory of the parent.
 147  */
 148 #define XBT_LOG_NEW_SUBCATEGORY(catName, parent, desc)    \
 149     extern s_xbt_log_category_t _XBT_LOGV(parent); \
 150     XBT_LOG_NEW_SUBCATEGORY_helper(catName, parent, desc) \
 151
 152 /**
 153  * \ingroup XBT_log
 154  * \param catName name of new category
 155  * \param desc string describing the purpose of this category
 156  * \hideinitializer
 157  *
 158  * Creates a new subcategory of the root category.
 159  */
 160 # define XBT_LOG_NEW_CATEGORY(catName,desc)  \
 161    XBT_LOG_NEW_SUBCATEGORY_helper(catName, XBT_LOG_ROOT_CAT, desc)
 162
 163
 164 /**
 165  * \ingroup XBT_log
 166  * \param cname name of the cat
 167  * \hideinitializer
 168  *
 169  * Indicates which category is the default one.
 170  */
 171
 172 #if defined(XBT_LOG_MAYDAY) || defined(SUPERNOVAE_MODE) /*|| defined (NLOG) * turning logging off */
 173 # define XBT_LOG_DEFAULT_CATEGORY(cname)
 174 #else
 175 # define XBT_LOG_DEFAULT_CATEGORY(cname) \
 176          static xbt_log_category_t _XBT_LOGV(default) _XBT_GNUC_UNUSED = &_XBT_LOGV(cname)
 177 #endif
 178
 179 /**
 180  * \ingroup XBT_log
 181  * \param cname name of the cat
 182  * \param desc string describing the purpose of this category
 183  * \hideinitializer
 184  *
 185  * Creates a new subcategory of the root category and makes it the default
 186  * (used by macros that don't explicitly specify a category).
 187  */
 188 # define XBT_LOG_NEW_DEFAULT_CATEGORY(cname,desc)        \
 189     XBT_LOG_NEW_CATEGORY(cname,desc);                   \
 190     XBT_LOG_DEFAULT_CATEGORY(cname)
 191
 192 /**
 193  * \ingroup XBT_log
 194  * \param cname name of the cat
 195  * \param parent name of the parent
 196  * \param desc string describing the purpose of this category
 197  * \hideinitializer
 198  *
 199  * Creates a new subcategory of the parent category and makes it the default
 200  * (used by macros that don't explicitly specify a category).
 201  */
 202 #define XBT_LOG_NEW_DEFAULT_SUBCATEGORY(cname, parent, desc) \
 203     XBT_LOG_NEW_SUBCATEGORY(cname, parent, desc);            \
 204     XBT_LOG_DEFAULT_CATEGORY(cname)
 205
 206 /**
 207  * \ingroup XBT_log
 208  * \param cname name of the cat
 209  * \hideinitializer
 210  *
 211  * Indicates that a category you'll use in this file (to get subcategories of it,
 212  * for example) really lives in another file.
 213  */
 214
 215 #define XBT_LOG_EXTERNAL_CATEGORY(cname) \
 216    extern s_xbt_log_category_t _XBT_LOGV(cname)
 217
 218 /**
 219  * \ingroup XBT_log
 220  * \param cname name of the cat
 221  * \hideinitializer
 222  *
 223  * Indicates that the default category of this file was declared in another file.
 224  */
 225
 226 #define XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(cname) \
 227    XBT_LOG_EXTERNAL_CATEGORY(cname);\
 228    XBT_LOG_DEFAULT_CATEGORY(cname)
 229
 230 /* Functions you may call */
 231
 232 XBT_PUBLIC(void) xbt_log_control_set(const char *cs);
 233
 234 /* Forward declarations */
 235 typedef struct xbt_log_appender_s s_xbt_log_appender_t,
 236     *xbt_log_appender_t;
 237 typedef struct xbt_log_layout_s s_xbt_log_layout_t, *xbt_log_layout_t;
 238 typedef struct xbt_log_event_s s_xbt_log_event_t, *xbt_log_event_t;
 239 typedef struct xbt_log_category_s s_xbt_log_category_t,
 240     *xbt_log_category_t;
 241
 242 /*
 243  * Do NOT access any members of this structure directly. FIXME: move to private?
 244  */
 245 #ifdef _XBT_WIN32
 246 #define XBT_LOG_BUFF_SIZE  16384        /* Size of the static string in which we build the log string */
 247 #else
 248 #define XBT_LOG_BUFF_SIZE 2048  /* Size of the static string in which we build the log string */
 249 #endif
 250 struct xbt_log_category_s {
 251   xbt_log_category_t parent;
 252   xbt_log_category_t firstChild;
 253   xbt_log_category_t nextSibling;
 254   const char *name;
 255   int threshold;
 256   int isThreshInherited;
 257   xbt_log_appender_t appender;
 258   xbt_log_layout_t layout;
 259   int additivity;
 260 };
 261
 262 struct xbt_log_event_s {
 263   xbt_log_category_t cat;
 264   e_xbt_log_priority_t priority;
 265   const char *fileName;
 266   const char *functionName;
 267   int lineNum;
 268   va_list ap;
 269   va_list ap_copy;              /* need a copy to launch dynamic layouts when the static ones overflowed */
 270 #ifdef _XBT_WIN32
 271   char *buffer;
 272 #else
 273   char buffer[XBT_LOG_BUFF_SIZE];
 274 #endif
 275 };
 276
 277 /**
 278  * \ingroup XBT_log_implem
 279  * \param cat the category (not only its name, but the variable)
 280  * \param thresholdPriority the priority
 281  *
 282  * Programatically alters a category's threshold priority (don't use).
 283  */
 284 XBT_PUBLIC(void) xbt_log_threshold_set(xbt_log_category_t cat,
 285                                        e_xbt_log_priority_t
 286                                        thresholdPriority);
 287
 288 /**
 289  * \ingroup XBT_log_implem
 290  * \param cat the category (not only its name, but the variable)
 291  * \param app the appender
 292  *
 293  * Programatically sets the category's appender.
 294  * (the prefered interface is throught xbt_log_control_set())
 295  *
 296  */
 297 XBT_PUBLIC(void) xbt_log_appender_set(xbt_log_category_t cat,
 298                                       xbt_log_appender_t app);
 299 /**
 300  * \ingroup XBT_log_implem
 301  * \param cat the category (not only its name, but the variable)
 302  * \param lay the layout
 303  *
 304  * Programatically sets the category's layout.
 305  * (the prefered interface is throught xbt_log_control_set())
 306  *
 307  */
 308 XBT_PUBLIC(void) xbt_log_layout_set(xbt_log_category_t cat,
 309                                     xbt_log_layout_t lay);
 310
 311 /**
 312  * \ingroup XBT_log_implem
 313  * \param cat the category (not only its name, but the variable)
 314  * \param additivity whether logging actions must be passed to parent.
 315  *
 316  * Programatically sets whether the logging actions must be passed to
 317  * the parent category.
 318  * (the prefered interface is throught xbt_log_control_set())
 319  *
 320  */
 321 XBT_PUBLIC(void) xbt_log_additivity_set(xbt_log_category_t cat,
 322                                         int additivity);
 323
 324 /** @brief create a new simple layout
 325  *
 326  * This layout is not as flexible as the pattern one
 327  */
 328 XBT_PUBLIC(xbt_log_layout_t) xbt_log_layout_simple_new(char *arg);
 329 XBT_PUBLIC(xbt_log_layout_t) xbt_log_layout_format_new(char *arg);
 330 XBT_PUBLIC(xbt_log_appender_t) xbt_log_appender_file_new(char *arg);
 331
 332
 333 /* ********************************** */
 334 /* Functions that you shouldn't call  */
 335 /* ********************************** */
 336 XBT_PUBLIC(void) _xbt_log_event_log(xbt_log_event_t ev,
 337                                     const char *fmt,
 338                                     ...) _XBT_GNUC_PRINTF(2, 3);
 339
 340 XBT_PUBLIC(int) _xbt_log_cat_init(xbt_log_category_t category,
 341                                   e_xbt_log_priority_t priority);
 342
 343
 344 XBT_PUBLIC_DATA(s_xbt_log_category_t) _XBT_LOGV(XBT_LOG_ROOT_CAT);
 345
 346
 347 extern xbt_log_appender_t xbt_log_default_appender;
 348 extern xbt_log_layout_t xbt_log_default_layout;
 349
 350 /* ********************** */
 351 /* Public functions again */
 352 /* ********************** */
 353
 354 /**
 355  * \ingroup XBT_log
 356  * \param catName name of the category
 357  * \param priority minimal priority to be enabled to return true (must be #e_xbt_log_priority_t)
 358  * \hideinitializer
 359  *
 360  * Returns true if the given priority is enabled for the category.
 361  * If you have expensive expressions that are computed outside of the log
 362  * command and used only within it, you should make its evaluation conditional
 363  * using this macro.
 364  */
 365 #define XBT_LOG_ISENABLED(catName, priority) \
 366             _XBT_LOG_ISENABLEDV(_XBT_LOGV(catName), priority)
 367
 368 /*
 369  * Helper function that implements XBT_LOG_ISENABLED.
 370  *
 371  * NOTES
 372  * First part is a compile-time constant.
 373  * Call to _log_initCat only happens once.
 374  */
 375 #define _XBT_LOG_ISENABLEDV(catv, priority)                  \
 376        (priority >= XBT_LOG_STATIC_THRESHOLD                 \
 377         && priority >= catv.threshold                         \
 378         && (catv.threshold != xbt_log_priority_uninitialized \
 379             || _xbt_log_cat_init(&catv, priority)) )
 380
 381 /*
 382  * Internal Macros
 383  * Some kludge macros to ease maintenance. See how they're used below.
 384  *
 385  * IMPLEMENTATION NOTE: To reduce the parameter passing overhead of an enabled
 386  * message, the many parameters passed to the logging function are packed in a
 387  * structure. Since these values will be usually be passed to at least 3
 388  * functions, this is a win.
 389  * It also allows adding new values (such as a timestamp) without breaking
 390  * code.
 391  * Setting the LogEvent's valist member is done inside _log_logEvent.
 392  */
 393 #ifdef _XBT_WIN32
 394 #include <stdlib.h>             /* calloc */
 395 #define _XBT_LOG_PRE(catv, prio) do {                            \
 396      if (_XBT_LOG_ISENABLEDV(catv, prio)) {                      \
 397        s_xbt_log_event_t _log_ev;                                \
 398        _log_ev.cat = &(catv);                                    \
 399        _log_ev.priority = (prio);                                \
 400        _log_ev.fileName = __FILE__;                              \
 401        _log_ev.functionName = _XBT_FUNCTION;                     \
 402        _log_ev.lineNum = __LINE__;                               \
 403        _log_ev.buffer = (char*) calloc(XBT_LOG_BUFF_SIZE + 1, sizeof(char)); \
 404        _xbt_log_event_log(&_log_ev
 405 #else
 406 #include <string.h>             /* memset */
 407 #define _XBT_LOG_PRE(catv, prio) do {                            \
 408      if (_XBT_LOG_ISENABLEDV(catv, prio)) {                      \
 409        s_xbt_log_event_t _log_ev;                                \
 410        _log_ev.cat = &(catv);                                    \
 411        _log_ev.priority = (prio);                                \
 412        _log_ev.fileName = __FILE__;                              \
 413        _log_ev.functionName = _XBT_FUNCTION;                     \
 414        _log_ev.lineNum = __LINE__;                               \
 415        memset(_log_ev.buffer, 0, XBT_LOG_BUFF_SIZE);             \
 416        _xbt_log_event_log(&_log_ev
 417
 418 #endif
 419
 420 #define _XBT_LOG_POST                          \
 421                         );                      \
 422      } } while(0)
 423
 424
 425 /* Logging Macros */
 426
 427 #ifdef XBT_LOG_MAYDAY
 428 # define CLOG0(c, p, f)                   fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__)
 429 # define CLOG1(c, p, f,a1)                fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1)
 430 # define CLOG2(c, p, f,a1,a2)             fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2)
 431 # define CLOG3(c, p, f,a1,a2,a3)          fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3)
 432 # define CLOG4(c, p, f,a1,a2,a3,a4)       fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4)
 433 # define CLOG5(c, p, f,a1,a2,a3,a4,a5)    fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5)
 434 # define CLOG6(c, p, f,a1,a2,a3,a4,a5,a6) fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5,a6)
 435 # define CLOG7(c, p, f,a1,a2,a3,a4,a5,a6,a7) fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5,a6,a7)
 436 # define CLOG8(c, p, f,a1,a2,a3,a4,a5,a6,a7,a8) fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5,a6,a7,a8)
 437 # define CLOG9(c, p, f,a1,a2,a3,a4,a5,a6,a7,a8,a9) fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 438 # define CLOG10(c, p, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 439 #else
 440 # define CLOG0(c, p, f)                   _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f _XBT_LOG_POST
 441 # define CLOG1(c, p, f,a1)                _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f,a1 _XBT_LOG_POST
 442 # define CLOG2(c, p, f,a1,a2)             _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f,a1,a2 _XBT_LOG_POST
 443 # define CLOG3(c, p, f,a1,a2,a3)          _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f,a1,a2,a3 _XBT_LOG_POST
 444 # define CLOG4(c, p, f,a1,a2,a3,a4)       _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f,a1,a2,a3,a4 _XBT_LOG_POST
 445 # define CLOG5(c, p, f,a1,a2,a3,a4,a5)    _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f,a1,a2,a3,a4,a5 _XBT_LOG_POST
 446 # define CLOG6(c, p, f,a1,a2,a3,a4,a5,a6) _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f,a1,a2,a3,a4,a5,a6 _XBT_LOG_POST
 447 # define CLOG7(c, p, f,a1,a2,a3,a4,a5,a6,a7) _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f,a1,a2,a3,a4,a5,a6,a7 _XBT_LOG_POST
 448 # define CLOG8(c, p, f,a1,a2,a3,a4,a5,a6,a7,a8) _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f,a1,a2,a3,a4,a5,a6,a7,a8 _XBT_LOG_POST
 449 # define CLOG9(c, p, f,a1,a2,a3,a4,a5,a6,a7,a8,a9) _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f,a1,a2,a3,a4,a5,a6,a7,a8,a9 _XBT_LOG_POST
 450 # define CLOG10(c, p, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) _XBT_LOG_PRE(_XBT_LOGV(c),p) ,f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10 _XBT_LOG_POST
 451 #endif
 452 #define CDEBUG0(c, f)                   CLOG0(c, xbt_log_priority_debug, f)
 453 #define CDEBUG1(c, f,a1)                CLOG1(c, xbt_log_priority_debug, f,a1)
 454 #define CDEBUG2(c, f,a1,a2)             CLOG2(c, xbt_log_priority_debug, f,a1,a2)
 455 #define CDEBUG3(c, f,a1,a2,a3)          CLOG3(c, xbt_log_priority_debug, f,a1,a2,a3)
 456 #define CDEBUG4(c, f,a1,a2,a3,a4)       CLOG4(c, xbt_log_priority_debug, f,a1,a2,a3,a4)
 457 #define CDEBUG5(c, f,a1,a2,a3,a4,a5)    CLOG5(c, xbt_log_priority_debug, f,a1,a2,a3,a4,a5)
 458 #define CDEBUG6(c, f,a1,a2,a3,a4,a5,a6) CLOG6(c, xbt_log_priority_debug, f,a1,a2,a3,a4,a5,a6)
 459 #define CDEBUG7(c, f,a1,a2,a3,a4,a5,a6,a7) CLOG7(c, xbt_log_priority_debug, f,a1,a2,a3,a4,a5,a6,a7)
 460 #define CDEBUG8(c, f,a1,a2,a3,a4,a5,a6,a7,a8) CLOG8(c, xbt_log_priority_debug, f,a1,a2,a3,a4,a5,a6,a7,a8)
 461 #define CDEBUG9(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9) CLOG9(c, xbt_log_priority_debug, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 462 /** @ingroup XBT_log
 463  *  @hideinitializer
 464  * \param c the category on which to log
 465  * \param f the format string
 466  * \param a1 first argument of the format
 467  * \param a2 second argument of the format
 468  * \param a3 third argument of the format
 469  * \param a4 fourth argument of the format
 470  * \param a5 fifth argument of the format
 471  * \param a6 sixth argument of the format
 472  * \param a7 seventh argument of the format
 473  * \param a8 eighth argument of the format
 474  * \param a9 ninth argument of the format
 475  * \param a10 tenth argument of the format
 476  *  @brief Log an event at the DEBUG priority on the specified category with these args (CDEBUGn exists for any n<10).
 477  */
 478 #define CDEBUG10(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) CLOG10(c, xbt_log_priority_debug, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 479
 480 #define CVERB0(c, f)                   CLOG0(c, xbt_log_priority_verbose, f)
 481 #define CVERB1(c, f,a1)                CLOG1(c, xbt_log_priority_verbose, f,a1)
 482 #define CVERB2(c, f,a1,a2)             CLOG2(c, xbt_log_priority_verbose, f,a1,a2)
 483 #define CVERB3(c, f,a1,a2,a3)          CLOG3(c, xbt_log_priority_verbose, f,a1,a2,a3)
 484 #define CVERB4(c, f,a1,a2,a3,a4)       CLOG4(c, xbt_log_priority_verbose, f,a1,a2,a3,a4)
 485 #define CVERB5(c, f,a1,a2,a3,a4,a5)    CLOG5(c, xbt_log_priority_verbose, f,a1,a2,a3,a4,a5)
 486 #define CVERB6(c, f,a1,a2,a3,a4,a5,a6)    CLOG6(c, xbt_log_priority_verbose, f,a1,a2,a3,a4,a5,a6)
 487 #define CVERB7(c, f,a1,a2,a3,a4,a5,a6,a7)    CLOG7(c, xbt_log_priority_verbose, f,a1,a2,a3,a4,a5,a6,a7)
 488 #define CVERB8(c, f,a1,a2,a3,a4,a5,a6,a7,a8)    CLOG8(c, xbt_log_priority_verbose, f,a1,a2,a3,a4,a5,a6,a7,a8)
 489 #define CVERB9(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)    CLOG9(c, xbt_log_priority_verbose, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 490 /** @ingroup XBT_log
 491  *  @hideinitializer
 492  *  @brief Log an event at the VERB priority on the specified category with these args (CVERBn exists for any n<10).
 493  */
 494 #define CVERB10(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)    CLOG10(c, xbt_log_priority_verbose, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 495
 496 #define CINFO0(c, f)                   CLOG0(c, xbt_log_priority_info, f)
 497 #define CINFO1(c, f,a1)                CLOG1(c, xbt_log_priority_info, f,a1)
 498 #define CINFO2(c, f,a1,a2)             CLOG2(c, xbt_log_priority_info, f,a1,a2)
 499 #define CINFO3(c, f,a1,a2,a3)          CLOG3(c, xbt_log_priority_info, f,a1,a2,a3)
 500 #define CINFO4(c, f,a1,a2,a3,a4)       CLOG4(c, xbt_log_priority_info, f,a1,a2,a3,a4)
 501 #define CINFO5(c, f,a1,a2,a3,a4,a5)    CLOG5(c, xbt_log_priority_info, f,a1,a2,a3,a4,a5)
 502 #define CINFO6(c, f,a1,a2,a3,a4,a5,a6) CLOG6(c, xbt_log_priority_info, f,a1,a2,a3,a4,a5,a6)
 503 #define CINFO7(c, f,a1,a2,a3,a4,a5,a6,a7) CLOG7(c, xbt_log_priority_info, f,a1,a2,a3,a4,a5,a6,a7)
 504 #define CINFO8(c, f,a1,a2,a3,a4,a5,a6,a7,a8) CLOG8(c, xbt_log_priority_info, f,a1,a2,a3,a4,a5,a6,a7,a8)
 505 #define CINFO9(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9) CLOG9(c, xbt_log_priority_info, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 506 /** @ingroup XBT_log
 507  *  @hideinitializer
 508  *  @brief Log an event at the INFO priority on the specified category with these args (CINFOn exists for any n<10).
 509  */
 510 #define CINFO10(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) CLOG10(c, xbt_log_priority_info, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 511
 512 #define CWARN0(c, f)                   CLOG0(c, xbt_log_priority_warning, f)
 513 #define CWARN1(c, f,a1)                CLOG1(c, xbt_log_priority_warning, f,a1)
 514 #define CWARN2(c, f,a1,a2)             CLOG2(c, xbt_log_priority_warning, f,a1,a2)
 515 #define CWARN3(c, f,a1,a2,a3)          CLOG3(c, xbt_log_priority_warning, f,a1,a2,a3)
 516 #define CWARN4(c, f,a1,a2,a3,a4)       CLOG4(c, xbt_log_priority_warning, f,a1,a2,a3,a4)
 517 #define CWARN5(c, f,a1,a2,a3,a4,a5)    CLOG5(c, xbt_log_priority_warning, f,a1,a2,a3,a4,a5)
 518 #define CWARN6(c, f,a1,a2,a3,a4,a5,a6) CLOG6(c, xbt_log_priority_warning, f,a1,a2,a3,a4,a5,a6)
 519 #define CWARN7(c, f,a1,a2,a3,a4,a5,a6,a7) CLOG7(c, xbt_log_priority_warning, f,a1,a2,a3,a4,a5,a6,a7)
 520 #define CWARN8(c, f,a1,a2,a3,a4,a5,a6,a7,a8) CLOG8(c, xbt_log_priority_warning, f,a1,a2,a3,a4,a5,a6,a7,a8)
 521 #define CWARN9(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9) CLOG9(c, xbt_log_priority_warning, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 522 /** @ingroup XBT_log
 523  *  @hideinitializer
 524  *  @brief Log an event at the WARN priority on the specified category with these args (CWARNn exists for any n<10).
 525  */
 526 #define CWARN10(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) CLOG10(c, xbt_log_priority_warning, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,10)
 527
 528 #define CERROR0(c, f)                   CLOG0(c, xbt_log_priority_error, f)
 529 #define CERROR1(c, f,a1)                CLOG1(c, xbt_log_priority_error, f,a1)
 530 #define CERROR2(c, f,a1,a2)             CLOG2(c, xbt_log_priority_error, f,a1,a2)
 531 #define CERROR3(c, f,a1,a2,a3)          CLOG3(c, xbt_log_priority_error, f,a1,a2,a3)
 532 #define CERROR4(c, f,a1,a2,a3,a4)       CLOG4(c, xbt_log_priority_error, f,a1,a2,a3,a4)
 533 #define CERROR5(c, f,a1,a2,a3,a4,a5)    CLOG5(c, xbt_log_priority_error, f,a1,a2,a3,a4,a5)
 534 #define CERROR6(c, f,a1,a2,a3,a4,a5,a6) CLOG6(c, xbt_log_priority_error, f,a1,a2,a3,a4,a5,a6)
 535 #define CERROR7(c, f,a1,a2,a3,a4,a5,a6,a7) CLOG7(c, xbt_log_priority_error, f,a1,a2,a3,a4,a5,a6,a7)
 536 #define CERROR8(c, f,a1,a2,a3,a4,a5,a6,a7,a8) CLOG8(c, xbt_log_priority_error, f,a1,a2,a3,a4,a5,a6,a7,a8)
 537 #define CERROR9(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9) CLOG9(c, xbt_log_priority_error, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 538 /** @ingroup XBT_log
 539  *  @hideinitializer
 540  *  @brief Log an event at the ERROR priority on the specified category with these args (CERRORn exists for any n<10).
 541  */
 542 #define CERROR10(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) CLOG10(c, xbt_log_priority_error, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 543
 544 #define CCRITICAL0(c, f)                   CLOG0(c, xbt_log_priority_critical, f)
 545 #define CCRITICAL1(c, f,a1)                CLOG1(c, xbt_log_priority_critical, f,a1)
 546 #define CCRITICAL2(c, f,a1,a2)             CLOG2(c, xbt_log_priority_critical, f,a1,a2)
 547 #define CCRITICAL3(c, f,a1,a2,a3)          CLOG3(c, xbt_log_priority_critical, f,a1,a2,a3)
 548 #define CCRITICAL4(c, f,a1,a2,a3,a4)       CLOG4(c, xbt_log_priority_critical, f,a1,a2,a3,a4)
 549 #define CCRITICAL5(c, f,a1,a2,a3,a4,a5)    CLOG5(c, xbt_log_priority_critical, f,a1,a2,a3,a4,a5)
 550 #define CCRITICAL6(c, f,a1,a2,a3,a4,a5,a6)    CLOG6(c, xbt_log_priority_critical, f,a1,a2,a3,a4,a5,a6)
 551 #define CCRITICAL7(c, f,a1,a2,a3,a4,a5,a6,a7)    CLOG7(c, xbt_log_priority_critical, f,a1,a2,a3,a4,a5,a6,a7)
 552 #define CCRITICAL8(c, f,a1,a2,a3,a4,a5,a6,a7,a8)    CLOG8(c, xbt_log_priority_critical, f,a1,a2,a3,a4,a5,a6,a7,a8)
 553 #define CCRITICAL9(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)    CLOG9(c, xbt_log_priority_critical, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 554 /** @ingroup XBT_log
 555  *  @hideinitializer
 556  *  @brief Log an event at the CRITICAL priority on the specified category with these args (CCRITICALn exists for any n<10).
 557  */
 558 #define CCRITICAL10(c, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)    CLOG10(c, xbt_log_priority_critical, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 559
 560 #ifdef XBT_LOG_MAYDAY
 561 # define LOG0(p, f)                   fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__)
 562 # define LOG1(p, f,a1)                fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1)
 563 # define LOG2(p, f,a1,a2)             fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2)
 564 # define LOG3(p, f,a1,a2,a3)          fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3)
 565 # define LOG4(p, f,a1,a2,a3,a4)       fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4)
 566 # define LOG5(p, f,a1,a2,a3,a4,a5)    fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5)
 567 # define LOG6(p, f,a1,a2,a3,a4,a5,a6) fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5,a6)
 568 # define LOG7(p, f,a1,a2,a3,a4,a5,a6,a7) fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5,a6,a7)
 569 # define LOG8(p, f,a1,a2,a3,a4,a5,a6,a7,a8) fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5,a6,a7,a8)
 570 # define LOG9(p, f,a1,a2,a3,a4,a5,a6,a7,a8,a9) fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 571 # define LOG10(p, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) fprintf(stderr,"%s:%d:" f "\n",__FILE__,__LINE__,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 572 #else
 573 # define LOG0(p, f)                   _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f _XBT_LOG_POST
 574 # define LOG1(p, f,a1)                _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f,a1 _XBT_LOG_POST
 575 # define LOG2(p, f,a1,a2)             _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f,a1,a2 _XBT_LOG_POST
 576 # define LOG3(p, f,a1,a2,a3)          _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f,a1,a2,a3 _XBT_LOG_POST
 577 # define LOG4(p, f,a1,a2,a3,a4)       _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f,a1,a2,a3,a4 _XBT_LOG_POST
 578 # define LOG5(p, f,a1,a2,a3,a4,a5)    _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f,a1,a2,a3,a4,a5 _XBT_LOG_POST
 579 # define LOG6(p, f,a1,a2,a3,a4,a5,a6) _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f,a1,a2,a3,a4,a5,a6 _XBT_LOG_POST
 580 # define LOG7(p, f,a1,a2,a3,a4,a5,a6,a7) _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f,a1,a2,a3,a4,a5,a6,a7 _XBT_LOG_POST
 581 # define LOG8(p, f,a1,a2,a3,a4,a5,a6,a7,a8) _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f,a1,a2,a3,a4,a5,a6,a7,a8 _XBT_LOG_POST
 582 # define LOG9(p, f,a1,a2,a3,a4,a5,a6,a7,a8,a9) _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f,a1,a2,a3,a4,a5,a6,a7,a8,a9 _XBT_LOG_POST
 583 # define LOG10(p,f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) _XBT_LOG_PRE((*_XBT_LOGV(default)),p) ,f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10 _XBT_LOG_POST
 584 #endif
 585
 586 #define DEBUG0(f)                   LOG0(xbt_log_priority_debug, f)
 587 #define DEBUG1(f,a1)                LOG1(xbt_log_priority_debug, f,a1)
 588 #define DEBUG2(f,a1,a2)             LOG2(xbt_log_priority_debug, f,a1,a2)
 589 #define DEBUG3(f,a1,a2,a3)          LOG3(xbt_log_priority_debug, f,a1,a2,a3)
 590 #define DEBUG4(f,a1,a2,a3,a4)       LOG4(xbt_log_priority_debug, f,a1,a2,a3,a4)
 591 #define DEBUG5(f,a1,a2,a3,a4,a5)    LOG5(xbt_log_priority_debug, f,a1,a2,a3,a4,a5)
 592 #define DEBUG6(f,a1,a2,a3,a4,a5,a6) LOG6(xbt_log_priority_debug, f,a1,a2,a3,a4,a5,a6)
 593 #define DEBUG7(f,a1,a2,a3,a4,a5,a6,a7) LOG7(xbt_log_priority_debug, f,a1,a2,a3,a4,a5,a6,a7)
 594 #define DEBUG8(f,a1,a2,a3,a4,a5,a6,a7,a8) LOG8(xbt_log_priority_debug, f,a1,a2,a3,a4,a5,a6,a7,a8)
 595 #define DEBUG9(f,a1,a2,a3,a4,a5,a6,a7,a8,a9) LOG9(xbt_log_priority_debug, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 596 /** @ingroup XBT_log
 597  *  @hideinitializer
 598  * \param f the format string
 599  * \param a1 first argument of the format
 600  * \param a2 second argument of the format
 601  * \param a3 third argument of the format
 602  * \param a4 fourth argument of the format
 603  * \param a5 fifth argument of the format
 604  * \param a6 sixth argument of the format
 605  * \param a7 seventh argument of the format
 606  * \param a8 eighth argument of the format
 607  * \param a9 ninth argument of the format
 608  * \param a10 tenth argument of the format
 609  *  @brief Log an event at the DEBUG priority on the default category with these args (DEBUGn exists for any n<10)
 610  */
 611 #define DEBUG10(f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) LOG10(xbt_log_priority_debug, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 612
 613 #define VERB0(f)                   LOG0(xbt_log_priority_verbose, f)
 614 #define VERB1(f,a1)                LOG1(xbt_log_priority_verbose, f,a1)
 615 #define VERB2(f,a1,a2)             LOG2(xbt_log_priority_verbose, f,a1,a2)
 616 #define VERB3(f,a1,a2,a3)          LOG3(xbt_log_priority_verbose, f,a1,a2,a3)
 617 #define VERB4(f,a1,a2,a3,a4)       LOG4(xbt_log_priority_verbose, f,a1,a2,a3,a4)
 618 #define VERB5(f,a1,a2,a3,a4,a5)    LOG5(xbt_log_priority_verbose, f,a1,a2,a3,a4,a5)
 619 #define VERB6(f,a1,a2,a3,a4,a5,a6) LOG6(xbt_log_priority_verbose, f,a1,a2,a3,a4,a5,a6)
 620 #define VERB7(f,a1,a2,a3,a4,a5,a6,a7) LOG7(xbt_log_priority_verbose, f,a1,a2,a3,a4,a5,a6,a7)
 621 #define VERB8(f,a1,a2,a3,a4,a5,a6,a7,a8) LOG8(xbt_log_priority_verbose, f,a1,a2,a3,a4,a5,a6,a7,a8)
 622 #define VERB9(f,a1,a2,a3,a4,a5,a6,a7,a8,a9) LOG9(xbt_log_priority_verbose, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 623 /** @ingroup XBT_log
 624  *  @hideinitializer
 625  *  @brief Log an event at the VERB priority on the default category with these args (VERBn exists for any n<10).
 626  */
 627 #define VERB10(f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) LOG10(xbt_log_priority_verbose, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 628
 629 #define INFO0(f)                   LOG0(xbt_log_priority_info, f)
 630 #define INFO1(f,a1)                LOG1(xbt_log_priority_info, f,a1)
 631 #define INFO2(f,a1,a2)             LOG2(xbt_log_priority_info, f,a1,a2)
 632 #define INFO3(f,a1,a2,a3)          LOG3(xbt_log_priority_info, f,a1,a2,a3)
 633 #define INFO4(f,a1,a2,a3,a4)       LOG4(xbt_log_priority_info, f,a1,a2,a3,a4)
 634 #define INFO5(f,a1,a2,a3,a4,a5)    LOG5(xbt_log_priority_info, f,a1,a2,a3,a4,a5)
 635 #define INFO6(f,a1,a2,a3,a4,a5,a6) LOG6(xbt_log_priority_info, f,a1,a2,a3,a4,a5,a6)
 636 #define INFO7(f,a1,a2,a3,a4,a5,a6,a7) LOG7(xbt_log_priority_info, f,a1,a2,a3,a4,a5,a6,a7)
 637 #define INFO8(f,a1,a2,a3,a4,a5,a6,a7,a8) LOG8(xbt_log_priority_info, f,a1,a2,a3,a4,a5,a6,a7,a8)
 638 #define INFO9(f,a1,a2,a3,a4,a5,a6,a7,a8,a9) LOG9(xbt_log_priority_info, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 639 /** @ingroup XBT_log
 640  *  @hideinitializer
 641  *  @brief Log an event at the INFO priority on the default category with these args (INFOn exists for any n<10).
 642  */
 643 #define INFO10(f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) LOG10(xbt_log_priority_info, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 644
 645 #define WARN0(f)                   LOG0(xbt_log_priority_warning, f)
 646 #define WARN1(f,a1)                LOG1(xbt_log_priority_warning, f,a1)
 647 #define WARN2(f,a1,a2)             LOG2(xbt_log_priority_warning, f,a1,a2)
 648 #define WARN3(f,a1,a2,a3)          LOG3(xbt_log_priority_warning, f,a1,a2,a3)
 649 #define WARN4(f,a1,a2,a3,a4)       LOG4(xbt_log_priority_warning, f,a1,a2,a3,a4)
 650 #define WARN5(f,a1,a2,a3,a4,a5)    LOG5(xbt_log_priority_warning, f,a1,a2,a3,a4,a5)
 651 #define WARN6(f,a1,a2,a3,a4,a5,a6) LOG6(xbt_log_priority_warning, f,a1,a2,a3,a4,a5,a6)
 652 #define WARN7(f,a1,a2,a3,a4,a5,a6,a7) LOG7(xbt_log_priority_warning, f,a1,a2,a3,a4,a5,a6,a7)
 653 #define WARN8(f,a1,a2,a3,a4,a5,a6,a7,a8) LOG8(xbt_log_priority_warning, f,a1,a2,a3,a4,a5,a6,a7,a8)
 654 #define WARN9(f,a1,a2,a3,a4,a5,a6,a7,a8,a9) LOG9(xbt_log_priority_warning, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 655 /** @ingroup XBT_log
 656  *  @hideinitializer
 657  *  @brief Log an event at the WARN priority on the default category with these args (WARNn exists for any n<10).
 658  */
 659 #define WARN10(f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) LOG10(xbt_log_priority_warning, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 660
 661
 662 #define ERROR0(f)                   LOG0(xbt_log_priority_error, f)
 663 #define ERROR1(f,a1)                LOG1(xbt_log_priority_error, f,a1)
 664 #define ERROR2(f,a1,a2)             LOG2(xbt_log_priority_error, f,a1,a2)
 665 #define ERROR3(f,a1,a2,a3)          LOG3(xbt_log_priority_error, f,a1,a2,a3)
 666 #define ERROR4(f,a1,a2,a3,a4)       LOG4(xbt_log_priority_error, f,a1,a2,a3,a4)
 667 #define ERROR5(f,a1,a2,a3,a4,a5)    LOG5(xbt_log_priority_error, f,a1,a2,a3,a4,a5)
 668 #define ERROR6(f,a1,a2,a3,a4,a5,a6) LOG6(xbt_log_priority_error, f,a1,a2,a3,a4,a5,a6)
 669 #define ERROR7(f,a1,a2,a3,a4,a5,a6,a7) LOG7(xbt_log_priority_error, f,a1,a2,a3,a4,a5,a6,a7)
 670 #define ERROR8(f,a1,a2,a3,a4,a5,a6,a7,a8) LOG8(xbt_log_priority_error, f,a1,a2,a3,a4,a5,a6,a7,a8)
 671 #define ERROR9(f,a1,a2,a3,a4,a5,a6,a7,a8,a9) LOG9(xbt_log_priority_error, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 672 /** @ingroup XBT_log
 673  *  @hideinitializer
 674  *  @brief Log an event at the ERROR priority on the default category with these args (ERRORn exists for any n<10).
 675  */
 676 #define ERROR10(f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) LOG10(xbt_log_priority_error, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 677
 678 #define CRITICAL0(f)                   LOG0(xbt_log_priority_critical, f)
 679 #define CRITICAL1(f,a1)                LOG1(xbt_log_priority_critical, f,a1)
 680 #define CRITICAL2(f,a1,a2)             LOG2(xbt_log_priority_critical, f,a1,a2)
 681 #define CRITICAL3(f,a1,a2,a3)          LOG3(xbt_log_priority_critical, f,a1,a2,a3)
 682 #define CRITICAL4(f,a1,a2,a3,a4)       LOG4(xbt_log_priority_critical, f,a1,a2,a3,a4)
 683 #define CRITICAL5(f,a1,a2,a3,a4,a5)    LOG5(xbt_log_priority_critical, f,a1,a2,a3,a4,a5)
 684 #define CRITICAL6(f,a1,a2,a3,a4,a5,a6) LOG6(xbt_log_priority_critical, f,a1,a2,a3,a4,a5,a6)
 685 #define CRITICAL7(f,a1,a2,a3,a4,a5,a6,a7) LOG7(xbt_log_priority_critical, f,a1,a2,a3,a4,a5,a6,a7)
 686 #define CRITICAL8(f,a1,a2,a3,a4,a5,a6,a7,a8) LOG8(xbt_log_priority_critical, f,a1,a2,a3,a4,a5,a6,a7,a8)
 687 #define CRITICAL9(f,a1,a2,a3,a4,a5,a6,a7,a8,a9) LOG9(xbt_log_priority_critical, f,a1,a2,a3,a4,a5,a6,a7,a8,a9)
 688 /** @ingroup XBT_log
 689  *  @hideinitializer
 690  *  @brief Log an event at the CRITICAL priority on the default category with these args (CRITICALn exists for any n<10).
 691  */
 692 #define CRITICAL10(f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) LOG10(xbt_log_priority_critical, f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
 693
 694 /** @ingroup XBT_log
 695  *  @hideinitializer
 696  *  @brief Log at TRACE priority that we entered in current function.
 697  */
 698 #define XBT_IN               LOG1(xbt_log_priority_trace, ">> begin of %s",     _XBT_FUNCTION)
 699 #define XBT_IN1(fmt,a)       LOG2(xbt_log_priority_trace, ">> begin of %s" fmt, _XBT_FUNCTION, a)
 700 #define XBT_IN2(fmt,a,b)     LOG3(xbt_log_priority_trace, ">> begin of %s" fmt, _XBT_FUNCTION, a,b)
 701 #define XBT_IN3(fmt,a,b,c)   LOG4(xbt_log_priority_trace, ">> begin of %s" fmt, _XBT_FUNCTION, a,b,c)
 702 #define XBT_IN4(fmt,a,b,c,d) LOG5(xbt_log_priority_trace, ">> begin of %s" fmt, _XBT_FUNCTION, a,b,c,d)
 703 /** @ingroup XBT_log
 704  *  @hideinitializer
 705  *  @brief Log at TRACE priority that we entered in current function, appending a user specified format taking 5 args (XBT_INn exists for all n in [1,6])
 706  */
 707 #define XBT_IN5(fmt,a,b,c,d,e) LOG6(xbt_log_priority_trace, ">> begin of %s" fmt, _XBT_FUNCTION, a,b,c,d,e)
 708 #define XBT_IN6(fmt,a,b,c,d,e,f) LOG7(xbt_log_priority_trace, ">> begin of %s" fmt, _XBT_FUNCTION, a,b,c,d,e,f)
 709 /** @ingroup XBT_log
 710  *  @hideinitializer
 711  *  @brief Log at TRACE priority that we exited the current function.
 712  */
 713 #define XBT_OUT              LOG1(xbt_log_priority_trace, "<< end of %s",       _XBT_FUNCTION)
 714 /** @ingroup XBT_log
 715  *  @hideinitializer
 716  *  @brief Log at TRACE priority a message indicating that we reached that point.
 717  */
 718 #define XBT_HERE             LOG0(xbt_log_priority_trace, "-- was here")
 719
 720
 721 SG_END_DECL()
 722 #endif                          /* ! _XBT_LOG_H_ */