sv_parser_parser/behavioral_statements/
patterns.rs

1use nom::Parser;
2
3use crate::*;
4
5// -----------------------------------------------------------------------------
6
7#[tracable_parser]
8#[packrat_parser]
9pub(crate) fn pattern(s: Span) -> IResult<Span, Pattern> {
10    alt((
11        pattern_variable,
12        map(symbol(".*"), |x| Pattern::Asterisk(Box::new(x))),
13        map(constant_expression, |x| {
14            Pattern::ConstantExpression(Box::new(x))
15        }),
16        pattern_tagged,
17        pattern_list,
18        pattern_identifier_list,
19        paren(pattern).map(|p| p.nodes.1),
20    ))(s)
21}
22
23#[tracable_parser]
24#[packrat_parser]
25pub(crate) fn pattern_variable(s: Span) -> IResult<Span, Pattern> {
26    let (s, a) = symbol(".")(s)?;
27    let (s, b) = variable_identifier(s)?;
28    Ok((
29        s,
30        Pattern::Variable(Box::new(PatternVariable { nodes: (a, b) })),
31    ))
32}
33
34#[tracable_parser]
35#[packrat_parser]
36pub(crate) fn pattern_tagged(s: Span) -> IResult<Span, Pattern> {
37    let (s, a) = keyword("tagged")(s)?;
38    let (s, b) = member_identifier(s)?;
39    let (s, c) = opt(pattern)(s)?;
40    Ok((
41        s,
42        Pattern::Tagged(Box::new(PatternTagged { nodes: (a, b, c) })),
43    ))
44}
45
46#[tracable_parser]
47#[packrat_parser]
48pub(crate) fn pattern_list(s: Span) -> IResult<Span, Pattern> {
49    let (s, a) = apostrophe_brace(list(symbol(","), pattern))(s)?;
50    Ok((s, Pattern::List(Box::new(PatternList { nodes: (a,) }))))
51}
52
53#[tracable_parser]
54#[packrat_parser]
55pub(crate) fn pattern_identifier_list(s: Span) -> IResult<Span, Pattern> {
56    let (s, a) = apostrophe_brace(list(
57        symbol(","),
58        triple(member_identifier, symbol(":"), pattern),
59    ))(s)?;
60    Ok((
61        s,
62        Pattern::IdentifierList(Box::new(PatternIdentifierList { nodes: (a,) })),
63    ))
64}
65
66#[tracable_parser]
67#[packrat_parser]
68pub(crate) fn assignment_pattern(s: Span) -> IResult<Span, AssignmentPattern> {
69    alt((
70        assignment_pattern_list,
71        assignment_pattern_structure,
72        assignment_pattern_array,
73        assignment_pattern_repeat,
74    ))(s)
75}
76
77#[tracable_parser]
78#[packrat_parser]
79pub(crate) fn assignment_pattern_list(s: Span) -> IResult<Span, AssignmentPattern> {
80    let (s, a) = apostrophe_brace(list(symbol(","), expression))(s)?;
81    Ok((
82        s,
83        AssignmentPattern::List(Box::new(AssignmentPatternList { nodes: (a,) })),
84    ))
85}
86
87#[tracable_parser]
88#[packrat_parser]
89pub(crate) fn assignment_pattern_structure(s: Span) -> IResult<Span, AssignmentPattern> {
90    let (s, a) = apostrophe_brace(list(
91        symbol(","),
92        triple(structure_pattern_key, symbol(":"), expression),
93    ))(s)?;
94    Ok((
95        s,
96        AssignmentPattern::Structure(Box::new(AssignmentPatternStructure { nodes: (a,) })),
97    ))
98}
99
100#[tracable_parser]
101#[packrat_parser]
102pub(crate) fn assignment_pattern_array(s: Span) -> IResult<Span, AssignmentPattern> {
103    let (s, a) = apostrophe_brace(list(
104        symbol(","),
105        triple(array_pattern_key, symbol(":"), expression),
106    ))(s)?;
107    Ok((
108        s,
109        AssignmentPattern::Array(Box::new(AssignmentPatternArray { nodes: (a,) })),
110    ))
111}
112
113#[tracable_parser]
114#[packrat_parser]
115pub(crate) fn assignment_pattern_repeat(s: Span) -> IResult<Span, AssignmentPattern> {
116    let (s, a) = apostrophe_brace(pair(
117        constant_expression,
118        brace(list(symbol(","), expression)),
119    ))(s)?;
120    Ok((
121        s,
122        AssignmentPattern::Repeat(Box::new(AssignmentPatternRepeat { nodes: (a,) })),
123    ))
124}
125
126#[tracable_parser]
127#[packrat_parser]
128pub(crate) fn structure_pattern_key(s: Span) -> IResult<Span, StructurePatternKey> {
129    alt((
130        map(member_identifier, |x| {
131            StructurePatternKey::MemberIdentifier(Box::new(x))
132        }),
133        map(assignment_pattern_key, |x| {
134            StructurePatternKey::AssignmentPatternKey(Box::new(x))
135        }),
136    ))(s)
137}
138
139#[tracable_parser]
140#[packrat_parser]
141pub(crate) fn array_pattern_key(s: Span) -> IResult<Span, ArrayPatternKey> {
142    alt((
143        map(constant_expression, |x| {
144            ArrayPatternKey::ConstantExpression(Box::new(x))
145        }),
146        map(assignment_pattern_key, |x| {
147            ArrayPatternKey::AssignmentPatternKey(Box::new(x))
148        }),
149    ))(s)
150}
151
152#[tracable_parser]
153#[packrat_parser]
154pub(crate) fn assignment_pattern_key(s: Span) -> IResult<Span, AssignmentPatternKey> {
155    alt((
156        map(simple_type, |x| {
157            AssignmentPatternKey::SimpleType(Box::new(x))
158        }),
159        map(keyword("default"), |x| {
160            AssignmentPatternKey::Default(Box::new(x))
161        }),
162    ))(s)
163}
164
165#[tracable_parser]
166#[packrat_parser]
167pub(crate) fn assignment_pattern_expression(s: Span) -> IResult<Span, AssignmentPatternExpression> {
168    let (s, a) = opt(assignment_pattern_expression_type)(s)?;
169    let (s, b) = assignment_pattern(s)?;
170    Ok((s, AssignmentPatternExpression { nodes: (a, b) }))
171}
172
173#[tracable_parser]
174#[packrat_parser]
175pub(crate) fn assignment_pattern_expression_type(
176    s: Span,
177) -> IResult<Span, AssignmentPatternExpressionType> {
178    alt((
179        map(ps_type_identifier, |x| {
180            AssignmentPatternExpressionType::PsTypeIdentifier(Box::new(x))
181        }),
182        map(ps_parameter_identifier, |x| {
183            AssignmentPatternExpressionType::PsParameterIdentifier(Box::new(x))
184        }),
185        map(integer_atom_type, |x| {
186            AssignmentPatternExpressionType::IntegerAtomType(Box::new(x))
187        }),
188        map(type_reference, |x| {
189            AssignmentPatternExpressionType::TypeReference(Box::new(x))
190        }),
191    ))(s)
192}
193
194#[tracable_parser]
195#[packrat_parser]
196pub(crate) fn constant_assignment_pattern_expression(
197    s: Span,
198) -> IResult<Span, ConstantAssignmentPatternExpression> {
199    let (s, a) = assignment_pattern_expression(s)?;
200    Ok((s, ConstantAssignmentPatternExpression { nodes: (a,) }))
201}
202
203#[tracable_parser]
204#[packrat_parser]
205pub(crate) fn assignment_pattern_net_lvalue(s: Span) -> IResult<Span, AssignmentPatternNetLvalue> {
206    let (s, a) = apostrophe_brace(list(symbol(","), net_lvalue))(s)?;
207    Ok((s, AssignmentPatternNetLvalue { nodes: (a,) }))
208}
209
210#[tracable_parser]
211#[packrat_parser]
212pub(crate) fn assignment_pattern_variable_lvalue(
213    s: Span,
214) -> IResult<Span, AssignmentPatternVariableLvalue> {
215    let (s, a) = apostrophe_brace(list(symbol(","), variable_lvalue))(s)?;
216    Ok((s, AssignmentPatternVariableLvalue { nodes: (a,) }))
217}
sv_parser_parser/behavioral_statements/patterns.rs

sv_parser_parser/behavioral_statements/
patterns.rs
