sv_parser_parser/source_text/
class_items.rs

1use crate::*;
2
3// -----------------------------------------------------------------------------
4
5#[tracable_parser]
6#[packrat_parser]
7pub(crate) fn class_item(s: Span) -> IResult<Span, ClassItem> {
8    alt((
9        class_item_property,
10        class_item_method,
11        class_item_constraint,
12        class_item_declaration,
13        class_item_covergroup,
14        map(pair(local_parameter_declaration, symbol(";")), |x| {
15            ClassItem::LocalParameterDeclaration(Box::new(x))
16        }),
17        map(pair(parameter_declaration, symbol(";")), |x| {
18            ClassItem::ParameterDeclaration(Box::new(x))
19        }),
20        map(symbol(";"), |x| ClassItem::Empty(Box::new(x))),
21    ))(s)
22}
23
24#[tracable_parser]
25#[packrat_parser]
26pub(crate) fn class_item_property(s: Span) -> IResult<Span, ClassItem> {
27    let (s, a) = many0(attribute_instance)(s)?;
28    let (s, b) = class_property(s)?;
29    Ok((
30        s,
31        ClassItem::Property(Box::new(ClassItemProperty { nodes: (a, b) })),
32    ))
33}
34
35#[tracable_parser]
36#[packrat_parser]
37pub(crate) fn class_item_method(s: Span) -> IResult<Span, ClassItem> {
38    let (s, a) = many0(attribute_instance)(s)?;
39    let (s, b) = class_method(s)?;
40    Ok((
41        s,
42        ClassItem::Method(Box::new(ClassItemMethod { nodes: (a, b) })),
43    ))
44}
45
46#[tracable_parser]
47#[packrat_parser]
48pub(crate) fn class_item_constraint(s: Span) -> IResult<Span, ClassItem> {
49    let (s, a) = many0(attribute_instance)(s)?;
50    let (s, b) = class_constraint(s)?;
51    Ok((
52        s,
53        ClassItem::Constraint(Box::new(ClassItemConstraint { nodes: (a, b) })),
54    ))
55}
56
57#[tracable_parser]
58#[packrat_parser]
59pub(crate) fn class_item_declaration(s: Span) -> IResult<Span, ClassItem> {
60    let (s, a) = many0(attribute_instance)(s)?;
61    let (s, b) = class_declaration(s)?;
62    Ok((
63        s,
64        ClassItem::Declaration(Box::new(ClassItemDeclaration { nodes: (a, b) })),
65    ))
66}
67
68#[tracable_parser]
69#[packrat_parser]
70pub(crate) fn class_item_covergroup(s: Span) -> IResult<Span, ClassItem> {
71    let (s, a) = many0(attribute_instance)(s)?;
72    let (s, b) = covergroup_declaration(s)?;
73    Ok((
74        s,
75        ClassItem::Covergroup(Box::new(ClassItemCovergroup { nodes: (a, b) })),
76    ))
77}
78
79#[tracable_parser]
80#[packrat_parser]
81pub(crate) fn class_property(s: Span) -> IResult<Span, ClassProperty> {
82    alt((class_property_non_const, class_property_const))(s)
83}
84
85#[tracable_parser]
86#[packrat_parser]
87pub(crate) fn class_property_non_const(s: Span) -> IResult<Span, ClassProperty> {
88    let (s, a) = many0(property_qualifier)(s)?;
89    let (s, b) = data_declaration(s)?;
90    Ok((
91        s,
92        ClassProperty::NonConst(Box::new(ClassPropertyNonConst { nodes: (a, b) })),
93    ))
94}
95
96#[tracable_parser]
97#[packrat_parser]
98pub(crate) fn class_property_const(s: Span) -> IResult<Span, ClassProperty> {
99    let (s, a) = keyword("const")(s)?;
100    let (s, b) = many0(class_item_qualifier)(s)?;
101    let (s, c) = data_type(s)?;
102    let (s, d) = const_identifier(s)?;
103    // BNF-WA
104    //let (s, e) = opt(pair(symbol("="), constant_expression))(s)?;
105    let (s, e) = opt(pair(symbol("="), class_property_const_expression))(s)?;
106    let (s, f) = symbol(";")(s)?;
107    Ok((
108        s,
109        ClassProperty::Const(Box::new(ClassPropertyConst {
110            nodes: (a, b, c, d, e, f),
111        })),
112    ))
113}
114
115#[tracable_parser]
116#[packrat_parser]
117pub(crate) fn class_property_const_expression(
118    s: Span,
119) -> IResult<Span, ClassPropertyConstExpression> {
120    alt((
121        map(constant_expression, |x| {
122            ClassPropertyConstExpression::ConstantExpression(Box::new(x))
123        }),
124        map(class_new, |x| {
125            ClassPropertyConstExpression::ClassNew(Box::new(x))
126        }),
127    ))(s)
128}
129
130#[tracable_parser]
131#[packrat_parser]
132pub(crate) fn class_method(s: Span) -> IResult<Span, ClassMethod> {
133    alt((
134        class_method_task,
135        class_method_function,
136        class_method_pure_virtual,
137        class_method_extern_method,
138        class_method_constructor,
139        class_method_extern_constructor,
140    ))(s)
141}
142
143#[tracable_parser]
144#[packrat_parser]
145pub(crate) fn class_method_task(s: Span) -> IResult<Span, ClassMethod> {
146    let (s, a) = many0(method_qualifier)(s)?;
147    let (s, b) = task_declaration(s)?;
148    Ok((
149        s,
150        ClassMethod::Task(Box::new(ClassMethodTask { nodes: (a, b) })),
151    ))
152}
153
154#[tracable_parser]
155#[packrat_parser]
156pub(crate) fn class_method_function(s: Span) -> IResult<Span, ClassMethod> {
157    let (s, a) = many0(method_qualifier)(s)?;
158    let (s, b) = function_declaration(s)?;
159    Ok((
160        s,
161        ClassMethod::Function(Box::new(ClassMethodFunction { nodes: (a, b) })),
162    ))
163}
164
165#[tracable_parser]
166#[packrat_parser]
167pub(crate) fn class_method_pure_virtual(s: Span) -> IResult<Span, ClassMethod> {
168    let (s, a) = keyword("pure")(s)?;
169    let (s, b) = keyword("virtual")(s)?;
170    let (s, c) = many0(class_item_qualifier)(s)?;
171    let (s, d) = method_prototype(s)?;
172    let (s, e) = symbol(";")(s)?;
173    Ok((
174        s,
175        ClassMethod::PureVirtual(Box::new(ClassMethodPureVirtual {
176            nodes: (a, b, c, d, e),
177        })),
178    ))
179}
180
181#[tracable_parser]
182#[packrat_parser]
183pub(crate) fn class_method_extern_method(s: Span) -> IResult<Span, ClassMethod> {
184    let (s, a) = keyword("extern")(s)?;
185    let (s, b) = many0(method_qualifier)(s)?;
186    let (s, c) = method_prototype(s)?;
187    let (s, d) = symbol(";")(s)?;
188    Ok((
189        s,
190        ClassMethod::ExternMethod(Box::new(ClassMethodExternMethod {
191            nodes: (a, b, c, d),
192        })),
193    ))
194}
195
196#[tracable_parser]
197#[packrat_parser]
198pub(crate) fn class_method_constructor(s: Span) -> IResult<Span, ClassMethod> {
199    let (s, a) = many0(method_qualifier)(s)?;
200    let (s, b) = class_constructor_declaration(s)?;
201    Ok((
202        s,
203        ClassMethod::Constructor(Box::new(ClassMethodConstructor { nodes: (a, b) })),
204    ))
205}
206
207#[tracable_parser]
208#[packrat_parser]
209pub(crate) fn class_method_extern_constructor(s: Span) -> IResult<Span, ClassMethod> {
210    let (s, a) = keyword("extern")(s)?;
211    let (s, b) = many0(method_qualifier)(s)?;
212    let (s, c) = class_constructor_prototype(s)?;
213    Ok((
214        s,
215        ClassMethod::ExternConstructor(Box::new(ClassMethodExternConstructor { nodes: (a, b, c) })),
216    ))
217}
218
219#[tracable_parser]
220#[packrat_parser]
221pub(crate) fn class_constructor_prototype(s: Span) -> IResult<Span, ClassConstructorPrototype> {
222    let (s, a) = keyword("function")(s)?;
223    let (s, b) = keyword("new")(s)?;
224    let (s, c) = opt(paren(opt(tf_port_list)))(s)?;
225    let (s, d) = symbol(";")(s)?;
226    Ok((
227        s,
228        ClassConstructorPrototype {
229            nodes: (a, b, c, d),
230        },
231    ))
232}
233
234#[tracable_parser]
235#[packrat_parser]
236pub(crate) fn class_constraint(s: Span) -> IResult<Span, ClassConstraint> {
237    alt((
238        map(constraint_prototype, |x| {
239            ClassConstraint::ConstraintPrototype(Box::new(x))
240        }),
241        map(constraint_declaration, |x| {
242            ClassConstraint::ConstraintDeclaration(Box::new(x))
243        }),
244    ))(s)
245}
246
247#[tracable_parser]
248#[packrat_parser]
249pub(crate) fn class_item_qualifier(s: Span) -> IResult<Span, ClassItemQualifier> {
250    alt((
251        map(keyword("static"), |x| {
252            ClassItemQualifier::Static(Box::new(x))
253        }),
254        map(keyword("protected"), |x| {
255            ClassItemQualifier::Protected(Box::new(x))
256        }),
257        map(keyword("local"), |x| ClassItemQualifier::Local(Box::new(x))),
258    ))(s)
259}
260
261#[tracable_parser]
262#[packrat_parser]
263pub(crate) fn property_qualifier(s: Span) -> IResult<Span, PropertyQualifier> {
264    alt((
265        map(random_qualifier, |x| {
266            PropertyQualifier::RandomQualifier(Box::new(x))
267        }),
268        map(class_item_qualifier, |x| {
269            PropertyQualifier::ClassItemQualifier(Box::new(x))
270        }),
271    ))(s)
272}
273
274#[tracable_parser]
275#[packrat_parser]
276pub(crate) fn random_qualifier(s: Span) -> IResult<Span, RandomQualifier> {
277    alt((
278        map(keyword("randc"), |x| RandomQualifier::Randc(Box::new(x))),
279        map(keyword("rand"), |x| RandomQualifier::Rand(Box::new(x))),
280    ))(s)
281}
282
283#[tracable_parser]
284#[packrat_parser]
285pub(crate) fn method_qualifier(s: Span) -> IResult<Span, MethodQualifier> {
286    alt((
287        map(pair(keyword("pure"), keyword("virtual")), |x| {
288            MethodQualifier::PureVirtual(Box::new(x))
289        }),
290        map(keyword("virtual"), |x| {
291            MethodQualifier::Virtual(Box::new(x))
292        }),
293        map(class_item_qualifier, |x| {
294            MethodQualifier::ClassItemQualifier(Box::new(x))
295        }),
296    ))(s)
297}
298
299#[tracable_parser]
300#[packrat_parser]
301pub(crate) fn method_prototype(s: Span) -> IResult<Span, MethodPrototype> {
302    alt((
303        map(task_prototype, |x| {
304            MethodPrototype::TaskPrototype(Box::new(x))
305        }),
306        map(function_prototype, |x| {
307            MethodPrototype::FunctionPrototype(Box::new(x))
308        }),
309    ))(s)
310}
311
312#[tracable_parser]
313#[packrat_parser]
314pub(crate) fn class_constructor_declaration(s: Span) -> IResult<Span, ClassConstructorDeclaration> {
315    let (s, a) = keyword("function")(s)?;
316    let (s, b) = opt(class_scope)(s)?;
317    let (s, c) = keyword("new")(s)?;
318    let (s, d) = opt(paren(opt(tf_port_list)))(s)?;
319    let (s, e) = symbol(";")(s)?;
320    let (s, f) = many0(block_item_declaration)(s)?;
321    let (s, g) = opt(tuple((
322        keyword("super"),
323        symbol("."),
324        keyword("new"),
325        opt(paren(list_of_arguments)),
326        symbol(";"),
327    )))(s)?;
328    let (s, (h, i)) = many_till(function_statement_or_null, keyword("endfunction"))(s)?;
329    let (s, j) = opt(pair(symbol(":"), new))(s)?;
330    Ok((
331        s,
332        ClassConstructorDeclaration {
333            nodes: (a, b, c, d, e, f, g, h, i, j),
334        },
335    ))
336}
337
338#[tracable_parser]
339#[packrat_parser]
340pub(crate) fn new(s: Span) -> IResult<Span, New> {
341    let (s, a) = keyword("new")(s)?;
342    Ok((s, New { nodes: (a,) }))
343}
sv_parser_parser/source_text/class_items.rs

sv_parser_parser/source_text/
class_items.rs
