texform-knowledge-macros 0.1.0

Procedural macros for the TeXForm knowledge base (internal; use the texform 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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use proc_macro::TokenStream;

use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::{LitStr, parse_macro_input};
use texform_argspec::{ArgForm, ArgSpec, DelimiterToken, ValueKind, parse_arg_specs};

#[proc_macro]
pub fn argspec(input: TokenStream) -> TokenStream {
    let literal = parse_macro_input!(input as LitStr);
    let source = literal.value();
    match parse_arg_specs(source.as_str(), "argspec literal") {
        Ok(specs) => render_parsed_arg_spec(specs.as_slice(), source.as_str()).into(),
        Err(error) => syn::Error::new(
            literal.span(),
            format!(
                "invalid argspec literal at char {}: {}",
                error.char_index, error.message
            ),
        )
        .to_compile_error()
        .into(),
    }
}

fn render_parsed_arg_spec(specs: &[ArgSpec], source: &str) -> TokenStream2 {
    let rendered_specs = specs.iter().map(render_arg_spec);
    quote! {
        ::texform_knowledge::specs::ParsedArgSpec {
            args: &[#(#rendered_specs),*],
            source: #source,
        }
    }
}

fn render_arg_spec(spec: &ArgSpec) -> TokenStream2 {
    let required = spec.required;
    let no_leading_space = spec.no_leading_space;
    let nullable = spec.nullable;
    let kind = render_value_kind(spec.kind);
    let form = render_arg_form(&spec.form);

    quote! {
        ::texform_knowledge::specs::ArgSpec {
            required: #required,
            no_leading_space: #no_leading_space,
            nullable: #nullable,
            kind: #kind,
            form: #form,
        }
    }
}

fn render_value_kind(kind: ValueKind) -> TokenStream2 {
    match kind {
        ValueKind::Content { mode } => {
            let mode = render_content_mode(mode);
            quote! {
                ::texform_knowledge::specs::ValueKind::Content { mode: #mode }
            }
        }
        ValueKind::Delimiter => quote!(::texform_knowledge::specs::ValueKind::Delimiter),
        ValueKind::CSName => quote!(::texform_knowledge::specs::ValueKind::CSName),
        ValueKind::Dimension => quote!(::texform_knowledge::specs::ValueKind::Dimension),
        ValueKind::Integer => quote!(::texform_knowledge::specs::ValueKind::Integer),
        ValueKind::KeyVal => quote!(::texform_knowledge::specs::ValueKind::KeyVal),
        ValueKind::Column => quote!(::texform_knowledge::specs::ValueKind::Column),
        ValueKind::Star => quote!(::texform_knowledge::specs::ValueKind::Star),
    }
}

fn render_arg_form(form: &ArgForm) -> TokenStream2 {
    match form {
        ArgForm::Standard => quote!(::texform_knowledge::specs::ArgForm::Standard),
        ArgForm::Star => quote!(::texform_knowledge::specs::ArgForm::Star),
        ArgForm::Group => quote!(::texform_knowledge::specs::ArgForm::Group),
        ArgForm::Delimited { open, close } => {
            let open = render_delimiter_token(open);
            let close = render_delimiter_token(close);
            quote! {
                ::texform_knowledge::specs::ArgForm::Delimited {
                    open: #open,
                    close: #close,
                }
            }
        }
        ArgForm::Paired { pairs } => {
            let rendered_pairs = pairs.iter().map(|(open, close)| {
                let open = render_delimiter_token(open);
                let close = render_delimiter_token(close);
                quote! { (#open, #close) }
            });
            quote! {
                ::texform_knowledge::specs::ArgForm::Paired {
                    pairs: ::std::borrow::Cow::Borrowed(&[#(#rendered_pairs),*]),
                }
            }
        }
    }
}

fn render_delimiter_token(token: &DelimiterToken) -> TokenStream2 {
    match token {
        DelimiterToken::Char(ch) => quote!(::texform_knowledge::specs::DelimiterToken::Char(#ch)),
        DelimiterToken::ControlSeq(name) => {
            let name = name.as_ref();
            quote! {
                ::texform_knowledge::specs::DelimiterToken::ControlSeq(
                    ::std::borrow::Cow::Borrowed(#name)
                )
            }
        }
    }
}

fn render_content_mode(mode: texform_argspec::ContentMode) -> TokenStream2 {
    match mode {
        texform_argspec::ContentMode::Math => quote!(::texform_knowledge::specs::ContentMode::Math),
        texform_argspec::ContentMode::Text => quote!(::texform_knowledge::specs::ContentMode::Text),
    }
}