algorithmify_macros 0.1.1

Macros for the algorithmify library
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

use proc_macro::TokenTree;

use crate::{
    expression_mapper::{map_expression, map_reference, try_get_indexed_access},
    token_iterator::TokenIterator,
};

#[derive(Debug)]
pub(crate) struct StatementMapping {
    pub(crate) mapping: String,
}

pub(crate) fn map_statement(buffer: &mut String, iterator: &mut TokenIterator) {
    let result = [
        try_map_assignment,
        try_map_indexed_assignment,
        try_map_expression,
    ]
    .iter()
    .map(|f| execute_assignment_mapping(iterator, f))
    .find(|result| result.is_some())
    .and_then(|result| result);

    if let Some(result) = result {
        *buffer += result.mapping.as_str();
        *buffer += ",";
    } else {
        if let Some(tokens) = iterator.next_nth(5) {
            let reps = tokens.iter().map(|i| i.to_string()).collect::<Vec<_>>();
            panic!("statement not recognized: {}", reps.join(" "));
        } else {
            panic!("end of statement reached unexpectedly");
        }
    }
}

fn execute_assignment_mapping(
    iterator: &mut TokenIterator,
    mapping: &fn(&mut TokenIterator) -> Option<StatementMapping>,
) -> Option<StatementMapping> {
    let index = iterator.index;
    let result = mapping(iterator);
    if result.is_none() {
        iterator.rewind_to(index);
    }
    return result;
}

fn try_map_assignment(iterator: &mut TokenIterator) -> Option<StatementMapping> {
    iterator.try_get_next_token("let");
    iterator.try_get_next_token("mut");

    let identifier = if let TokenTree::Ident(ident) = iterator.next()? {
        map_reference(ident)
    } else {
        return None;
    };

    iterator.try_get_next_token("=")?;
    let expression = map_expression(iterator)?;

    iterator.try_get_next_token(";")?;

    let mapping = format!(
        "algorithmify::expressions::Statement::Assignment({}, {})",
        identifier, expression.mapping
    );

    Some(StatementMapping { mapping })
}

fn try_map_indexed_assignment(iterator: &mut TokenIterator) -> Option<StatementMapping> {
    iterator.try_get_next_token("let");
    iterator.try_get_next_token("mut");

    let identifier = try_get_indexed_access(iterator)?;

    iterator.try_get_next_token("=")?;
    let expression = map_expression(iterator)?;

    iterator.try_get_next_token(";")?;

    let mapping = format!(
        "algorithmify::expressions::Statement::IndexedAssigment({}, {})",
        identifier, expression.mapping
    );

    Some(StatementMapping { mapping })
}

pub(crate) fn try_map_expression(iterator: &mut TokenIterator) -> Option<StatementMapping> {
    if let Some(expression) = map_expression(iterator) {
        if let (Some(_), Some(_), _) | (None, None, _) | (None, Some(_), false) = (
            iterator.try_get_next_token(";"),
            iterator.peek(),
            expression.needs_semicolon_unless_final,
        ) {
            let mapping = format!(
                "algorithmify::expressions::Statement::Expression({})",
                expression.mapping
            );
            return Some(StatementMapping { mapping });
        }
    }

    None
}