wtflip 0.1.5

A language in a Rust macro... or something.
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

#[macro_export]
macro_rules! wtflip {
    /* Mutable declaration. */
    (@as_statement mut $ident:ident := $($expr:tt)+) => {
        let mut $ident = wtflip!(@as_expr $($expr)+);
    };

    /* Assignment or immutable declaration. */
    (@as_statement $ident:ident $(: $(@$($_:tt)* $declaration:tt)?)?= $($expr:tt)+) => {
        $($($declaration)? let)? $ident = wtflip!(@as_expr $($expr)+);
    };

    /* A compatibility layer. Allows for writing Rust in the wtflip invocation. */
    (@as_statement @{ $($compat:tt)* }) => ($($compat)*);

    /* Macro invocation. The macro invocation can't be used in callback parsers because it itself expands a macro. */
    (@as_expr @ $(:: $(@$($_:tt)* $prefixed:tt)?)? $ident:ident $(:: $path:ident)* $(($($args:tt)*))?) => (
        $crate::args_splitter!(
            [$($($prefixed)? ::)? $ident $(:: $path)*!]
            [$crate::wtflip!]
            []
            []
            [$($($args)*)?]
        );
    );

    /* Callback helper that turns @as_expr into a proper @callback invocation. */
    (@as_expr $($tokens:tt)*) => (wtflip!(@callback [] [] @as_expr $($tokens)*));

    /* @as_expr $literal callback. */
    (@callback [$($cb:tt)*] [$($args:tt)*]
        @as_expr $lit:literal $($tail:tt)*
    ) => (wtflip!(@callback [$($cb)*] [$($args)* [$lit]] $($tail)*));

    /* The compat layer but in expression position. */
    (@callback [$($cb:tt)*] [$($args:tt)*]
        @as_expr @{ $($tokens:tt)* } $($tail:tt)*
    ) => (wtflip!(@callback [$($cb)*] [$($args)* [{ $($tokens)* }]]));

    /* Convert empty callback arguments stack to an invocation of the callback with the now processed arguments. */
    (@callback [$($cb:tt)*] [$([$($arg:tt)*])*]) => ($($cb)*($($($arg)*),*));

    /* The end of a statement has been reached, process the buffer as a statement. */
    (@statement_accumulator [$($buffer:tt)*] ; $($tail:tt)*) => {
        wtflip!(@as_statement $($buffer)*);
        wtflip!($($tail)*);
    };

    /* Append all non semicolon tokens to the buffer which will be processed as a statement later. */
    (@statement_accumulator [$($buffer:tt)*] $token:tt $($tail:tt)*) => (wtflip!(
        @statement_accumulator [$($buffer)* $token] $($tail)*
    ));

    /* Finished munching the token tree */
    () => ();

    /* Just passes a non-empty token tree into a statement accumulator. */
    ($($tokens:tt)+) => (wtflip!(
        @statement_accumulator [] $($tokens)*
    ));
}

#[macro_export]
macro_rules! args_splitter {
    (
        [$($wrap:tt)*]
        [$($processor:tt)*]
        []
        [$([ $($out:tt)* ])*]
        []
    ) => ($($processor)*(@callback [$($wrap)*] [] $(@as_expr $($out)*)*));
    (
        [$($wrap:tt)*]
        [$($processor:tt)*]
        [$($current:tt)*]
        [$($out:tt)*]
        [$(, $($rest:tt)*)?]
    ) => ($crate::args_splitter!(
        [$($wrap)*]
        [$($processor)*]
        []
        [$($out)* [$($current)*]]
        [$($($rest)*)?]
    ));
    (
        [$($wrap:tt)*]
        [$($processor:tt)*]
        [$($current:tt)*]
        $out:tt
        [$no_comma:tt $($rest:tt)*]
    ) => ($crate::args_splitter!(
        [$($wrap)*]
        [$($processor)*]
        [$($current)* $no_comma]
        $out
        [$($rest)*]
    ));
}