ninja-build-syntax 0.0.2

Parser for ninja's manifest file format, i.e. `ninja.build` files.
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

use std::result;

use bstr::ByteSlice as _;

type Error<'a> = nom::Err<(&'a [u8], nom::error::ErrorKind)>;
type Result<'a, T> = result::Result<(&'a [u8], T), Error<'a>>;

pub fn test_parse_impl<T: PartialEq<T> + ::std::fmt::Debug>(
    expected_result: T,
    expected_rest: &[u8],
    parse_input: &[u8],
    actual_iresult: Result<T>,
    parse_function_name: &str,
    filename: &str,
    line: u32,
) {
    match actual_iresult {
        Ok((ref actual_rest, ref actual_result))
            if *actual_rest == expected_rest && *actual_result == expected_result => {}
        Ok((actual_rest, actual_result)) => {
            panic!(
                r#"
{}:{}: Parsing failed:
    input:         {:?}
    function:      {}
    expected:      {:?}
    expected rest: {:?}
    actual:        {:?}
    actual_rest:   {:?}
"#,
                filename,
                line,
                parse_input.as_bstr(),
                parse_function_name,
                expected_result,
                expected_rest.as_bstr(),
                actual_result,
                actual_rest.as_bstr(),
            );
        }
        Err(error) => {
            panic!(
                r#"
{}:{}: Parsing failed:
    input:         {:?}
    function:      {}
    error:         {:?}
"#,
                filename,
                line,
                parse_input.as_bstr(),
                parse_function_name,
                error,
            );
        }
    }
}

#[macro_export]
macro_rules! test_parse {
    ($parse_function:ident($parse_input:expr), $expected_result:expr) => {
        test_parse!($parse_function($parse_input), $expected_result, b"")
    };
    ($parse_function:ident($parse_input:expr), $expected_result:expr, $rest:expr) => {
        $crate::parsers::test_macros::test_parse_impl(
            $expected_result,
            &$rest[..],
            &$parse_input[..],
            $parse_function(&$parse_input[..]),
            stringify!($parse_function),
            file!(),
            line!(),
        );
    };
}
macro_rules! test_parse_error {
    ($parse_function:ident($parse_input:expr)) => {
        match $parse_function(&$parse_input[..]) {
            Err(nom::Err::Error(_)) | Err(nom::Err::Failure(_)) => (),
            x => panic!(
                "expected {}({:?}) to return Error but got {:?}",
                stringify!($parse_function),
                &$parse_input[..],
                x
            ),
        }
    };
}

macro_rules! value {
    ( $( $item:expr ),* ) => {
        Value(vec![ $( $item ),* ])
    };
    ( $( $item:expr ),* , ) => {
        value![ $( $item ),* ]
    };
}

macro_rules! plain {
    ($value:expr) => {
        $crate::parsers::ValuePiece::Plain(&$value[..])
    };
}

macro_rules! reference {
    ($value:expr) => {
        $crate::parsers::ValuePiece::Reference(&$value[..])
    };
}

macro_rules! id {
    ($s:expr) => {
        Identifier(&$s[..])
    };
}