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 expressions::Expression;
use expressions::expression;
use idents::{symbol, pattern};
use whitespace::{opt_space, space};

#[derive(Debug, PartialEq)]
pub enum InsertOrder {
    Before,
    After,
}

#[derive(Debug, PartialEq)]
pub enum Command {
    //Simple { name: String },
    Call {
        name: String,
        arguments: Vec<Expression>,
    },
    Include { file: String },
    Insert {
        order: InsertOrder,
        section: String,
    },
}

named!(inset_order<&str, InsertOrder>, alt_complete!(
    map!(tag!("BEFORE"), |_| InsertOrder::Before) |
    map!(tag!("AFTER"), |_| InsertOrder::After)
));

// named!(simple<&str, Command>, do_parse!(
//     name: symbol
//     >>
//     opt_space
//     >>
//     opt_complete!(tag!(";"))
//     >>
//     (Command::Simple {
//         name: name.into()
//     })
// ));

named!(call<&str, Command>, do_parse!(
    name: symbol
    >>
    wsc!(tag!("("))
    >>
    args: separated_nonempty_list!(
        wsc!(opt_complete!(tag!(","))),
        expression
    )
    >>
    wsc!(tag!(")"))
    >>
    opt_complete!(tag!(";"))
    >>
    (Command::Call {
        name: name.into(),
        arguments: args,
    })
));

named!(include<&str, Command>, do_parse!(
    tag!("INCLUDE")
    >>
    space
    >>
    file: pattern
    >>
    opt_space
    >>
    opt_complete!(tag!(";"))
    >>
    (Command::Include {
        file: file.into()
    })
));

named!(insert<&str, Command>, do_parse!(
    tag!("INSERT")
    >>
    order: wsc!(inset_order)
    >>
    section: symbol
    >>
    opt_space
    >>
    opt_complete!(tag!(";"))
    >>
    (Command::Insert {
        order,
        section: section.into(),
    })
));

named!(pub command<&str, Command>, alt_complete!(
    include | call | insert //| simple
));

#[cfg(test)]
mod tests {
    use commands::*;

    #[test]
    fn test_command() {
        assert_done!(command("OUTPUT_ARCH ( 0 ) ;"));
        assert_done!(command("OUTPUT_ARCH ( 0 )"));
        assert_done!(command("OUTPUT_ARCH ( 0 1 2 )"));
        assert_done!(command("OUTPUT_ARCH ( 0, 1 2 )"));
        assert_done!(command("OUTPUT_ARCH ( 0, 1, 2 )"));

        assert_fail!(command("OUTPUT_ARCH ( 0, 1, 2, )"));
        assert_fail!(command("OUTPUT_ARCH ( )"));

        assert_done!(command("INCLUDE abc.h ;"));
        assert_done!(command("INCLUDE\tabc.h"));

        assert_done!(command("INSERT BEFORE .text  ;"));
        assert_done!(command("INSERT  AFTER  .text"));
    }
}