nom-kconfig 0.8.0

A Kconfig parser
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use crate::attribute::{parse_expression, ExpressionToken, FunctionCall, Parameter};
use crate::{
    assert_parsing_eq,
    attribute::{parse_default, AndExpression, Atom, DefaultAttribute, Expression, Term},
    symbol::Symbol,
};

#[test]
fn test_parse_default() {
    assert_parsing_eq!(
        parse_default,
        "default 0x1",
        Ok((
            "",
            DefaultAttribute {
                expression: Expression::Term(AndExpression::Term(Term::Atom(Atom::Symbol(
                    Symbol::Constant("0x1".to_string())
                )))),
                r#if: None
            }
        ))
    )
}

// v3.5.0/arch/microblaze/platform/generic/Kconfig.auto
#[test]
fn test_parse_default_constant_symbol_with_numbers() {
    assert_parsing_eq!(
        parse_default,
        "default 7.10.d",
        Ok((
            "",
            DefaultAttribute {
                expression: Expression::Term(AndExpression::Term(Term::Atom(Atom::Symbol(
                    Symbol::NonConstant("7.10.d".to_string())
                )))),
                r#if: None
            }
        ))
    )
}

// 5.0 /scripts/gcc-plugins/Kconfig
#[test]
fn test_parse_default_ambigus() {
    assert_parsing_eq!(
        parse_default,
        r#"default "$(shell,$(srctree)/scripts/gcc-plugin.sh "$(preferred-plugin-hostcc)" "$(HOSTCXX)" "$(CC)")" if CC_IS_GCC"#,
        Ok((
            "",
            DefaultAttribute {
                expression: Expression::Term(AndExpression::Term(Term::Atom(Atom::Function(
                    FunctionCall {
                        name: "shell".to_string(),
                        parameters: vec!(Parameter {
                            tokens: vec!(
                                ExpressionToken::Function(Box::new(FunctionCall {
                                    name: "srctree".to_string(),
                                    parameters: vec![]
                                })),
                                ExpressionToken::Literal("/scripts/gcc-plugin.sh".to_string()),
                                ExpressionToken::Space,
                                ExpressionToken::DoubleQuotes(vec![ExpressionToken::Function(
                                    Box::new(FunctionCall {
                                        name: "preferred-plugin-hostcc".to_string(),
                                        parameters: vec![]
                                    })
                                ),]),
                                ExpressionToken::Space,
                                ExpressionToken::DoubleQuotes(vec![ExpressionToken::Variable(
                                    "HOSTCXX".to_string()
                                )]),
                                ExpressionToken::Space,
                                ExpressionToken::DoubleQuotes(vec![ExpressionToken::Variable(
                                    "CC".to_string()
                                )])
                            )
                        })
                    }
                )))),
                r#if: Some(Expression::Term(AndExpression::Term(Term::Atom(
                    Atom::Symbol(Symbol::NonConstant("CC_IS_GCC".to_string()))
                ))))
            }
        ))
    )
}

#[test]
fn test_default_attribute_to_string() {
    assert_eq!(
        DefaultAttribute {
            expression: Expression::Term(AndExpression::Term(Term::Atom(Atom::Number(64)))),
            r#if: None
        }
        .to_string(),
        "64"
    );

    assert_eq!(
        DefaultAttribute {
            expression: Expression::Term(AndExpression::Term(Term::Atom(Atom::Number(64)))),
            r#if: Some(Expression::Term(AndExpression::Term(Term::Atom(
                Atom::Symbol(Symbol::Constant("NET".to_string()))
            ))))
        }
        .to_string(),
        "64 if NET"
    )
}

#[test]
/// https://github.com/torvalds/linux/blob/master/init/Kconfig#L22-L25
fn test_default_attribute_number() {
    assert_parsing_eq!(
        parse_default,
        "default 0",
        Ok((
            "",
            DefaultAttribute {
                expression: Expression::Term(AndExpression::Term(Term::Atom(Atom::Number(0)))),
                r#if: None
            }
        ))
    )
}

#[test]
/// https://github.com/torvalds/linux/blob/master/init/Kconfig#L22-L25
fn test_default_attribute_number_2() {
    assert_parsing_eq!(
        parse_default,
        "default \"845\"",
        Ok((
            "",
            DefaultAttribute {
                expression: Expression::Term(AndExpression::Term(Term::Atom(Atom::Number(845)))),
                r#if: None
            }
        ))
    )
}

#[test]
fn test_default_attribute_number_3() {
    assert_parsing_eq!(
        parse_expression,
        "'console=ttyS0,19200'",
        Ok((
            "",
            Expression::Term(AndExpression::Term(Term::Atom(Atom::String(
                "console=ttyS0,19200".to_string()
            ))))
        ))
    )
}