axplat-macros 0.2.0

Procedural macros for the `axplat` crate
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

#![doc = include_str!("../README.md")]

use proc_macro::TokenStream;
use proc_macro2::Span;
use quote::quote;
use syn::{Error, FnArg, ItemFn, ReturnType};

fn compiler_error(err: Error) -> TokenStream {
    err.to_compile_error().into()
}

fn common_main(item: TokenStream, arg_num: usize, export_name: &str, err_msg: &str) -> TokenStream {
    let main = syn::parse_macro_input!(item as ItemFn);
    let mut err = if let ReturnType::Type(_, ty) = &main.sig.output {
        quote! { #ty }.to_string() != "!"
    } else {
        true
    };

    let args = &main.sig.inputs;
    for arg in args.iter() {
        if let FnArg::Typed(pat) = arg {
            let ty = &pat.ty;
            if quote! { #ty }.to_string() != "usize" {
                err = true;
                break;
            }
        }
    }
    if args.len() != arg_num {
        err = true;
    }

    if err {
        compiler_error(Error::new(Span::call_site(), err_msg))
    } else {
        quote! {
            #[unsafe(export_name = #export_name)]
            #main
        }
        .into()
    }
}

/// Marks a function to be called on the primary core after the platform
/// initialization.
///
/// The function signature must be `fn(cpu_id: usize, arg: usize) -> !`, where
/// `cpu_id` is the logical CPU ID (0, 1, ..., N-1, N is the number of CPU
/// cores on the platform), and `arg` is passed from the bootloader (typically
/// the device tree blob address).
///
/// # Example
///
/// ```rust
/// # use axplat_macros as axplat;
/// #[axplat::main]
/// fn primary_main(cpu_id: usize, arg: usize) -> ! {
///     todo!() // Your code here
/// }
#[proc_macro_attribute]
pub fn main(attr: TokenStream, item: TokenStream) -> TokenStream {
    if !attr.is_empty() {
        return compiler_error(Error::new(
            Span::call_site(),
            "expect an empty attribute or `#[axplat::main]`",
        ));
    };
    common_main(
        item,
        2,
        "__axplat_main",
        "expect a function with type `fn(cpu_id: usize, arg: usize) -> !`",
    )
}

/// Marks a function to be called on the secondary cores after the platform
/// initialization.
///
/// The function signature must be `fn(cpu_id: usize) -> !`, where `cpu_id` is
/// the logical CPU ID (0, 1, ..., N-1, N is the number of CPU cores on the
/// platform).
///
/// # Example
///
/// ```rust
/// # use axplat_macros as axplat;
/// #[axplat::secondary_main]
/// fn secondary_main(cpu_id: usize) -> ! {
///     todo!() // Your code here
/// }
#[proc_macro_attribute]
pub fn secondary_main(attr: TokenStream, item: TokenStream) -> TokenStream {
    if !attr.is_empty() {
        return compiler_error(Error::new(
            Span::call_site(),
            "expect an empty attribute or `#[axplat::secondary_main]`",
        ));
    };
    common_main(
        item,
        1,
        "__axplat_secondary_main",
        "expect a function with type `fn(cpu_id: usize) -> !`",
    )
}