spdlog_macros/
lib.rs

1//! Macros implementation of crate [`spdlog-rs`].
2//!
3//! `spdlog-macros` should currently not be used as a standalone dependency, use
4//! [`spdlog-rs`] instead.
5//!
6//! [`spdlog-rs`]: https://crates.io/crates/spdlog-rs
7
8mod normalize_forward;
9mod pattern;
10
11use proc_macro::TokenStream;
12use proc_macro2::TokenStream as TokenStream2;
13use quote::quote;
14
15#[proc_macro]
16pub fn pattern(input: TokenStream) -> TokenStream {
17    let pattern = syn::parse_macro_input!(input);
18    into_or_error(pattern::pattern_impl(pattern).map_err(Error::PatternParser))
19}
20
21#[proc_macro]
22pub fn runtime_pattern(input: TokenStream) -> TokenStream {
23    // We must make this macro a procedural macro because macro cannot match the "$"
24    // token which is used in the custom patterns.
25
26    let runtime_pattern = syn::parse_macro_input!(input);
27    into_or_error(pattern::runtime_pattern_impl(runtime_pattern).map_err(Error::PatternParser))
28}
29
30// Example:
31//
32// ```rust
33// normalize_forward!(callback => default[opt1: 1, opt2: {}, opt3: { 3 }, d], opt1: 10, a, b, c, opt3: { 30 });
34// // will be converted to
35// spdlog::callback!(opt1: 10, opt2: {}, opt3: { 30 }, d, a, b, c);
36// ```
37#[proc_macro]
38pub fn normalize_forward(input: TokenStream) -> TokenStream {
39    let normalize = syn::parse_macro_input!(input);
40    into_or_error(normalize_forward::normalize(normalize).map_err(Error::NormalizeForward))
41}
42
43enum Error {
44    PatternParser(spdlog_internal::pattern_parser::Error),
45    NormalizeForward(syn::Error),
46}
47
48impl Error {
49    fn emit(self) -> TokenStream2 {
50        match self {
51            Error::PatternParser(err) => {
52                let error = err.to_string();
53                quote!(compile_error!(#error))
54            }
55            Error::NormalizeForward(err) => err.to_compile_error(),
56        }
57    }
58}
59
60fn into_or_error(result: Result<TokenStream2, Error>) -> TokenStream {
61    match result {
62        Ok(stream) => stream.into(),
63        Err(err) => err.emit().into(),
64    }
65}