syd 3.54.1

rock-solid application kernel
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//
// Syd: rock-solid application kernel
// src/log/macros.rs: Logging macros
//
// Copyright (c) 2023, 2024, 2025, 2026 Ali Polatel <alip@chesswob.org>
//
// SPDX-License-Identifier: GPL-3.0

/// Formatted print which returns Result as Errno.
#[macro_export]
macro_rules! printf {
    () => {{}};
    ($($arg:tt)*) => {{
        use ::std::io::Write as _;
        let __s = format!($($arg)*);
        ::std::io::stdout().write_all(__s.as_bytes())
            .map_err(|error| $crate::err::err2no(&error))
    }};
}

/// Formatted println which returns Result as Errno.
#[macro_export]
macro_rules! printfln {
    () => {{
        use ::std::io::Write as _;
        ::std::io::stdout().write_all(b"\n")
            .map_err(|error| $crate::err::err2no(&error))
    }};
    ($($arg:tt)*) => {{
        use ::std::io::Write as _;
        let mut __s = format!($($arg)*);
        __s.push('\n');
        ::std::io::stdout().write_all(__s.as_bytes())
            .map_err(|error| $crate::err::err2no(&error))
    }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! log_impl {
    ($level:expr, $($key:literal : $value:expr),+) => {
        if $crate::log_enabled!($level) {
            let timestamp = $crate::log::now();
            let mut map = $crate::log::LogMap::new();
            $(
                if let Ok(value) = $crate::log::LogValue::try_serialize(&$value) {
                    let _ = map.try_insert($key, value);
                }
            )+
            if !map.is_empty() {
                $crate::log::log($level, timestamp, map);
            }
        }
    }
}

/// emerg! logging macro
#[macro_export]
macro_rules! emerg {
    ($($key:literal : $value:expr),+) => {
        $crate::log_impl!($crate::syslog::LogLevel::Emergent, $($key : $value),+)
    }
}

/// alert! logging macro
#[macro_export]
macro_rules! alert {
    ($($key:literal : $value:expr),+) => {
        $crate::log_impl!($crate::syslog::LogLevel::Alert, $($key : $value),+)
    }
}

/// crit! logging macro
#[macro_export]
macro_rules! crit {
    ($($key:literal : $value:expr),+) => {
        $crate::log_impl!($crate::syslog::LogLevel::Crit, $($key : $value),+)
    }
}

/// error! logging macro
#[macro_export]
macro_rules! error {
    ($($key:literal : $value:expr),+) => {
        $crate::log_impl!($crate::syslog::LogLevel::Err, $($key : $value),+)
    }
}

/// warn! logging macro
#[macro_export]
macro_rules! warn {
    ($($key:literal : $value:expr),+) => {
        $crate::log_impl!($crate::syslog::LogLevel::Warn, $($key : $value),+)
    }
}

/// notice! logging macro
#[macro_export]
macro_rules! notice {
    ($($key:literal : $value:expr),+) => {
        $crate::log_impl!($crate::syslog::LogLevel::Notice, $($key : $value),+)
    }
}

/// info! logging macro
#[macro_export]
macro_rules! info {
    ($($key:literal : $value:expr),+) => {
        $crate::log_impl!($crate::syslog::LogLevel::Info, $($key : $value),+)
    }
}

/// debug! logging macro
#[macro_export]
macro_rules! debug {
    ($($key:literal : $value:expr),+) => {
        $crate::log_impl!($crate::syslog::LogLevel::Debug, $($key : $value),+)
    }
}