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
//! Procedural macros for [drone-core].
//!
//! [drone-core]: https://github.com/drone-os/drone-core

#![warn(unsafe_op_in_unsafe_fn)]
#![warn(clippy::pedantic)]
#![allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::similar_names)]

extern crate proc_macro;

mod bitfield;
mod config_override;
mod heap;
mod log_baud_rate;
mod periph;
mod periph_map;
mod periph_singular;
mod reg;
mod reg_assert_taken;
mod reg_tokens;
mod reg_tokens_inner;
mod simple_token;
mod simple_tokens;
mod static_tokens;
mod thr_pool;
mod thr_soft;

use proc_macro::TokenStream;

#[proc_macro_derive(Bitfield, attributes(bitfield))]
pub fn derive_bitfield(input: TokenStream) -> TokenStream {
    bitfield::proc_macro_derive(input)
}

#[proc_macro]
pub fn config_override(input: TokenStream) -> TokenStream {
    config_override::proc_macro(input)
}

#[proc_macro]
pub fn heap(input: TokenStream) -> TokenStream {
    heap::proc_macro(input)
}

#[proc_macro]
pub fn log_baud_rate(input: TokenStream) -> TokenStream {
    log_baud_rate::proc_macro(input)
}

#[proc_macro]
pub fn periph(input: TokenStream) -> TokenStream {
    periph::proc_macro(input)
}

#[proc_macro]
pub fn periph_map(input: TokenStream) -> TokenStream {
    periph_map::proc_macro(input)
}

#[proc_macro]
pub fn periph_singular(input: TokenStream) -> TokenStream {
    periph_singular::proc_macro(input)
}

#[proc_macro]
pub fn reg(input: TokenStream) -> TokenStream {
    reg::proc_macro(input)
}

#[proc_macro]
pub fn reg_assert_taken(input: TokenStream) -> TokenStream {
    reg_assert_taken::proc_macro(input)
}

#[proc_macro]
pub fn reg_tokens(input: TokenStream) -> TokenStream {
    reg_tokens::proc_macro(input)
}

#[proc_macro]
pub fn reg_tokens_inner(input: TokenStream) -> TokenStream {
    reg_tokens_inner::proc_macro(input)
}

#[proc_macro]
pub fn simple_token(input: TokenStream) -> TokenStream {
    simple_token::proc_macro(input)
}

#[proc_macro]
pub fn unsafe_simple_tokens(input: TokenStream) -> TokenStream {
    simple_tokens::proc_macro(input)
}

#[proc_macro]
pub fn unsafe_static_tokens(input: TokenStream) -> TokenStream {
    static_tokens::proc_macro(input)
}

#[proc_macro]
pub fn thr_pool(input: TokenStream) -> TokenStream {
    thr_pool::proc_macro(input)
}

#[proc_macro]
pub fn thr_soft(input: TokenStream) -> TokenStream {
    thr_soft::proc_macro(input)
}