sv_parser_parser/behavioral_statements/
case_statements.rs

1use crate::*;
2
3// -----------------------------------------------------------------------------
4
5#[tracable_parser]
6#[packrat_parser]
7pub(crate) fn case_statement(s: Span) -> IResult<Span, CaseStatement> {
8    alt((
9        case_statement_normal,
10        case_statement_matches,
11        case_statement_inside,
12    ))(s)
13}
14
15#[tracable_parser]
16#[packrat_parser]
17pub(crate) fn case_statement_normal(s: Span) -> IResult<Span, CaseStatement> {
18    let (s, a) = opt(unique_priority)(s)?;
19    let (s, b) = case_keyword(s)?;
20    let (s, c) = paren(case_expression)(s)?;
21    let (s, d) = case_item(s)?;
22    let (s, (e, f)) = many_till(case_item, keyword("endcase"))(s)?;
23    Ok((
24        s,
25        CaseStatement::Normal(Box::new(CaseStatementNormal {
26            nodes: (a, b, c, d, e, f),
27        })),
28    ))
29}
30
31#[tracable_parser]
32#[packrat_parser]
33pub(crate) fn case_statement_matches(s: Span) -> IResult<Span, CaseStatement> {
34    let (s, a) = opt(unique_priority)(s)?;
35    let (s, b) = case_keyword(s)?;
36    let (s, c) = paren(case_expression)(s)?;
37    let (s, d) = keyword("matches")(s)?;
38    let (s, e) = case_pattern_item(s)?;
39    let (s, (f, g)) = many_till(case_pattern_item, keyword("endcase"))(s)?;
40    Ok((
41        s,
42        CaseStatement::Matches(Box::new(CaseStatementMatches {
43            nodes: (a, b, c, d, e, f, g),
44        })),
45    ))
46}
47
48#[tracable_parser]
49#[packrat_parser]
50pub(crate) fn case_statement_inside(s: Span) -> IResult<Span, CaseStatement> {
51    let (s, a) = opt(unique_priority)(s)?;
52    let (s, b) = keyword("case")(s)?;
53    let (s, c) = paren(case_expression)(s)?;
54    let (s, d) = keyword("inside")(s)?;
55    let (s, e) = case_inside_item(s)?;
56    let (s, (f, g)) = many_till(case_inside_item, keyword("endcase"))(s)?;
57    Ok((
58        s,
59        CaseStatement::Inside(Box::new(CaseStatementInside {
60            nodes: (a, b, c, d, e, f, g),
61        })),
62    ))
63}
64
65#[tracable_parser]
66#[packrat_parser]
67pub(crate) fn case_keyword(s: Span) -> IResult<Span, CaseKeyword> {
68    alt((
69        map(keyword("casez"), |x| CaseKeyword::Casez(Box::new(x))),
70        map(keyword("casex"), |x| CaseKeyword::Casex(Box::new(x))),
71        map(keyword("case"), |x| CaseKeyword::Case(Box::new(x))),
72    ))(s)
73}
74
75#[tracable_parser]
76#[packrat_parser]
77pub(crate) fn case_expression(s: Span) -> IResult<Span, CaseExpression> {
78    let (s, a) = expression(s)?;
79    Ok((s, CaseExpression { nodes: (a,) }))
80}
81
82#[tracable_parser]
83#[packrat_parser]
84pub(crate) fn case_item(s: Span) -> IResult<Span, CaseItem> {
85    alt((
86        case_item_nondefault,
87        map(case_item_default, |x| CaseItem::Default(Box::new(x))),
88    ))(s)
89}
90
91#[recursive_parser]
92#[tracable_parser]
93#[packrat_parser]
94pub(crate) fn case_item_nondefault(s: Span) -> IResult<Span, CaseItem> {
95    let (s, a) = list(symbol(","), case_item_expression)(s)?;
96    let (s, b) = symbol(":")(s)?;
97    let (s, c) = statement_or_null(s)?;
98    Ok((
99        s,
100        CaseItem::NonDefault(Box::new(CaseItemNondefault { nodes: (a, b, c) })),
101    ))
102}
103
104#[tracable_parser]
105#[packrat_parser]
106pub(crate) fn case_item_default(s: Span) -> IResult<Span, CaseItemDefault> {
107    let (s, a) = keyword("default")(s)?;
108    let (s, b) = opt(symbol(":"))(s)?;
109    let (s, c) = statement_or_null(s)?;
110    Ok((s, CaseItemDefault { nodes: (a, b, c) }))
111}
112
113#[tracable_parser]
114#[packrat_parser]
115pub(crate) fn case_pattern_item(s: Span) -> IResult<Span, CasePatternItem> {
116    alt((
117        case_pattern_item_nondefault,
118        map(case_item_default, |x| CasePatternItem::Default(Box::new(x))),
119    ))(s)
120}
121
122#[recursive_parser]
123#[tracable_parser]
124#[packrat_parser]
125pub(crate) fn case_pattern_item_nondefault(s: Span) -> IResult<Span, CasePatternItem> {
126    let (s, a) = pattern(s)?;
127    let (s, b) = opt(pair(symbol("&&&"), expression))(s)?;
128    let (s, c) = symbol(":")(s)?;
129    let (s, d) = statement_or_null(s)?;
130    Ok((
131        s,
132        CasePatternItem::NonDefault(Box::new(CasePatternItemNondefault {
133            nodes: (a, b, c, d),
134        })),
135    ))
136}
137
138#[tracable_parser]
139#[packrat_parser]
140pub(crate) fn case_inside_item(s: Span) -> IResult<Span, CaseInsideItem> {
141    alt((
142        case_inside_item_nondefault,
143        map(case_item_default, |x| CaseInsideItem::Default(Box::new(x))),
144    ))(s)
145}
146
147#[recursive_parser]
148#[tracable_parser]
149#[packrat_parser]
150pub(crate) fn case_inside_item_nondefault(s: Span) -> IResult<Span, CaseInsideItem> {
151    let (s, a) = open_range_list(s)?;
152    let (s, b) = symbol(":")(s)?;
153    let (s, c) = statement_or_null(s)?;
154    Ok((
155        s,
156        CaseInsideItem::NonDefault(Box::new(CaseInsideItemNondefault { nodes: (a, b, c) })),
157    ))
158}
159
160#[tracable_parser]
161#[packrat_parser]
162pub(crate) fn case_item_expression(s: Span) -> IResult<Span, CaseItemExpression> {
163    let (s, a) = expression(s)?;
164    Ok((s, CaseItemExpression { nodes: (a,) }))
165}
166
167#[tracable_parser]
168#[packrat_parser]
169pub(crate) fn randcase_statement(s: Span) -> IResult<Span, RandcaseStatement> {
170    let (s, a) = keyword("randcase")(s)?;
171    let (s, b) = randcase_item(s)?;
172    let (s, (c, d)) = many_till(randcase_item, keyword("endcase"))(s)?;
173    Ok((
174        s,
175        RandcaseStatement {
176            nodes: (a, b, c, d),
177        },
178    ))
179}
180
181#[recursive_parser]
182#[tracable_parser]
183#[packrat_parser]
184pub(crate) fn randcase_item(s: Span) -> IResult<Span, RandcaseItem> {
185    let (s, a) = expression(s)?;
186    let (s, b) = symbol(":")(s)?;
187    let (s, c) = statement_or_null(s)?;
188    Ok((s, RandcaseItem { nodes: (a, b, c) }))
189}
190
191#[recursive_parser]
192#[tracable_parser]
193#[packrat_parser]
194pub(crate) fn open_range_list(s: Span) -> IResult<Span, OpenRangeList> {
195    let (s, a) = list(symbol(","), open_value_range)(s)?;
196    Ok((s, OpenRangeList { nodes: (a,) }))
197}
198
199#[tracable_parser]
200#[packrat_parser]
201pub(crate) fn open_value_range(s: Span) -> IResult<Span, OpenValueRange> {
202    let (s, a) = value_range(s)?;
203    Ok((s, OpenValueRange { nodes: (a,) }))
204}
sv_parser_parser/behavioral_statements/case_statements.rs

sv_parser_parser/behavioral_statements/
case_statements.rs
