sv_parser_parser/behavioral_statements/
assertion_statements.rs

1use crate::*;
2
3// -----------------------------------------------------------------------------
4
5#[tracable_parser]
6#[packrat_parser]
7pub(crate) fn assertion_item(s: Span) -> IResult<Span, AssertionItem> {
8    alt((
9        map(concurrent_assertion_item, |x| {
10            AssertionItem::Concurrent(Box::new(x))
11        }),
12        map(deferred_immediate_assertion_item, |x| {
13            AssertionItem::Immediate(Box::new(x))
14        }),
15    ))(s)
16}
17
18#[tracable_parser]
19#[packrat_parser]
20pub(crate) fn deferred_immediate_assertion_item(
21    s: Span,
22) -> IResult<Span, DeferredImmediateAssertionItem> {
23    let (s, a) = opt(pair(block_identifier, symbol(":")))(s)?;
24    let (s, b) = deferred_immediate_assertion_statement(s)?;
25    Ok((s, DeferredImmediateAssertionItem { nodes: (a, b) }))
26}
27
28#[tracable_parser]
29#[packrat_parser]
30pub(crate) fn procedural_assertion_statement(
31    s: Span,
32) -> IResult<Span, ProceduralAssertionStatement> {
33    alt((
34        map(concurrent_assertion_statement, |x| {
35            ProceduralAssertionStatement::Concurrent(Box::new(x))
36        }),
37        map(immediate_assertion_statement, |x| {
38            ProceduralAssertionStatement::Immediate(Box::new(x))
39        }),
40        map(checker_instantiation, |x| {
41            ProceduralAssertionStatement::Checker(Box::new(x))
42        }),
43    ))(s)
44}
45
46#[tracable_parser]
47#[packrat_parser]
48pub(crate) fn immediate_assertion_statement(s: Span) -> IResult<Span, ImmediateAssertionStatement> {
49    alt((
50        map(simple_immediate_assertion_statement, |x| {
51            ImmediateAssertionStatement::Simple(Box::new(x))
52        }),
53        map(deferred_immediate_assertion_statement, |x| {
54            ImmediateAssertionStatement::Deferred(Box::new(x))
55        }),
56    ))(s)
57}
58
59#[tracable_parser]
60#[packrat_parser]
61pub(crate) fn simple_immediate_assertion_statement(
62    s: Span,
63) -> IResult<Span, SimpleImmediateAssertionStatement> {
64    alt((
65        map(simple_immediate_assert_statement, |x| {
66            SimpleImmediateAssertionStatement::Assert(Box::new(x))
67        }),
68        map(simple_immediate_assume_statement, |x| {
69            SimpleImmediateAssertionStatement::Assume(Box::new(x))
70        }),
71        map(simple_immediate_cover_statement, |x| {
72            SimpleImmediateAssertionStatement::Cover(Box::new(x))
73        }),
74    ))(s)
75}
76
77#[tracable_parser]
78#[packrat_parser]
79pub(crate) fn simple_immediate_assert_statement(
80    s: Span,
81) -> IResult<Span, SimpleImmediateAssertStatement> {
82    let (s, a) = keyword("assert")(s)?;
83    let (s, b) = paren(expression)(s)?;
84    let (s, c) = action_block(s)?;
85    Ok((s, SimpleImmediateAssertStatement { nodes: (a, b, c) }))
86}
87
88#[tracable_parser]
89#[packrat_parser]
90pub(crate) fn simple_immediate_assume_statement(
91    s: Span,
92) -> IResult<Span, SimpleImmediateAssumeStatement> {
93    let (s, a) = keyword("assume")(s)?;
94    let (s, b) = paren(expression)(s)?;
95    let (s, c) = action_block(s)?;
96    Ok((s, SimpleImmediateAssumeStatement { nodes: (a, b, c) }))
97}
98
99#[tracable_parser]
100#[packrat_parser]
101pub(crate) fn simple_immediate_cover_statement(
102    s: Span,
103) -> IResult<Span, SimpleImmediateCoverStatement> {
104    let (s, a) = keyword("cover")(s)?;
105    let (s, b) = paren(expression)(s)?;
106    let (s, c) = statement_or_null(s)?;
107    Ok((s, SimpleImmediateCoverStatement { nodes: (a, b, c) }))
108}
109
110#[tracable_parser]
111#[packrat_parser]
112pub(crate) fn deferred_immediate_assertion_statement(
113    s: Span,
114) -> IResult<Span, DeferredImmediateAssertionStatement> {
115    alt((
116        map(deferred_immediate_assert_statement, |x| {
117            DeferredImmediateAssertionStatement::Assert(Box::new(x))
118        }),
119        map(deferred_immediate_assume_statement, |x| {
120            DeferredImmediateAssertionStatement::Assume(Box::new(x))
121        }),
122        map(deferred_immediate_cover_statement, |x| {
123            DeferredImmediateAssertionStatement::Cover(Box::new(x))
124        }),
125    ))(s)
126}
127
128#[tracable_parser]
129#[packrat_parser]
130pub(crate) fn deferred_immediate_assert_statement(
131    s: Span,
132) -> IResult<Span, DeferredImmediateAssertStatement> {
133    let (s, a) = keyword("assert")(s)?;
134    let (s, b) = assert_timing(s)?;
135    let (s, c) = paren(expression)(s)?;
136    let (s, d) = action_block(s)?;
137    Ok((
138        s,
139        DeferredImmediateAssertStatement {
140            nodes: (a, b, c, d),
141        },
142    ))
143}
144
145#[tracable_parser]
146#[packrat_parser]
147pub(crate) fn deferred_immediate_assume_statement(
148    s: Span,
149) -> IResult<Span, DeferredImmediateAssumeStatement> {
150    let (s, a) = keyword("assume")(s)?;
151    let (s, b) = assert_timing(s)?;
152    let (s, c) = paren(expression)(s)?;
153    let (s, d) = action_block(s)?;
154    Ok((
155        s,
156        DeferredImmediateAssumeStatement {
157            nodes: (a, b, c, d),
158        },
159    ))
160}
161
162#[tracable_parser]
163#[packrat_parser]
164pub(crate) fn deferred_immediate_cover_statement(
165    s: Span,
166) -> IResult<Span, DeferredImmediateCoverStatement> {
167    let (s, a) = keyword("cover")(s)?;
168    let (s, b) = assert_timing(s)?;
169    let (s, c) = paren(expression)(s)?;
170    let (s, d) = statement_or_null(s)?;
171    Ok((
172        s,
173        DeferredImmediateCoverStatement {
174            nodes: (a, b, c, d),
175        },
176    ))
177}
178
179#[tracable_parser]
180#[packrat_parser]
181pub(crate) fn assert_timing(s: Span) -> IResult<Span, AssertTiming> {
182    alt((
183        map(symbol("#0"), |x| AssertTiming::Zero(Box::new(x))),
184        map(keyword("final"), |x| AssertTiming::Final(Box::new(x))),
185    ))(s)
186}
sv_parser_parser/behavioral_statements/assertion_statements.rs

sv_parser_parser/behavioral_statements/
assertion_statements.rs
