1#[macro_export]
2macro_rules! do_log_filter {
3 (target: $target:expr, $log_filter:expr, $lvl:expr, $($arg:tt)+) => ({
4 let lvl = $lvl;
5 if lvl <= log::STATIC_MAX_LEVEL && lvl as usize <= $log_filter.get_level() && lvl <= log::max_level() {
6 $log_filter._private_api_log(
7 std::format_args!($($arg)+),
8 lvl,
9 &($target, std::module_path!(), std::file!(), std::line!()),
10 );
11 }
12 });
13 ($log_filter:expr, $lvl:expr, $($arg:tt)+) => (do_log_filter!(target: std::module_path!(), $log_filter, $lvl, $($arg)+))
14}
15#[allow(unused_imports)]
16pub(super) use do_log_filter;
17
18#[macro_export]
19macro_rules! logger_error {
20 ($log_filter:expr, $($arg:tt)+) => (
21 do_log_filter!($log_filter, log::Level::Error, $($arg)+);
22 )
23}
24#[allow(unused_imports)]
25pub(super) use logger_error;
26
27#[macro_export]
28macro_rules! logger_warn {
29 ($log_filter:expr, $($arg:tt)+) => (
30 do_log_filter!($log_filter, log::Level::Warn, $($arg)+);
31 )
32}
33#[allow(unused_imports)]
34pub(super) use logger_warn;
35
36#[macro_export]
37macro_rules! logger_info {
38 ($log_filter:expr, $($arg:tt)+) => (
39 do_log_filter!($log_filter, log::Level::Info, $($arg)+);
40 )
41}
42#[allow(unused_imports)]
43pub(super) use logger_info;
44
45#[macro_export]
46macro_rules! logger_debug {
47 ($log_filter:expr, $($arg:tt)+) => (
48 do_log_filter!($log_filter, log::Level::Debug, $($arg)+);
49 )
50}
51#[allow(unused_imports)]
52pub(super) use logger_debug;
53
54#[macro_export]
55macro_rules! logger_trace {
56 ($log_filter:expr, $($arg:tt)+) => (
57 do_log_filter!($log_filter, log::Level::Trace, $($arg)+);
58 )
59}
60#[allow(unused_imports)]
61pub(super) use logger_trace;
62
63#[macro_export]
64macro_rules! logger_debug_assert {
65 ($log_filter:expr, $($arg:tt)*) => (if std::cfg!(debug_assertions) { $crate::logger_assert!($log_filter, $($arg)*); });
66}
67#[allow(unused_imports)]
68pub(super) use logger_debug_assert;
69
70#[macro_export]
71macro_rules! logger_debug_assert_eq {
72 ($log_filter:expr, $($arg:tt)*) => (if std::cfg!(debug_assertions) { $crate::logger_assert_eq!($log_filter, $($arg)*); })
73}
74#[allow(unused_imports)]
75pub(super) use logger_debug_assert_eq;
76
77#[macro_export]
78macro_rules! logger_assert {
79 ($log_filter:expr, $cond:expr) => ({
80 if !$cond {
81 do_log_filter!(
82 $log_filter,
83 log::Level::Error,
84 "assertion failed: {:?}",
85 $cond
86 );
87 std::panic!(r#"assertion failed: {:?}"#, $cond);
88 }
89 });
90 ($log_filter:expr, $cond:expr,) => ({
91 $crate::logger_assert!($log_filter, $cond);
92 });
93 ($log_filter:expr, $cond:expr, $($arg:tt)+) => ({
94 if !$cond {
95 do_log_filter!(
96 $log_filter,
97 log::Level::Error,
98 "assertion failed: {}",
99 std::format_args!($($arg)+)
100 );
101 std::panic!(r#"{}"#, std::format_args!($($arg)+));
102 }
103 });
104}
105#[allow(unused_imports)]
106pub(super) use logger_assert;
107
108#[macro_export]
109macro_rules! log_println {
110 ($($arg:tt)+) => {
111 std::println!($($arg)+);
112 log::info!($($arg)+);
113 }
114}
115#[allow(unused_imports)]
116pub(super) use log_println;
117
118#[macro_export]
119macro_rules! logger_assert_eq {
120 ($log_filter:expr, $left:expr, $right:expr) => ({
121 match (&$left, &$right) {
122 (left_val, right_val) => {
123 if !(*left_val == *right_val) {
124 do_log_filter!($log_filter, log::Level::Error, "assertion failed! \
125 expected: (`left == right`) actual: (`{:?}` != `{:?}`)", &*left_val, &*right_val);
126 std::panic!(r#"assertion failed: `(left == right)`
127 left: `{:?}`,
128 right: `{:?}`"#, &*left_val, &*right_val);
129 }
130 }
131 }
132 });
133 ($log_filter:expr, $left:expr, $right:expr,) => ({
134 $crate::logger_assert_eq!($log_filter, $left, $right);
135 });
136 ($log_filter:expr, $left:expr, $right:expr, $($arg:tt)+) => ({
137 match (&($left), &($right)) {
138 (left_val, right_val) => {
139 if !(*left_val == *right_val) {
140 do_log_filter!($log_filter, log::Level::Error, "assertion failed! \
141 expected: `(left == right)` actual: (`{:?}` != `{:?}`)", &*left_val, &*right_val);
142 std::panic!(r#"assertion failed: `(left == right)`
143 left: `{:?}`,
144 right: `{:?}`: {}"#, &*left_val, &*right_val,
145 std::format_args!($($arg)+));
146 }
147 }
148 }
149 });
150}
151#[allow(unused_imports)]
152pub(super) use logger_assert_eq;
153
154#[macro_export]
155macro_rules! log_debug_assert {
156 ($($arg:tt)*) => (if std::cfg!(debug_assertions) { $crate::log_assert!($($arg)*); });
157}
158#[allow(unused_imports)]
159pub(super) use log_debug_assert;
160
161#[macro_export]
162macro_rules! log_debug_assert_eq {
163 ($($arg:tt)*) => (if std::cfg!(debug_assertions) { $crate::log_assert_eq!($($arg)*); })
164}
165#[allow(unused_imports)]
166pub(super) use log_debug_assert_eq;
167
168#[macro_export]
169macro_rules! log_assert {
170 ($cond:expr) => ({
171 if !$cond {
172 log::error!(
173 "assertion failed: {:?}",
174 $cond
175 );
176 std::panic!(r#"assertion failed: {:?}"#, $cond);
177 }
178 });
179 ($cond:expr,) => ({
180 $crate::log_assert!($log_filter, $cond);
181 });
182 ($cond:expr, $($arg:tt)+) => ({
183 if !$cond {
184 log::error!(
185 "assertion failed: {}",
186 std::format_args!($($arg)+)
187 );
188 std::panic!(r#"{}"#, std::format_args!($($arg)+));
189 }
190 });
191}
192#[allow(unused_imports)]
193pub(super) use log_assert;
194
195#[macro_export]
196macro_rules! log_assert_eq {
197 ($left:expr, $right:expr) => ({
198 match (&$left, &$right) {
199 (left_val, right_val) => {
200 if !(*left_val == *right_val) {
201 log::error!("assertion failed! \
202 expected: (`left == right`) actual: (`{:?}` != `{:?}`)", &*left_val, &*right_val);
203 std::panic!(r#"assertion failed: `(left == right)`
204 left: `{:?}`,
205 right: `{:?}`"#, &*left_val, &*right_val);
206 }
207 }
208 }
209 });
210 ($left:expr, $right:expr,) => ({
211 $crate::log_assert_eq!($left, $right);
212 });
213 ($left:expr, $right:expr, $($arg:tt)+) => ({
214 match (&($left), &($right)) {
215 (left_val, right_val) => {
216 if !(*left_val == *right_val) {
217 log::error!( "assertion failed! \
218 expected: `(left == right)` actual: (`{:?}` != `{:?}`)", &*left_val, &*right_val);
219 std::panic!(r#"assertion failed: `(left == right)`
220 left: `{:?}`,
221 right: `{:?}`: {}"#, &*left_val, &*right_val,
222 std::format_args!($($arg)+));
223 }
224 }
225 }
226 });
227}
228
229#[allow(unused_imports)]
230pub(super) use log_assert_eq;