sv_parser_parser/declarations/
declaration_assignments.rs

1use crate::*;
2
3// -----------------------------------------------------------------------------
4
5#[tracable_parser]
6#[packrat_parser]
7pub(crate) fn defparam_assignment(s: Span) -> IResult<Span, DefparamAssignment> {
8    let (s, a) = hierarchical_parameter_identifier(s)?;
9    let (s, b) = symbol("=")(s)?;
10    let (s, c) = constant_mintypmax_expression(s)?;
11    Ok((s, DefparamAssignment { nodes: (a, b, c) }))
12}
13
14#[tracable_parser]
15#[packrat_parser]
16pub(crate) fn net_decl_assignment(s: Span) -> IResult<Span, NetDeclAssignment> {
17    let (s, a) = net_identifier(s)?;
18    let (s, b) = many0(unpacked_dimension)(s)?;
19    let (s, c) = opt(pair(symbol("="), expression))(s)?;
20    Ok((s, NetDeclAssignment { nodes: (a, b, c) }))
21}
22
23#[tracable_parser]
24#[packrat_parser]
25pub(crate) fn param_assignment(s: Span) -> IResult<Span, ParamAssignment> {
26    let (s, a) = parameter_identifier(s)?;
27    let (s, b) = many0(unpacked_dimension)(s)?;
28    let (s, c) = opt(pair(symbol("="), constant_param_expression))(s)?;
29    Ok((s, ParamAssignment { nodes: (a, b, c) }))
30}
31
32#[tracable_parser]
33#[packrat_parser]
34pub(crate) fn specparam_assignment(s: Span) -> IResult<Span, SpecparamAssignment> {
35    alt((
36        specparam_assignment_mintypmax,
37        map(pulse_control_specparam, |x| {
38            SpecparamAssignment::PulseControlSpecparam(Box::new(x))
39        }),
40    ))(s)
41}
42
43#[tracable_parser]
44#[packrat_parser]
45pub(crate) fn specparam_assignment_mintypmax(s: Span) -> IResult<Span, SpecparamAssignment> {
46    let (s, a) = specparam_identifier(s)?;
47    let (s, b) = symbol("=")(s)?;
48    let (s, c) = constant_mintypmax_expression(s)?;
49    Ok((
50        s,
51        SpecparamAssignment::Mintypmax(Box::new(SpecparamAssignmentMintypmax { nodes: (a, b, c) })),
52    ))
53}
54
55#[tracable_parser]
56#[packrat_parser]
57pub(crate) fn type_assignment(s: Span) -> IResult<Span, TypeAssignment> {
58    let (s, a) = type_identifier(s)?;
59    let (s, b) = opt(pair(symbol("="), data_type))(s)?;
60    Ok((s, TypeAssignment { nodes: (a, b) }))
61}
62
63#[tracable_parser]
64#[packrat_parser]
65pub(crate) fn pulse_control_specparam(s: Span) -> IResult<Span, PulseControlSpecparam> {
66    alt((
67        pulse_control_specparam_without_descriptor,
68        pulse_control_specparam_with_descriptor,
69    ))(s)
70}
71
72#[tracable_parser]
73#[packrat_parser]
74pub(crate) fn pulse_control_specparam_without_descriptor(
75    s: Span,
76) -> IResult<Span, PulseControlSpecparam> {
77    let (s, a) = symbol("PATHPULSE$")(s)?;
78    let (s, b) = symbol("=")(s)?;
79    let (s, c) = paren(pair(
80        reject_limit_value,
81        opt(pair(symbol(","), error_limit_value)),
82    ))(s)?;
83    Ok((
84        s,
85        PulseControlSpecparam::WithoutDescriptor(Box::new(
86            PulseControlSpecparamWithoutDescriptor { nodes: (a, b, c) },
87        )),
88    ))
89}
90
91#[tracable_parser]
92#[packrat_parser]
93pub(crate) fn pulse_control_specparam_with_descriptor(
94    s: Span,
95) -> IResult<Span, PulseControlSpecparam> {
96    let (s, a) = symbol("PATHPULSE$")(s)?;
97    let (s, b) = specify_input_terminal_descriptor(s)?;
98    let (s, c) = symbol("$")(s)?;
99    let (s, d) = specify_output_terminal_descriptor(s)?;
100    let (s, e) = symbol("=")(s)?;
101    let (s, f) = paren(pair(
102        reject_limit_value,
103        opt(pair(symbol(","), error_limit_value)),
104    ))(s)?;
105    Ok((
106        s,
107        PulseControlSpecparam::WithDescriptor(Box::new(PulseControlSpecparamWithDescriptor {
108            nodes: (a, b, c, d, e, f),
109        })),
110    ))
111}
112
113#[tracable_parser]
114#[packrat_parser]
115pub(crate) fn error_limit_value(s: Span) -> IResult<Span, ErrorLimitValue> {
116    let (s, a) = limit_value(s)?;
117    Ok((s, ErrorLimitValue { nodes: (a,) }))
118}
119
120#[tracable_parser]
121#[packrat_parser]
122pub(crate) fn reject_limit_value(s: Span) -> IResult<Span, RejectLimitValue> {
123    let (s, a) = limit_value(s)?;
124    Ok((s, RejectLimitValue { nodes: (a,) }))
125}
126
127#[tracable_parser]
128#[packrat_parser]
129pub(crate) fn limit_value(s: Span) -> IResult<Span, LimitValue> {
130    let (s, a) = constant_mintypmax_expression(s)?;
131    Ok((s, LimitValue { nodes: (a,) }))
132}
133
134#[tracable_parser]
135#[packrat_parser]
136pub(crate) fn variable_decl_assignment(s: Span) -> IResult<Span, VariableDeclAssignment> {
137    alt((
138        variable_decl_assignment_dynamic_array,
139        variable_decl_assignment_class,
140        variable_decl_assignment_variable,
141    ))(s)
142}
143
144#[tracable_parser]
145#[packrat_parser]
146pub(crate) fn variable_decl_assignment_variable(s: Span) -> IResult<Span, VariableDeclAssignment> {
147    let (s, a) = variable_identifier(s)?;
148    let (s, b) = many0(variable_dimension)(s)?;
149    let (s, c) = opt(pair(symbol("="), expression))(s)?;
150    let (s, _) = not(peek(symbol("=")))(s)?;
151    Ok((
152        s,
153        VariableDeclAssignment::Variable(Box::new(VariableDeclAssignmentVariable {
154            nodes: (a, b, c),
155        })),
156    ))
157}
158
159#[tracable_parser]
160#[packrat_parser]
161pub(crate) fn variable_decl_assignment_dynamic_array(
162    s: Span,
163) -> IResult<Span, VariableDeclAssignment> {
164    let (s, a) = dynamic_array_variable_identifier(s)?;
165    let (s, b) = unsized_dimension(s)?;
166    let (s, c) = many0(variable_dimension)(s)?;
167    let (s, d) = opt(pair(symbol("="), dynamic_array_new))(s)?;
168    let (s, _) = not(peek(symbol("=")))(s)?;
169    Ok((
170        s,
171        VariableDeclAssignment::DynamicArray(Box::new(VariableDeclAssignmentDynamicArray {
172            nodes: (a, b, c, d),
173        })),
174    ))
175}
176
177#[tracable_parser]
178#[packrat_parser]
179pub(crate) fn variable_decl_assignment_class(s: Span) -> IResult<Span, VariableDeclAssignment> {
180    let (s, a) = class_variable_identifier(s)?;
181    let (s, b) = pair(symbol("="), class_new)(s)?;
182    Ok((
183        s,
184        VariableDeclAssignment::Class(Box::new(VariableDeclAssignmentClass { nodes: (a, b) })),
185    ))
186}
187
188#[tracable_parser]
189#[packrat_parser]
190pub(crate) fn class_new(s: Span) -> IResult<Span, ClassNew> {
191    alt((class_new_expression, class_new_argument))(s)
192}
193
194#[tracable_parser]
195#[packrat_parser]
196pub(crate) fn class_new_argument(s: Span) -> IResult<Span, ClassNew> {
197    let (s, a) = opt(class_scope)(s)?;
198    let (s, b) = keyword("new")(s)?;
199    let (s, c) = opt(paren(list_of_arguments))(s)?;
200    Ok((
201        s,
202        ClassNew::Argument(Box::new(ClassNewArgument { nodes: (a, b, c) })),
203    ))
204}
205
206#[tracable_parser]
207#[packrat_parser]
208pub(crate) fn class_new_expression(s: Span) -> IResult<Span, ClassNew> {
209    let (s, a) = keyword("new")(s)?;
210    let (s, b) = expression(s)?;
211    Ok((
212        s,
213        ClassNew::Expression(Box::new(ClassNewExpression { nodes: (a, b) })),
214    ))
215}
216
217#[tracable_parser]
218#[packrat_parser]
219pub(crate) fn dynamic_array_new(s: Span) -> IResult<Span, DynamicArrayNew> {
220    let (s, a) = keyword("new")(s)?;
221    let (s, b) = bracket(expression)(s)?;
222    let (s, c) = opt(paren(expression))(s)?;
223    Ok((s, DynamicArrayNew { nodes: (a, b, c) }))
224}
sv_parser_parser/declarations/declaration_assignments.rs

sv_parser_parser/declarations/
declaration_assignments.rs
