Skip to main content

fixed_record_macros/
lib.rs

1#![deny(unsafe_op_in_unsafe_fn)]
2use proc_macro::TokenStream;
3use syn::{
4    DeriveInput, Expr, Lit, Token,
5    parse::{Parse, ParseStream},
6    parse_macro_input,
7};
8
9mod core;
10mod helpers;
11mod list;
12
13struct MacroArgs {
14    clear_byte: u8,
15}
16
17impl Default for MacroArgs {
18    fn default() -> Self {
19        Self { clear_byte: b' ' }
20    }
21}
22
23impl Parse for MacroArgs {
24    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
25        let mut args = Self::default();
26
27        while !input.is_empty() {
28            let ident: syn::Ident = input.parse()?;
29            input.parse::<Token![=]>()?;
30            let expr: Expr = input.parse()?;
31
32            if ident == "clear_byte" {
33                args.clear_byte = parse_clear_byte(&expr)?;
34            } else {
35                return Err(syn::Error::new_spanned(
36                    ident,
37                    "unsupported fixed_record option",
38                ));
39            }
40
41            if input.peek(Token![,]) {
42                input.parse::<Token![,]>()?;
43            }
44        }
45
46        Ok(args)
47    }
48}
49
50fn parse_clear_byte(expr: &Expr) -> syn::Result<u8> {
51    if let Expr::Path(expr_path) = expr {
52        if expr_path.path.is_ident("ZERO") {
53            return Ok(0x00);
54        }
55        if expr_path.path.is_ident("SPACE") {
56            return Ok(b' ');
57        }
58        return Err(syn::Error::new_spanned(
59            expr,
60            "clear_byte must be ZERO, SPACE, a byte literal, or an integer from 0 to 255",
61        ));
62    }
63
64    let Expr::Lit(expr_lit) = expr else {
65        return Err(syn::Error::new_spanned(
66            expr,
67            "clear_byte must be ZERO, SPACE, a byte literal, or an integer from 0 to 255",
68        ));
69    };
70
71    match &expr_lit.lit {
72        Lit::Byte(lit_byte) => Ok(lit_byte.value()),
73        Lit::Int(lit_int) => lit_int.base10_parse::<u8>().map_err(|err| {
74            syn::Error::new_spanned(lit_int, format!("invalid clear_byte value: {err}"))
75        }),
76        _ => Err(syn::Error::new_spanned(
77            expr,
78            "clear_byte must be ZERO, SPACE, a byte literal, or an integer from 0 to 255",
79        )),
80    }
81}
82
83/// Generates helper types and implementations for fixed-width records.
84/// 固定長レコード用の補助型と実装を生成する attribute macro です。
85#[proc_macro_attribute]
86pub fn fixed_record(attr: TokenStream, item: TokenStream) -> TokenStream {
87    let args = parse_macro_input!(attr as MacroArgs);
88    let input = parse_macro_input!(item as DeriveInput);
89    let options = core::MacroOptions {
90        clear_byte: args.clear_byte,
91    };
92
93    match core::expand_fixed_record(&input, options) {
94        Ok(tokens) => tokens.into(),
95        Err(error) => error.to_compile_error().into(),
96    }
97}