iart-core 0.1.2

The Infomation and Result Trace crate
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(
    feature = "for-nightly-try-support",
    feature(try_trait_v2),
    feature(try_trait_v2_residual)
)]
#![cfg_attr(feature = "for-nightly-likely-optimization", feature(likely_unlikely))]
#![cfg_attr(feature = "for-nightly-allocator-api-support", feature(allocator_api))]
#![cfg_attr(
    feature = "for-nightly-error-generic-member-access",
    feature(error_generic_member_access)
)]
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![doc = include_str!("../doc/modules/lib.md")]

extern crate alloc;
extern crate core;

#[macro_use]
mod utils;

pub mod events;
mod iart_impl;
#[cfg(test)]
mod tests;
mod types;

pub use types::*;

#[cfg(all(feature = "core_error-support", feature = "std"))]
compile_error!(
    "Feature 'core_error-support' cannot be used with 'std'. \
     Please disable 'core_error-support' when building for std targets."
);

#[cfg(all(feature = "std", feature = "enable-default-handler"))]
use crate::events::IartEvent;
use crate::utils::{const_str_to_usize, str_eq};
use core::sync::atomic::{AtomicPtr, Ordering};

#[allow(unused)]
pub const BACK_TRACE_MAX: usize = {
    if let Some(val) = option_env!("IART_TRACE_MAX") {
        const_str_to_usize(val)
    } else {
        32
    }
};

#[allow(unused)]
#[doc = include_str!("../doc/variable/TRACE_REMOVE_TYPE.md")]
pub const TRACE_REMOVE_TYPE: &str = {
    if let Some(s) = option_env!("IART_TRACE_TYPE") {
        if str_eq(s, "good") || str_eq(s, "first") || str_eq(s, "last") {
            s
        } else {
            panic!("Invalid IART_TRACE_TYPE!");
        }
    } else {
        "good"
    }
};

#[allow(unused)]
#[doc = include_str!("../doc/variable/TRACE_UNIQUE.md")]
pub const TRACE_UNIQUE: bool = !cfg!(feature = "no-trace-dedup");

#[doc = include_str!("../doc/variable/HANDLER.md")]
static HANDLER: AtomicPtr<()> = AtomicPtr::new(
    #[cfg(all(
        feature = "std",
        feature = "enable-default-handler",
        feature = "for-nightly-allocator-api-support"
    ))]
    {
        default_handler::<std::alloc::Global> as *mut ()
    },
    #[cfg(all(
        feature = "std",
        feature = "enable-default-handler",
        not(feature = "for-nightly-allocator-api-support")
    ))]
    {
        default_handler as *mut ()
    },
    #[cfg(not(all(feature = "std", feature = "enable-default-handler")))]
    core::ptr::null_mut(),
);

#[inline]
#[doc = include_str!("../doc/fn/set_handler.md")]
pub fn set_handler(f: IartLogger) {
    HANDLER.store(f as *mut (), Ordering::SeqCst);
}

#[inline]
#[doc = include_str!("../doc/fn/is_initialized_handler.md")]
pub fn is_initialized_handler() -> bool {
    !HANDLER.load(Ordering::Acquire).is_null()
}

#[doc = include_str!("../doc/fn/default_handler.md")]
#[cfg(all(
    feature = "std",
    feature = "enable-default-handler",
    not(feature = "for-nightly-allocator-api-support")
))]
pub fn default_handler(event: IartEvent, iart: IartHandleDetails) -> std::fmt::Result {
    match event {
        IartEvent::DroppedWithoutCheck => {
            eprintln!("IART dropped without check! {:?}", iart);
        }
        _ => {}
    }

    Ok(())
}

#[doc = include_str!("../doc/fn/default_handler.md")]
#[cfg(all(
    feature = "std",
    feature = "enable-default-handler",
    feature = "for-nightly-allocator-api-support"
))]
pub fn default_handler<A: alloc::alloc::Allocator + Clone + core::fmt::Debug>(
    event: IartEvent,
    iart: IartHandleDetails<A>,
) -> std::fmt::Result {
    match event {
        IartEvent::DroppedWithoutCheck => {
            eprintln!("IART dropped without check! {:?}", iart);
        }
        _ => {}
    }

    Ok(())
}