sv_parser_parser/behavioral_statements/
patterns.rs

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

sv_parser_parser/behavioral_statements/
patterns.rs
