|  | @@ -92,13 +92,20 @@
 | 
	
		
			
				|  |  |  #define tor_assert(a) STMT_BEGIN                                        \
 | 
	
		
			
				|  |  |    (void)(a);                                                            \
 | 
	
		
			
				|  |  |    STMT_END
 | 
	
		
			
				|  |  | +#define tor_assertf(a, fmt, ...) STMT_BEGIN                             \
 | 
	
		
			
				|  |  | +  (void)(a);                                                            \
 | 
	
		
			
				|  |  | +  (void)(fmt);                                                          \
 | 
	
		
			
				|  |  | +  STMT_END
 | 
	
		
			
				|  |  |  #else
 | 
	
		
			
				|  |  |  /** Like assert(3), but send assertion failures to the log as well as to
 | 
	
		
			
				|  |  |   * stderr. */
 | 
	
		
			
				|  |  | -#define tor_assert(expr) STMT_BEGIN                                     \
 | 
	
		
			
				|  |  | +#define tor_assert(expr) tor_assertf(expr, NULL)
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +#define tor_assertf(expr, fmt, ...) STMT_BEGIN                          \
 | 
	
		
			
				|  |  |    if (ASSERT_PREDICT_LIKELY_(expr)) {                                   \
 | 
	
		
			
				|  |  |    } else {                                                              \
 | 
	
		
			
				|  |  | -    tor_assertion_failed_(SHORT_FILE__, __LINE__, __func__, #expr);     \
 | 
	
		
			
				|  |  | +    tor_assertion_failed_(SHORT_FILE__, __LINE__, __func__, #expr,      \
 | 
	
		
			
				|  |  | +                          fmt, ##__VA_ARGS__);                          \
 | 
	
		
			
				|  |  |      abort();                                                            \
 | 
	
		
			
				|  |  |    } STMT_END
 | 
	
		
			
				|  |  |  #endif /* defined(TOR_UNIT_TESTS) && defined(DISABLE_ASSERTS_IN_UNIT_TESTS) */
 | 
	
	
		
			
				|  | @@ -106,7 +113,7 @@
 | 
	
		
			
				|  |  |  #define tor_assert_unreached()                                  \
 | 
	
		
			
				|  |  |    STMT_BEGIN {                                                  \
 | 
	
		
			
				|  |  |      tor_assertion_failed_(SHORT_FILE__, __LINE__, __func__,     \
 | 
	
		
			
				|  |  | -                          "line should be unreached");          \
 | 
	
		
			
				|  |  | +                          "line should be unreached", NULL);    \
 | 
	
		
			
				|  |  |      abort();                                                    \
 | 
	
		
			
				|  |  |    } STMT_END
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -136,6 +143,7 @@
 | 
	
		
			
				|  |  |  #ifdef ALL_BUGS_ARE_FATAL
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal_unreached() tor_assert(0)
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal(cond) tor_assert((cond))
 | 
	
		
			
				|  |  | +#define tor_assertf_nonfatal(cond, fmt, ...) tor_assertf(cond, fmt, ...)
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal_unreached_once() tor_assert(0)
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal_once(cond) tor_assert((cond))
 | 
	
		
			
				|  |  |  #define BUG(cond)                                                       \
 | 
	
	
		
			
				|  | @@ -146,24 +154,35 @@
 | 
	
		
			
				|  |  |  #elif defined(TOR_UNIT_TESTS) && defined(DISABLE_ASSERTS_IN_UNIT_TESTS)
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal_unreached() STMT_NIL
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal(cond) ((void)(cond))
 | 
	
		
			
				|  |  | +#define tor_assertf_nonfatal(cond, fmt, ...) STMT_BEGIN                 \
 | 
	
		
			
				|  |  | +  (void)cond;                                                           \
 | 
	
		
			
				|  |  | +  (void)fmt;                                                            \
 | 
	
		
			
				|  |  | +  STMT_END
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal_unreached_once() STMT_NIL
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal_once(cond) ((void)(cond))
 | 
	
		
			
				|  |  |  #define BUG(cond) (ASSERT_PREDICT_UNLIKELY_(cond) ? 1 : 0)
 | 
	
		
			
				|  |  |  #else /* Normal case, !ALL_BUGS_ARE_FATAL, !DISABLE_ASSERTS_IN_UNIT_TESTS */
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal_unreached() STMT_BEGIN                      \
 | 
	
		
			
				|  |  | -  tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__, NULL, 0);         \
 | 
	
		
			
				|  |  | +  tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__, NULL, 0, NULL);   \
 | 
	
		
			
				|  |  |    STMT_END
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal(cond) STMT_BEGIN                            \
 | 
	
		
			
				|  |  |    if (ASSERT_PREDICT_LIKELY_(cond)) {                                   \
 | 
	
		
			
				|  |  |    } else {                                                              \
 | 
	
		
			
				|  |  | -    tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__, #cond, 0);      \
 | 
	
		
			
				|  |  | +    tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__, #cond, 0, NULL);\
 | 
	
		
			
				|  |  | +  }                                                                     \
 | 
	
		
			
				|  |  | +  STMT_END
 | 
	
		
			
				|  |  | +#define tor_assertf_nonfatal(cond, fmt, ...) STMT_BEGIN                 \
 | 
	
		
			
				|  |  | +  if (ASSERT_PREDICT_UNLIKELY_(cond)) {                                 \
 | 
	
		
			
				|  |  | +  } else {                                                              \
 | 
	
		
			
				|  |  | +    tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__, #cond, 0,        \
 | 
	
		
			
				|  |  | +                      fmt, ##__VA_ARGS__);                               \
 | 
	
		
			
				|  |  |    }                                                                     \
 | 
	
		
			
				|  |  |    STMT_END
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal_unreached_once() STMT_BEGIN                 \
 | 
	
		
			
				|  |  |    static int warning_logged__ = 0;                                      \
 | 
	
		
			
				|  |  |    if (!warning_logged__) {                                              \
 | 
	
		
			
				|  |  |      warning_logged__ = 1;                                               \
 | 
	
		
			
				|  |  | -    tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__, NULL, 1);       \
 | 
	
		
			
				|  |  | +    tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__, NULL, 1, NULL); \
 | 
	
		
			
				|  |  |    }                                                                     \
 | 
	
		
			
				|  |  |    STMT_END
 | 
	
		
			
				|  |  |  #define tor_assert_nonfatal_once(cond) STMT_BEGIN                       \
 | 
	
	
		
			
				|  | @@ -171,12 +190,12 @@
 | 
	
		
			
				|  |  |    if (ASSERT_PREDICT_LIKELY_(cond)) {                                   \
 | 
	
		
			
				|  |  |    } else if (!warning_logged__) {                                       \
 | 
	
		
			
				|  |  |      warning_logged__ = 1;                                               \
 | 
	
		
			
				|  |  | -    tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__, #cond, 1);      \
 | 
	
		
			
				|  |  | +    tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__, #cond, 1, NULL);\
 | 
	
		
			
				|  |  |    }                                                                     \
 | 
	
		
			
				|  |  |    STMT_END
 | 
	
		
			
				|  |  |  #define BUG(cond)                                                       \
 | 
	
		
			
				|  |  |    (ASSERT_PREDICT_UNLIKELY_(cond) ?                                     \
 | 
	
		
			
				|  |  | -   (tor_bug_occurred_(SHORT_FILE__,__LINE__,__func__,"!("#cond")",0), 1) \
 | 
	
		
			
				|  |  | +  (tor_bug_occurred_(SHORT_FILE__,__LINE__,__func__,"!("#cond")",1,NULL),1) \
 | 
	
		
			
				|  |  |     : 0)
 | 
	
		
			
				|  |  |  #endif /* defined(ALL_BUGS_ARE_FATAL) || ... */
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -188,7 +207,7 @@
 | 
	
		
			
				|  |  |        if (bool_result && !var) {                                        \
 | 
	
		
			
				|  |  |          var = 1;                                                        \
 | 
	
		
			
				|  |  |          tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__,             \
 | 
	
		
			
				|  |  | -                          "!("#cond")", 1);                             \
 | 
	
		
			
				|  |  | +                          "!("#cond")", 1, NULL);                       \
 | 
	
		
			
				|  |  |        }                                                                 \
 | 
	
		
			
				|  |  |        bool_result; } ))
 | 
	
		
			
				|  |  |  #else /* !(defined(__GNUC__)) */
 | 
	
	
		
			
				|  | @@ -198,7 +217,7 @@
 | 
	
		
			
				|  |  |        (var ? 1 :                                                        \
 | 
	
		
			
				|  |  |         (var=1,                                                          \
 | 
	
		
			
				|  |  |          tor_bug_occurred_(SHORT_FILE__, __LINE__, __func__,             \
 | 
	
		
			
				|  |  | -                           "!("#cond")", 1),                            \
 | 
	
		
			
				|  |  | +                           "!("#cond")", 1, NULL),                      \
 | 
	
		
			
				|  |  |          1))                                                             \
 | 
	
		
			
				|  |  |        : 0)
 | 
	
		
			
				|  |  |  #endif /* defined(__GNUC__) */
 | 
	
	
		
			
				|  | @@ -221,10 +240,11 @@
 | 
	
		
			
				|  |  |  #define tor_fragile_assert() tor_assert_nonfatal_unreached_once()
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  void tor_assertion_failed_(const char *fname, unsigned int line,
 | 
	
		
			
				|  |  | -                           const char *func, const char *expr);
 | 
	
		
			
				|  |  | +                           const char *func, const char *expr,
 | 
	
		
			
				|  |  | +                           const char *fmt, ...);
 | 
	
		
			
				|  |  |  void tor_bug_occurred_(const char *fname, unsigned int line,
 | 
	
		
			
				|  |  |                         const char *func, const char *expr,
 | 
	
		
			
				|  |  | -                       int once);
 | 
	
		
			
				|  |  | +                       int once, const char *fmt, ...);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  #ifdef _WIN32
 | 
	
		
			
				|  |  |  #define SHORT_FILE__ (tor_fix_source_file(__FILE__))
 |