herring-derive 0.1.2

Macro implementation of #[derive(Herring)]
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

use herring_automata::Automaton;
use proc_macro2::{Ident, Span, TokenStream};
use quote::quote;

pub(crate) fn graph<const D: bool>(automaton: &Automaton<D>, name: &str) -> syn::Result<()> {
    if let Ok(val) = std::env::var("HERRING_DEBUG") {
        if val == "graphviz" {
            graphviz(automaton, &format!("{name}.dot"))
        } else if val == "mermaid" {
            mermaid(automaton, &format!("{name}.mmd"))
        } else {
            Ok(())
        }
    } else {
        Ok(())
    }
}

fn graphviz<const D: bool>(
    automaton: &herring_automata::Automaton<D>,
    name: &str,
) -> syn::Result<()> {
    use proc_macro2::Span;
    use syn::Error;
    if let Err(err) = automaton.print_graphviz(name) {
        return Err(Error::new(
            Span::call_site(),
            format!("error writing debug file: {err}"),
        ));
    }
    Ok(())
}

fn mermaid<const D: bool>(
    automaton: &herring_automata::Automaton<D>,
    name: &str,
) -> syn::Result<()> {
    use proc_macro2::Span;
    use syn::Error;
    if let Err(err) = automaton.print_mermaid(name) {
        return Err(Error::new(
            Span::call_site(),
            format!("error writing debug file: {err}"),
        ));
    }
    Ok(())
}

pub(crate) fn log_state(state: usize) -> TokenStream {
    if let Ok(val) = std::env::var("HERRING_DEBUG") {
        if val == "log" {
            return quote! { eprintln!("STATE: S{}", #state); };
        }
    }
    quote! {}
}

pub(crate) fn expand_or_skip(output: TokenStream, enum_name: &Ident) -> syn::Result<TokenStream> {
    fn write_file(output: TokenStream, enum_name: &Ident) -> std::io::Result<()> {
        use std::io::Write;
        let mut f =
            std::fs::File::create(format!("{}_lexer.rs", enum_name.to_string().to_lowercase()))?;
        write!(f, "{output}")
    }
    if let Ok(val) = std::env::var("HERRING_DEBUG") {
        match val.as_str() {
            "expand" => {
                if let Err(err) = write_file(output, enum_name) {
                    return Err(syn::Error::new(
                        Span::call_site(),
                        format!("error writing output file: {err}"),
                    ));
                }
                return Ok(quote! {});
            }
            "skip" => {
                return Ok(quote! {});
            }
            _ => {}
        }
    }
    Ok(output)
}