sv_parser_parser/behavioral_statements/
procedural_blocks_and_assignments.rs

1use crate::*;
2
3// -----------------------------------------------------------------------------
4
5#[tracable_parser]
6#[packrat_parser]
7pub(crate) fn initial_construct(s: Span) -> IResult<Span, InitialConstruct> {
8    let (s, a) = keyword("initial")(s)?;
9    let (s, b) = statement_or_null(s)?;
10    Ok((s, InitialConstruct { nodes: (a, b) }))
11}
12
13#[tracable_parser]
14#[packrat_parser]
15pub(crate) fn always_construct(s: Span) -> IResult<Span, AlwaysConstruct> {
16    let (s, a) = always_keyword(s)?;
17    let (s, b) = statement(s)?;
18    Ok((s, AlwaysConstruct { nodes: (a, b) }))
19}
20
21#[tracable_parser]
22#[packrat_parser]
23pub(crate) fn always_keyword(s: Span) -> IResult<Span, AlwaysKeyword> {
24    alt((
25        map(keyword("always_comb"), |x| {
26            AlwaysKeyword::AlwaysComb(Box::new(x))
27        }),
28        map(keyword("always_latch"), |x| {
29            AlwaysKeyword::AlwaysLatch(Box::new(x))
30        }),
31        map(keyword("always_ff"), |x| {
32            AlwaysKeyword::AlwaysFf(Box::new(x))
33        }),
34        map(keyword("always"), |x| AlwaysKeyword::Always(Box::new(x))),
35    ))(s)
36}
37
38#[tracable_parser]
39#[packrat_parser]
40pub(crate) fn final_construct(s: Span) -> IResult<Span, FinalConstruct> {
41    let (s, a) = keyword("final")(s)?;
42    let (s, b) = function_statement(s)?;
43    Ok((s, FinalConstruct { nodes: (a, b) }))
44}
45
46#[tracable_parser]
47#[packrat_parser]
48pub(crate) fn blocking_assignment(s: Span) -> IResult<Span, BlockingAssignment> {
49    alt((
50        blocking_assignment_variable,
51        blocking_assignment_nonrange_variable,
52        blocking_assignment_hierarchical_variable,
53        map(operator_assignment, |x| {
54            BlockingAssignment::OperatorAssignment(Box::new(x))
55        }),
56    ))(s)
57}
58
59#[recursive_parser]
60#[tracable_parser]
61#[packrat_parser]
62pub(crate) fn blocking_assignment_variable(s: Span) -> IResult<Span, BlockingAssignment> {
63    let (s, a) = variable_lvalue(s)?;
64    let (s, b) = symbol("=")(s)?;
65    let (s, c) = delay_or_event_control(s)?;
66    let (s, d) = expression(s)?;
67    Ok((
68        s,
69        BlockingAssignment::Variable(Box::new(BlockingAssignmentVariable {
70            nodes: (a, b, c, d),
71        })),
72    ))
73}
74
75#[recursive_parser]
76#[tracable_parser]
77#[packrat_parser]
78pub(crate) fn blocking_assignment_nonrange_variable(s: Span) -> IResult<Span, BlockingAssignment> {
79    let (s, a) = nonrange_variable_lvalue(s)?;
80    let (s, b) = symbol("=")(s)?;
81    let (s, c) = dynamic_array_new(s)?;
82    Ok((
83        s,
84        BlockingAssignment::NonrangeVariable(Box::new(BlockingAssignmentNonrangeVariable {
85            nodes: (a, b, c),
86        })),
87    ))
88}
89
90#[tracable_parser]
91#[packrat_parser]
92pub(crate) fn blocking_assignment_hierarchical_variable(
93    s: Span,
94) -> IResult<Span, BlockingAssignment> {
95    let (s, a) = opt(implicit_class_handle_or_class_scope_or_package_scope)(s)?;
96    let (s, b) = hierarchical_variable_identifier(s)?;
97    let (s, c) = select(s)?;
98    let (s, d) = symbol("=")(s)?;
99    let (s, e) = class_new(s)?;
100    Ok((
101        s,
102        BlockingAssignment::HierarchicalVariable(Box::new(
103            BlockingAssignmentHierarchicalVariable {
104                nodes: (a, b, c, d, e),
105            },
106        )),
107    ))
108}
109
110#[recursive_parser]
111#[tracable_parser]
112#[packrat_parser]
113pub(crate) fn operator_assignment(s: Span) -> IResult<Span, OperatorAssignment> {
114    let (s, a) = variable_lvalue(s)?;
115    let (s, b) = assignment_operator(s)?;
116    let (s, c) = expression(s)?;
117    Ok((s, OperatorAssignment { nodes: (a, b, c) }))
118}
119
120#[tracable_parser]
121#[packrat_parser]
122pub(crate) fn assignment_operator(s: Span) -> IResult<Span, AssignmentOperator> {
123    alt((
124        map(symbol("="), |x| AssignmentOperator { nodes: (x,) }),
125        map(symbol("+="), |x| AssignmentOperator { nodes: (x,) }),
126        map(symbol("-="), |x| AssignmentOperator { nodes: (x,) }),
127        map(symbol("*="), |x| AssignmentOperator { nodes: (x,) }),
128        map(symbol("/="), |x| AssignmentOperator { nodes: (x,) }),
129        map(symbol("%="), |x| AssignmentOperator { nodes: (x,) }),
130        map(symbol("&="), |x| AssignmentOperator { nodes: (x,) }),
131        map(symbol("|="), |x| AssignmentOperator { nodes: (x,) }),
132        map(symbol("^="), |x| AssignmentOperator { nodes: (x,) }),
133        map(symbol("<<<="), |x| AssignmentOperator { nodes: (x,) }),
134        map(symbol(">>>="), |x| AssignmentOperator { nodes: (x,) }),
135        map(symbol("<<="), |x| AssignmentOperator { nodes: (x,) }),
136        map(symbol(">>="), |x| AssignmentOperator { nodes: (x,) }),
137    ))(s)
138}
139
140#[recursive_parser]
141#[tracable_parser]
142#[packrat_parser]
143pub(crate) fn nonblocking_assignment(s: Span) -> IResult<Span, NonblockingAssignment> {
144    let (s, a) = variable_lvalue(s)?;
145    let (s, b) = symbol("<=")(s)?;
146    let (s, c) = opt(delay_or_event_control)(s)?;
147    let (s, d) = expression(s)?;
148    Ok((
149        s,
150        NonblockingAssignment {
151            nodes: (a, b, c, d),
152        },
153    ))
154}
155
156#[tracable_parser]
157#[packrat_parser]
158pub(crate) fn procedural_continuous_assignment(
159    s: Span,
160) -> IResult<Span, ProceduralContinuousAssignment> {
161    alt((
162        procedural_continuous_assignment_assign,
163        procedural_continuous_assignment_deassign,
164        procedural_continuous_assignment_force_variable,
165        procedural_continuous_assignment_force_net,
166        procedural_continuous_assignment_release_variable,
167        procedural_continuous_assignment_release_net,
168    ))(s)
169}
170
171#[tracable_parser]
172#[packrat_parser]
173pub(crate) fn procedural_continuous_assignment_assign(
174    s: Span,
175) -> IResult<Span, ProceduralContinuousAssignment> {
176    let (s, a) = keyword("assign")(s)?;
177    let (s, b) = variable_assignment(s)?;
178    Ok((
179        s,
180        ProceduralContinuousAssignment::Assign(Box::new(ProceduralContinuousAssignmentAssign {
181            nodes: (a, b),
182        })),
183    ))
184}
185
186#[tracable_parser]
187#[packrat_parser]
188pub(crate) fn procedural_continuous_assignment_deassign(
189    s: Span,
190) -> IResult<Span, ProceduralContinuousAssignment> {
191    let (s, a) = keyword("deassign")(s)?;
192    let (s, b) = variable_lvalue(s)?;
193    Ok((
194        s,
195        ProceduralContinuousAssignment::Deassign(Box::new(
196            ProceduralContinuousAssignmentDeassign { nodes: (a, b) },
197        )),
198    ))
199}
200
201#[tracable_parser]
202#[packrat_parser]
203pub(crate) fn procedural_continuous_assignment_force_variable(
204    s: Span,
205) -> IResult<Span, ProceduralContinuousAssignment> {
206    let (s, a) = keyword("force")(s)?;
207    let (s, b) = variable_assignment(s)?;
208    Ok((
209        s,
210        ProceduralContinuousAssignment::ForceVariable(Box::new(
211            ProceduralContinuousAssignmentForceVariable { nodes: (a, b) },
212        )),
213    ))
214}
215
216#[tracable_parser]
217#[packrat_parser]
218pub(crate) fn procedural_continuous_assignment_force_net(
219    s: Span,
220) -> IResult<Span, ProceduralContinuousAssignment> {
221    let (s, a) = keyword("force")(s)?;
222    let (s, b) = net_assignment(s)?;
223    Ok((
224        s,
225        ProceduralContinuousAssignment::ForceNet(Box::new(
226            ProceduralContinuousAssignmentForceNet { nodes: (a, b) },
227        )),
228    ))
229}
230
231#[tracable_parser]
232#[packrat_parser]
233pub(crate) fn procedural_continuous_assignment_release_variable(
234    s: Span,
235) -> IResult<Span, ProceduralContinuousAssignment> {
236    let (s, a) = keyword("release")(s)?;
237    let (s, b) = variable_lvalue(s)?;
238    Ok((
239        s,
240        ProceduralContinuousAssignment::ReleaseVariable(Box::new(
241            ProceduralContinuousAssignmentReleaseVariable { nodes: (a, b) },
242        )),
243    ))
244}
245
246#[tracable_parser]
247#[packrat_parser]
248pub(crate) fn procedural_continuous_assignment_release_net(
249    s: Span,
250) -> IResult<Span, ProceduralContinuousAssignment> {
251    let (s, a) = keyword("release")(s)?;
252    let (s, b) = net_lvalue(s)?;
253    Ok((
254        s,
255        ProceduralContinuousAssignment::ReleaseNet(Box::new(
256            ProceduralContinuousAssignmentReleaseNet { nodes: (a, b) },
257        )),
258    ))
259}
260
261#[recursive_parser]
262#[tracable_parser]
263#[packrat_parser]
264pub(crate) fn variable_assignment(s: Span) -> IResult<Span, VariableAssignment> {
265    let (s, a) = variable_lvalue(s)?;
266    let (s, b) = symbol("=")(s)?;
267    let (s, c) = expression(s)?;
268    Ok((s, VariableAssignment { nodes: (a, b, c) }))
269}
sv_parser_parser/behavioral_statements/procedural_blocks_and_assignments.rs

sv_parser_parser/behavioral_statements/
procedural_blocks_and_assignments.rs
