sv_parser_parser/source_text/
constraints.rs

1use crate::*;
2
3// -----------------------------------------------------------------------------
4
5#[tracable_parser]
6#[packrat_parser]
7pub(crate) fn constraint_declaration(s: Span) -> IResult<Span, ConstraintDeclaration> {
8    let (s, a) = opt(r#static)(s)?;
9    let (s, b) = keyword("constraint")(s)?;
10    let (s, c) = constraint_identifier(s)?;
11    let (s, d) = constraint_block(s)?;
12    Ok((
13        s,
14        ConstraintDeclaration {
15            nodes: (a, b, c, d),
16        },
17    ))
18}
19
20#[tracable_parser]
21#[packrat_parser]
22pub(crate) fn r#static(s: Span) -> IResult<Span, Static> {
23    let (s, a) = keyword("static")(s)?;
24    Ok((s, Static { nodes: (a,) }))
25}
26
27#[tracable_parser]
28#[packrat_parser]
29pub(crate) fn constraint_block(s: Span) -> IResult<Span, ConstraintBlock> {
30    let (s, a) = brace(many0(constraint_block_item))(s)?;
31    Ok((s, ConstraintBlock { nodes: (a,) }))
32}
33
34#[tracable_parser]
35#[packrat_parser]
36pub(crate) fn constraint_block_item(s: Span) -> IResult<Span, ConstraintBlockItem> {
37    alt((
38        constraint_block_item_solve,
39        map(constraint_expression, |x| {
40            ConstraintBlockItem::ConstraintExpression(Box::new(x))
41        }),
42    ))(s)
43}
44
45#[tracable_parser]
46#[packrat_parser]
47pub(crate) fn constraint_block_item_solve(s: Span) -> IResult<Span, ConstraintBlockItem> {
48    let (s, a) = keyword("solve")(s)?;
49    let (s, b) = solve_before_list(s)?;
50    let (s, c) = keyword("before")(s)?;
51    let (s, d) = solve_before_list(s)?;
52    let (s, e) = symbol(";")(s)?;
53    Ok((
54        s,
55        ConstraintBlockItem::Solve(Box::new(ConstraintBlockItemSolve {
56            nodes: (a, b, c, d, e),
57        })),
58    ))
59}
60
61#[tracable_parser]
62#[packrat_parser]
63pub(crate) fn solve_before_list(s: Span) -> IResult<Span, SolveBeforeList> {
64    let (s, a) = list(symbol(","), constraint_primary)(s)?;
65    Ok((s, SolveBeforeList { nodes: (a,) }))
66}
67
68#[tracable_parser]
69#[packrat_parser]
70pub(crate) fn constraint_primary(s: Span) -> IResult<Span, ConstraintPrimary> {
71    let (s, a) = opt(implicit_class_handle_or_class_scope)(s)?;
72    let (s, b) = hierarchical_identifier(s)?;
73    let (s, c) = select(s)?;
74    Ok((s, ConstraintPrimary { nodes: (a, b, c) }))
75}
76
77#[tracable_parser]
78#[packrat_parser]
79pub(crate) fn constraint_expression(s: Span) -> IResult<Span, ConstraintExpression> {
80    alt((
81        constraint_expression_expression,
82        map(pair(uniqueness_constraint, symbol(";")), |x| {
83            ConstraintExpression::UniquenessConstraint(Box::new(x))
84        }),
85        constraint_expression_arrow,
86        constraint_expression_if,
87        constraint_expression_foreach,
88        constraint_expression_disable,
89    ))(s)
90}
91
92#[recursive_parser]
93#[tracable_parser]
94#[packrat_parser]
95pub(crate) fn constraint_expression_expression(s: Span) -> IResult<Span, ConstraintExpression> {
96    let (s, a) = opt(soft)(s)?;
97    let (s, b) = expression_or_dist(s)?;
98    let (s, c) = symbol(";")(s)?;
99    Ok((
100        s,
101        ConstraintExpression::Expression(Box::new(ConstraintExpressionExpression {
102            nodes: (a, b, c),
103        })),
104    ))
105}
106
107#[tracable_parser]
108#[packrat_parser]
109pub(crate) fn soft(s: Span) -> IResult<Span, Soft> {
110    let (s, a) = keyword("soft")(s)?;
111    Ok((s, Soft { nodes: (a,) }))
112}
113
114#[recursive_parser]
115#[tracable_parser]
116#[packrat_parser]
117pub(crate) fn constraint_expression_arrow(s: Span) -> IResult<Span, ConstraintExpression> {
118    let (s, a) = expression(s)?;
119    let (s, b) = symbol("->")(s)?;
120    let (s, c) = constraint_set(s)?;
121    Ok((
122        s,
123        ConstraintExpression::Arrow(Box::new(ConstraintExpressionArrow { nodes: (a, b, c) })),
124    ))
125}
126
127#[tracable_parser]
128#[packrat_parser]
129pub(crate) fn constraint_expression_if(s: Span) -> IResult<Span, ConstraintExpression> {
130    let (s, a) = keyword("if")(s)?;
131    let (s, b) = paren(expression)(s)?;
132    let (s, c) = constraint_set(s)?;
133    let (s, d) = opt(pair(keyword("else"), constraint_set))(s)?;
134    Ok((
135        s,
136        ConstraintExpression::If(Box::new(ConstraintExpressionIf {
137            nodes: (a, b, c, d),
138        })),
139    ))
140}
141
142#[tracable_parser]
143#[packrat_parser]
144pub(crate) fn constraint_expression_foreach(s: Span) -> IResult<Span, ConstraintExpression> {
145    let (s, a) = keyword("foreach")(s)?;
146    let (s, b) = paren(pair(
147        ps_or_hierarchical_array_identifier,
148        bracket(loop_variables),
149    ))(s)?;
150    let (s, c) = constraint_set(s)?;
151    Ok((
152        s,
153        ConstraintExpression::Foreach(Box::new(ConstraintExpressionForeach { nodes: (a, b, c) })),
154    ))
155}
156
157#[tracable_parser]
158#[packrat_parser]
159pub(crate) fn constraint_expression_disable(s: Span) -> IResult<Span, ConstraintExpression> {
160    let (s, a) = keyword("disable")(s)?;
161    let (s, b) = keyword("soft")(s)?;
162    let (s, c) = constraint_primary(s)?;
163    let (s, d) = symbol(";")(s)?;
164    Ok((
165        s,
166        ConstraintExpression::Disable(Box::new(ConstraintExpressionDisable {
167            nodes: (a, b, c, d),
168        })),
169    ))
170}
171
172#[tracable_parser]
173#[packrat_parser]
174pub(crate) fn uniqueness_constraint(s: Span) -> IResult<Span, UniquenessConstraint> {
175    let (s, a) = keyword("unique")(s)?;
176    let (s, b) = brace(open_range_list)(s)?;
177    Ok((s, UniquenessConstraint { nodes: (a, b) }))
178}
179
180#[tracable_parser]
181#[packrat_parser]
182pub(crate) fn constraint_set(s: Span) -> IResult<Span, ConstraintSet> {
183    alt((
184        map(constraint_expression, |x| {
185            ConstraintSet::ConstraintExpression(Box::new(x))
186        }),
187        constraint_set_brace,
188    ))(s)
189}
190
191#[tracable_parser]
192#[packrat_parser]
193pub(crate) fn constraint_set_brace(s: Span) -> IResult<Span, ConstraintSet> {
194    let (s, a) = brace(many0(constraint_expression))(s)?;
195    Ok((
196        s,
197        ConstraintSet::Brace(Box::new(ConstraintSetBrace { nodes: (a,) })),
198    ))
199}
200
201#[recursive_parser]
202#[tracable_parser]
203#[packrat_parser]
204pub(crate) fn dist_list(s: Span) -> IResult<Span, DistList> {
205    let (s, a) = list(symbol(","), dist_item)(s)?;
206    Ok((s, DistList { nodes: (a,) }))
207}
208
209#[recursive_parser]
210#[tracable_parser]
211#[packrat_parser]
212pub(crate) fn dist_item(s: Span) -> IResult<Span, DistItem> {
213    let (s, a) = value_range(s)?;
214    let (s, b) = opt(dist_weight)(s)?;
215    Ok((s, DistItem { nodes: (a, b) }))
216}
217
218#[tracable_parser]
219#[packrat_parser]
220pub(crate) fn dist_weight(s: Span) -> IResult<Span, DistWeight> {
221    alt((dist_weight_equal, dist_weight_divide))(s)
222}
223
224#[tracable_parser]
225#[packrat_parser]
226pub(crate) fn dist_weight_equal(s: Span) -> IResult<Span, DistWeight> {
227    let (s, a) = symbol(":=")(s)?;
228    let (s, b) = expression(s)?;
229    Ok((
230        s,
231        DistWeight::Equal(Box::new(DistWeightEqual { nodes: (a, b) })),
232    ))
233}
234
235#[tracable_parser]
236#[packrat_parser]
237pub(crate) fn dist_weight_divide(s: Span) -> IResult<Span, DistWeight> {
238    let (s, a) = symbol(":/")(s)?;
239    let (s, b) = expression(s)?;
240    Ok((
241        s,
242        DistWeight::Divide(Box::new(DistWeightDivide { nodes: (a, b) })),
243    ))
244}
245
246#[tracable_parser]
247#[packrat_parser]
248pub(crate) fn constraint_prototype(s: Span) -> IResult<Span, ConstraintPrototype> {
249    let (s, a) = opt(constraint_prototype_qualifier)(s)?;
250    let (s, b) = opt(r#static)(s)?;
251    let (s, c) = keyword("constraint")(s)?;
252    let (s, d) = constraint_identifier(s)?;
253    let (s, e) = symbol(";")(s)?;
254    Ok((
255        s,
256        ConstraintPrototype {
257            nodes: (a, b, c, d, e),
258        },
259    ))
260}
261
262#[tracable_parser]
263#[packrat_parser]
264pub(crate) fn constraint_prototype_qualifier(
265    s: Span,
266) -> IResult<Span, ConstraintPrototypeQualifier> {
267    alt((
268        map(keyword("extern"), |x| {
269            ConstraintPrototypeQualifier::Extern(Box::new(x))
270        }),
271        map(keyword("pure"), |x| {
272            ConstraintPrototypeQualifier::Pure(Box::new(x))
273        }),
274    ))(s)
275}
276
277#[tracable_parser]
278#[packrat_parser]
279pub(crate) fn extern_constraint_declaration(s: Span) -> IResult<Span, ExternConstraintDeclaration> {
280    let (s, a) = opt(r#static)(s)?;
281    let (s, b) = keyword("constraint")(s)?;
282    let (s, c) = class_scope(s)?;
283    let (s, d) = constraint_identifier(s)?;
284    let (s, e) = constraint_block(s)?;
285    Ok((
286        s,
287        ExternConstraintDeclaration {
288            nodes: (a, b, c, d, e),
289        },
290    ))
291}
292
293#[tracable_parser]
294#[packrat_parser]
295pub(crate) fn identifier_list(s: Span) -> IResult<Span, IdentifierList> {
296    let (s, a) = list(symbol(","), identifier)(s)?;
297    Ok((s, IdentifierList { nodes: (a,) }))
298}
sv_parser_parser/source_text/constraints.rs

sv_parser_parser/source_text/
constraints.rs
