sv_parser_parser/behavioral_statements/
timing_control_statements.rs

1use crate::*;
2
3// -----------------------------------------------------------------------------
4
5#[tracable_parser]
6#[packrat_parser]
7pub(crate) fn procedural_timing_control_statement(
8    s: Span,
9) -> IResult<Span, ProceduralTimingControlStatement> {
10    let (s, a) = procedural_timing_control(s)?;
11    let (s, b) = statement_or_null(s)?;
12    Ok((s, ProceduralTimingControlStatement { nodes: (a, b) }))
13}
14
15#[tracable_parser]
16#[packrat_parser]
17pub(crate) fn delay_or_event_control(s: Span) -> IResult<Span, DelayOrEventControl> {
18    alt((
19        map(delay_control, |x| DelayOrEventControl::Delay(Box::new(x))),
20        map(event_control, |x| DelayOrEventControl::Event(Box::new(x))),
21        delay_or_event_control_repeat,
22    ))(s)
23}
24
25#[tracable_parser]
26#[packrat_parser]
27pub(crate) fn delay_or_event_control_repeat(s: Span) -> IResult<Span, DelayOrEventControl> {
28    let (s, a) = keyword("repeat")(s)?;
29    let (s, b) = paren(expression)(s)?;
30    let (s, c) = event_control(s)?;
31    Ok((
32        s,
33        DelayOrEventControl::Repeat(Box::new(DelayOrEventControlRepeat { nodes: (a, b, c) })),
34    ))
35}
36
37#[tracable_parser]
38#[packrat_parser]
39pub(crate) fn delay_control(s: Span) -> IResult<Span, DelayControl> {
40    alt((delay_control_delay, delay_control_mintypmax))(s)
41}
42
43#[tracable_parser]
44#[packrat_parser]
45pub(crate) fn delay_control_delay(s: Span) -> IResult<Span, DelayControl> {
46    let (s, a) = symbol("#")(s)?;
47    let (s, b) = delay_value(s)?;
48    Ok((
49        s,
50        DelayControl::Delay(Box::new(DelayControlDelay { nodes: (a, b) })),
51    ))
52}
53
54#[tracable_parser]
55#[packrat_parser]
56pub(crate) fn delay_control_mintypmax(s: Span) -> IResult<Span, DelayControl> {
57    let (s, a) = symbol("#")(s)?;
58    let (s, b) = paren(mintypmax_expression)(s)?;
59    Ok((
60        s,
61        DelayControl::Mintypmax(Box::new(DelayControlMintypmax { nodes: (a, b) })),
62    ))
63}
64
65#[tracable_parser]
66#[packrat_parser]
67pub(crate) fn event_control(s: Span) -> IResult<Span, EventControl> {
68    alt((
69        event_control_event_identifier,
70        event_control_event_expression,
71        event_control_asterisk,
72        event_control_paren_asterisk,
73        event_control_sequence_identifier,
74    ))(s)
75}
76
77#[tracable_parser]
78#[packrat_parser]
79pub(crate) fn event_control_event_identifier(s: Span) -> IResult<Span, EventControl> {
80    let (s, a) = symbol("@")(s)?;
81    let (s, b) = hierarchical_event_identifier(s)?;
82    Ok((
83        s,
84        EventControl::EventIdentifier(Box::new(EventControlEventIdentifier { nodes: (a, b) })),
85    ))
86}
87
88#[tracable_parser]
89#[packrat_parser]
90pub(crate) fn event_control_event_expression(s: Span) -> IResult<Span, EventControl> {
91    let (s, a) = symbol("@")(s)?;
92    let (s, b) = paren(event_expression)(s)?;
93    Ok((
94        s,
95        EventControl::EventExpression(Box::new(EventControlEventExpression { nodes: (a, b) })),
96    ))
97}
98
99#[tracable_parser]
100#[packrat_parser]
101pub(crate) fn event_control_asterisk(s: Span) -> IResult<Span, EventControl> {
102    let (s, a) = symbol("@*")(s)?;
103    Ok((
104        s,
105        EventControl::Asterisk(Box::new(EventControlAsterisk { nodes: (a,) })),
106    ))
107}
108
109#[tracable_parser]
110#[packrat_parser]
111pub(crate) fn event_control_paren_asterisk(s: Span) -> IResult<Span, EventControl> {
112    let (s, a) = symbol("@")(s)?;
113    let (s, b) = paren(symbol("*"))(s)?;
114    Ok((
115        s,
116        EventControl::ParenAsterisk(Box::new(EventControlParenAsterisk { nodes: (a, b) })),
117    ))
118}
119
120#[tracable_parser]
121#[packrat_parser]
122pub(crate) fn event_control_sequence_identifier(s: Span) -> IResult<Span, EventControl> {
123    let (s, a) = symbol("@")(s)?;
124    let (s, b) = ps_or_hierarchical_sequence_identifier(s)?;
125    Ok((
126        s,
127        EventControl::SequenceIdentifier(Box::new(EventControlSequenceIdentifier {
128            nodes: (a, b),
129        })),
130    ))
131}
132
133#[tracable_parser]
134#[packrat_parser]
135pub(crate) fn event_expression(s: Span) -> IResult<Span, EventExpression> {
136    alt((
137        event_expression_or,
138        event_expression_comma,
139        event_expression_expression,
140        event_expression_sequence,
141        event_expression_paren,
142    ))(s)
143}
144
145#[recursive_parser]
146#[tracable_parser]
147#[packrat_parser]
148pub(crate) fn event_expression_expression(s: Span) -> IResult<Span, EventExpression> {
149    let (s, a) = opt(edge_identifier)(s)?;
150    let (s, b) = expression(s)?;
151    let (s, c) = opt(pair(keyword("iff"), expression))(s)?;
152    Ok((
153        s,
154        EventExpression::Expression(Box::new(EventExpressionExpression { nodes: (a, b, c) })),
155    ))
156}
157
158#[tracable_parser]
159#[packrat_parser]
160pub(crate) fn event_expression_sequence(s: Span) -> IResult<Span, EventExpression> {
161    let (s, a) = sequence_instance(s)?;
162    let (s, b) = opt(pair(keyword("iff"), expression))(s)?;
163    Ok((
164        s,
165        EventExpression::Sequence(Box::new(EventExpressionSequence { nodes: (a, b) })),
166    ))
167}
168
169#[recursive_parser]
170#[tracable_parser]
171#[packrat_parser]
172pub(crate) fn event_expression_or(s: Span) -> IResult<Span, EventExpression> {
173    let (s, a) = event_expression(s)?;
174    let (s, b) = keyword("or")(s)?;
175    let (s, c) = event_expression(s)?;
176    Ok((
177        s,
178        EventExpression::Or(Box::new(EventExpressionOr { nodes: (a, b, c) })),
179    ))
180}
181
182#[recursive_parser]
183#[tracable_parser]
184#[packrat_parser]
185pub(crate) fn event_expression_comma(s: Span) -> IResult<Span, EventExpression> {
186    let (s, a) = event_expression(s)?;
187    let (s, b) = symbol(",")(s)?;
188    let (s, c) = event_expression(s)?;
189    Ok((
190        s,
191        EventExpression::Comma(Box::new(EventExpressionComma { nodes: (a, b, c) })),
192    ))
193}
194
195#[tracable_parser]
196#[packrat_parser]
197pub(crate) fn event_expression_paren(s: Span) -> IResult<Span, EventExpression> {
198    let (s, a) = paren(event_expression)(s)?;
199    Ok((
200        s,
201        EventExpression::Paren(Box::new(EventExpressionParen { nodes: (a,) })),
202    ))
203}
204
205#[tracable_parser]
206#[packrat_parser]
207pub(crate) fn procedural_timing_control(s: Span) -> IResult<Span, ProceduralTimingControl> {
208    alt((
209        map(delay_control, |x| {
210            ProceduralTimingControl::DelayControl(Box::new(x))
211        }),
212        map(event_control, |x| {
213            ProceduralTimingControl::EventControl(Box::new(x))
214        }),
215        map(cycle_delay, |x| {
216            ProceduralTimingControl::CycleDelay(Box::new(x))
217        }),
218    ))(s)
219}
220
221#[tracable_parser]
222#[packrat_parser]
223pub(crate) fn jump_statement(s: Span) -> IResult<Span, JumpStatement> {
224    alt((
225        jump_statement_return,
226        jump_statement_break,
227        jump_statement_continue,
228    ))(s)
229}
230
231#[tracable_parser]
232#[packrat_parser]
233pub(crate) fn jump_statement_return(s: Span) -> IResult<Span, JumpStatement> {
234    let (s, a) = keyword("return")(s)?;
235    let (s, b) = opt(expression)(s)?;
236    let (s, c) = symbol(";")(s)?;
237    Ok((
238        s,
239        JumpStatement::Return(Box::new(JumpStatementReturn { nodes: (a, b, c) })),
240    ))
241}
242
243#[tracable_parser]
244#[packrat_parser]
245pub(crate) fn jump_statement_break(s: Span) -> IResult<Span, JumpStatement> {
246    let (s, a) = keyword("break")(s)?;
247    let (s, b) = symbol(";")(s)?;
248    Ok((
249        s,
250        JumpStatement::Break(Box::new(JumpStatementBreak { nodes: (a, b) })),
251    ))
252}
253
254#[tracable_parser]
255#[packrat_parser]
256pub(crate) fn jump_statement_continue(s: Span) -> IResult<Span, JumpStatement> {
257    let (s, a) = keyword("continue")(s)?;
258    let (s, b) = symbol(";")(s)?;
259    Ok((
260        s,
261        JumpStatement::Continue(Box::new(JumpStatementContinue { nodes: (a, b) })),
262    ))
263}
264
265#[tracable_parser]
266#[packrat_parser]
267pub(crate) fn wait_statement(s: Span) -> IResult<Span, WaitStatement> {
268    alt((
269        wait_statement_wait,
270        wait_statement_fork,
271        wait_statement_order,
272    ))(s)
273}
274
275#[tracable_parser]
276#[packrat_parser]
277pub(crate) fn wait_statement_wait(s: Span) -> IResult<Span, WaitStatement> {
278    let (s, a) = keyword("wait")(s)?;
279    let (s, b) = paren(expression)(s)?;
280    let (s, c) = statement_or_null(s)?;
281    Ok((
282        s,
283        WaitStatement::Wait(Box::new(WaitStatementWait { nodes: (a, b, c) })),
284    ))
285}
286
287#[tracable_parser]
288#[packrat_parser]
289pub(crate) fn wait_statement_fork(s: Span) -> IResult<Span, WaitStatement> {
290    let (s, a) = keyword("wait")(s)?;
291    let (s, b) = keyword("fork")(s)?;
292    let (s, c) = symbol(";")(s)?;
293    Ok((
294        s,
295        WaitStatement::Fork(Box::new(WaitStatementFork { nodes: (a, b, c) })),
296    ))
297}
298
299#[tracable_parser]
300#[packrat_parser]
301pub(crate) fn wait_statement_order(s: Span) -> IResult<Span, WaitStatement> {
302    let (s, a) = keyword("wait_order")(s)?;
303    let (s, b) = paren(list(symbol(","), hierarchical_identifier))(s)?;
304    let (s, c) = action_block(s)?;
305    Ok((
306        s,
307        WaitStatement::Order(Box::new(WaitStatementOrder { nodes: (a, b, c) })),
308    ))
309}
310
311#[tracable_parser]
312#[packrat_parser]
313pub(crate) fn event_trigger(s: Span) -> IResult<Span, EventTrigger> {
314    alt((event_trigger_named, event_trigger_nonblocking))(s)
315}
316
317#[tracable_parser]
318#[packrat_parser]
319pub(crate) fn event_trigger_named(s: Span) -> IResult<Span, EventTrigger> {
320    let (s, a) = symbol("->")(s)?;
321    let (s, b) = hierarchical_event_identifier(s)?;
322    let (s, c) = symbol(";")(s)?;
323    Ok((
324        s,
325        EventTrigger::Named(Box::new(EventTriggerNamed { nodes: (a, b, c) })),
326    ))
327}
328
329#[tracable_parser]
330#[packrat_parser]
331pub(crate) fn event_trigger_nonblocking(s: Span) -> IResult<Span, EventTrigger> {
332    let (s, a) = symbol("->>")(s)?;
333    let (s, b) = opt(delay_or_event_control)(s)?;
334    let (s, c) = hierarchical_event_identifier(s)?;
335    let (s, d) = symbol(";")(s)?;
336    Ok((
337        s,
338        EventTrigger::Nonblocking(Box::new(EventTriggerNonblocking {
339            nodes: (a, b, c, d),
340        })),
341    ))
342}
343
344#[tracable_parser]
345#[packrat_parser]
346pub(crate) fn disable_statement(s: Span) -> IResult<Span, DisableStatement> {
347    alt((
348        disable_statement_task,
349        disable_statement_block,
350        disable_statement_fork,
351    ))(s)
352}
353
354#[tracable_parser]
355#[packrat_parser]
356pub(crate) fn disable_statement_task(s: Span) -> IResult<Span, DisableStatement> {
357    let (s, a) = keyword("disable")(s)?;
358    let (s, b) = hierarchical_task_identifier(s)?;
359    let (s, c) = symbol(";")(s)?;
360    Ok((
361        s,
362        DisableStatement::Task(Box::new(DisableStatementTask { nodes: (a, b, c) })),
363    ))
364}
365
366#[tracable_parser]
367#[packrat_parser]
368pub(crate) fn disable_statement_block(s: Span) -> IResult<Span, DisableStatement> {
369    let (s, a) = keyword("disable")(s)?;
370    let (s, b) = hierarchical_block_identifier(s)?;
371    let (s, c) = symbol(";")(s)?;
372    Ok((
373        s,
374        DisableStatement::Block(Box::new(DisableStatementBlock { nodes: (a, b, c) })),
375    ))
376}
377
378#[tracable_parser]
379#[packrat_parser]
380pub(crate) fn disable_statement_fork(s: Span) -> IResult<Span, DisableStatement> {
381    let (s, a) = keyword("disable")(s)?;
382    let (s, b) = keyword("fork")(s)?;
383    let (s, c) = symbol(";")(s)?;
384    Ok((
385        s,
386        DisableStatement::Fork(Box::new(DisableStatementFork { nodes: (a, b, c) })),
387    ))
388}
sv_parser_parser/behavioral_statements/timing_control_statements.rs

sv_parser_parser/behavioral_statements/
timing_control_statements.rs
