scarf_syntax/declarations/
covergroup_declarations.rs

1// =======================================================================
2// covergroup_declarations.rs
3// =======================================================================
4// CST Nodes from 1800-2023 A.2.11
5use crate::*;
6
7#[derive(Clone, Debug, PartialEq)]
8pub enum CovergroupDeclaration<'a> {
9    Initial(
10        Box<(
11            Metadata<'a>, // covergroup
12            CovergroupIdentifier<'a>,
13            Option<(
14                Metadata<'a>, // (
15                Option<TfPortList<'a>>,
16                Metadata<'a>, // )
17            )>,
18            Option<CoverageEvent<'a>>,
19            Metadata<'a>, // ;
20            Vec<CoverageSpecOrOption<'a>>,
21            Metadata<'a>, // endgroup
22            Option<(
23                Metadata<'a>, // :
24                CovergroupIdentifier<'a>,
25            )>,
26        )>,
27    ),
28    Extends(
29        Box<(
30            Metadata<'a>, // covergroup
31            Metadata<'a>, // extends
32            CovergroupIdentifier<'a>,
33            Metadata<'a>, // ;
34            Vec<CoverageSpecOrOption<'a>>,
35            Metadata<'a>, // endgroup
36            Option<(
37                Metadata<'a>, // :
38                CovergroupIdentifier<'a>,
39            )>,
40        )>,
41    ),
42}
43
44#[derive(Clone, Debug, PartialEq)]
45pub enum CoverageSpecOrOption<'a> {
46    Spec(Box<(Vec<AttributeInstance<'a>>, CoverageSpec<'a>)>),
47    Option(
48        Box<(
49            Vec<AttributeInstance<'a>>,
50            CoverageOption<'a>,
51            Metadata<'a>, // ;
52        )>,
53    ),
54}
55
56#[derive(Clone, Debug, PartialEq)]
57pub enum CoverageOption<'a> {
58    Option(
59        Box<(
60            Metadata<'a>, // option
61            Metadata<'a>, // .
62            MemberIdentifier<'a>,
63            Metadata<'a>, // =
64            Expression<'a>,
65        )>,
66    ),
67    TypeOption(
68        Box<(
69            Metadata<'a>, // type_option
70            Metadata<'a>, // .
71            MemberIdentifier<'a>,
72            Metadata<'a>, // =
73            ConstantExpression<'a>,
74        )>,
75    ),
76}
77
78#[derive(Clone, Debug, PartialEq)]
79pub enum CoverageSpec<'a> {
80    Point(Box<CoverPoint<'a>>),
81    Cross(Box<CoverCross<'a>>),
82}
83
84#[derive(Clone, Debug, PartialEq)]
85pub enum CoverageEvent<'a> {
86    Clocking(Box<ClockingEvent<'a>>),
87    Function(
88        Box<(
89            Metadata<'a>, // with
90            Metadata<'a>, // function
91            Metadata<'a>, // sample
92            Metadata<'a>, // (
93            Option<TfPortList<'a>>,
94            Metadata<'a>, // )
95        )>,
96    ),
97    Block(
98        Box<(
99            Metadata<'a>, // @@
100            Metadata<'a>, // (
101            BlockEventExpression<'a>,
102            Metadata<'a>, // )
103        )>,
104    ),
105}
106
107#[derive(Clone, Debug, PartialEq)]
108pub enum BlockEventExpression<'a> {
109    Or(
110        Box<(
111            BlockEventExpression<'a>,
112            Metadata<'a>,
113            BlockEventExpression<'a>,
114        )>,
115    ),
116    Begin(
117        Box<(
118            Metadata<'a>, // begin
119            HierarchicalBtfIdentifier<'a>,
120        )>,
121    ),
122    End(
123        Box<(
124            Metadata<'a>, // end
125            HierarchicalBtfIdentifier<'a>,
126        )>,
127    ),
128}
129
130#[derive(Clone, Debug, PartialEq)]
131pub enum HierarchicalIdentifierOrClassScope<'a> {
132    Identifier(
133        Box<(
134            HierarchicalIdentifier<'a>,
135            Metadata<'a>, // .
136        )>,
137    ),
138    Scope(Box<ClassScope<'a>>),
139}
140
141#[derive(Clone, Debug, PartialEq)]
142pub enum HierarchicalBtfIdentifier<'a> {
143    Tf(Box<HierarchicalTfIdentifier<'a>>),
144    Block(Box<HierarchicalBlockIdentifier<'a>>),
145    Method(
146        Box<(
147            Option<HierarchicalIdentifierOrClassScope<'a>>,
148            MethodIdentifier<'a>,
149        )>,
150    ),
151}
152
153#[derive(Clone, Debug, PartialEq)]
154pub struct CoverPoint<'a>(
155    pub  Option<(
156        Option<DataTypeOrImplicit<'a>>,
157        CoverPointIdentifier<'a>,
158        Metadata<'a>, // :
159    )>,
160    pub Metadata<'a>, // coverpoint
161    pub Expression<'a>,
162    pub  Option<(
163        Metadata<'a>, // iff
164        Metadata<'a>, // (
165        Expression<'a>,
166        Metadata<'a>, // )
167    )>,
168    pub BinsOrEmpty<'a>,
169);
170
171#[derive(Clone, Debug, PartialEq)]
172pub enum BinsOrEmpty<'a> {
173    Bins(
174        Box<(
175            Metadata<'a>, // {
176            Vec<AttributeInstance<'a>>,
177            Vec<(
178                BinsOrOptions<'a>,
179                Metadata<'a>, // ;
180            )>,
181            Metadata<'a>, // }
182        )>,
183    ),
184    Empty(Box<Metadata<'a>>),
185}
186
187#[derive(Clone, Debug, PartialEq)]
188pub enum BinsOrOptions<'a> {
189    Coverage(Box<CoverageOption<'a>>),
190    Range(
191        Box<(
192            Option<Metadata<'a>>, // wildcard
193            BinsKeyword<'a>,
194            BinIdentifier<'a>,
195            Option<(
196                Metadata<'a>, // [
197                Option<CovergroupExpression<'a>>,
198                Metadata<'a>, // ]
199            )>,
200            Metadata<'a>, // =
201            Metadata<'a>, // {
202            CovergroupRangeList<'a>,
203            Metadata<'a>, // }
204            Option<(
205                Metadata<'a>, // with
206                Metadata<'a>, // (
207                WithCovergroupExpression<'a>,
208                Metadata<'a>, // )
209            )>,
210            Option<(
211                Metadata<'a>, // iff
212                Metadata<'a>, // (
213                Expression<'a>,
214                Metadata<'a>, // )
215            )>,
216        )>,
217    ),
218    Point(
219        Box<(
220            Option<Metadata<'a>>, // wildcard
221            BinsKeyword<'a>,
222            BinIdentifier<'a>,
223            Option<(
224                Metadata<'a>, // [
225                Option<CovergroupExpression<'a>>,
226                Metadata<'a>, // ]
227            )>,
228            Metadata<'a>, // =
229            CoverPointIdentifier<'a>,
230            Metadata<'a>, // with
231            Metadata<'a>, // (
232            WithCovergroupExpression<'a>,
233            Metadata<'a>, // )
234            Option<(
235                Metadata<'a>, // iff
236                Metadata<'a>, // (
237                Expression<'a>,
238                Metadata<'a>, // )
239            )>,
240        )>,
241    ),
242    Set(
243        Box<(
244            Option<Metadata<'a>>, // wildcard
245            BinsKeyword<'a>,
246            BinIdentifier<'a>,
247            Option<(
248                Metadata<'a>, // [
249                Option<CovergroupExpression<'a>>,
250                Metadata<'a>, // ]
251            )>,
252            Metadata<'a>, // =
253            SetCovergroupExpression<'a>,
254            Option<(
255                Metadata<'a>, // iff
256                Metadata<'a>, // (
257                Expression<'a>,
258                Metadata<'a>, // )
259            )>,
260        )>,
261    ),
262    Trans(
263        Box<(
264            Option<Metadata<'a>>, // wildcard
265            BinsKeyword<'a>,
266            BinIdentifier<'a>,
267            Option<(
268                Metadata<'a>, // [
269                Metadata<'a>, // ]
270            )>,
271            Metadata<'a>, // =
272            TransList<'a>,
273            Option<(
274                Metadata<'a>, // iff
275                Metadata<'a>, // (
276                Expression<'a>,
277                Metadata<'a>, // )
278            )>,
279        )>,
280    ),
281    Default(
282        Box<(
283            BinsKeyword<'a>,
284            BinIdentifier<'a>,
285            Option<(
286                Metadata<'a>, // [
287                Option<CovergroupExpression<'a>>,
288                Metadata<'a>, // ]
289            )>,
290            Metadata<'a>, // =
291            Metadata<'a>, // default
292            Option<(
293                Metadata<'a>, // iff
294                Metadata<'a>, // (
295                Expression<'a>,
296                Metadata<'a>, // )
297            )>,
298        )>,
299    ),
300    DefaultSequence(
301        Box<(
302            BinsKeyword<'a>,
303            BinIdentifier<'a>,
304            Metadata<'a>, // =
305            Metadata<'a>, // default
306            Metadata<'a>, // sequence
307            Option<(
308                Metadata<'a>, // iff
309                Metadata<'a>, // (
310                Expression<'a>,
311                Metadata<'a>, // )
312            )>,
313        )>,
314    ),
315}
316
317#[derive(Clone, Debug, PartialEq)]
318pub enum BinsKeyword<'a> {
319    Bins(Metadata<'a>),
320    IllegalBins(Metadata<'a>),
321    IgnoreBins(Metadata<'a>),
322}
323
324#[derive(Clone, Debug, PartialEq)]
325pub struct TransList<'a>(
326    pub Metadata<'a>, // (
327    pub TransSet<'a>,
328    pub Metadata<'a>, // )
329    pub  Vec<(
330        Metadata<'a>, // ,
331        Metadata<'a>, // (
332        TransSet<'a>,
333        Metadata<'a>, // )
334    )>,
335);
336
337#[derive(Clone, Debug, PartialEq)]
338pub struct TransSet<'a>(
339    pub TransRangeList<'a>,
340    pub  Vec<(
341        Metadata<'a>, // =>
342        TransRangeList<'a>,
343    )>,
344);
345
346#[derive(Clone, Debug, PartialEq)]
347pub enum TransRangeList<'a> {
348    NoRepeat(Box<TransItem<'a>>),
349    Repeat(
350        Box<(
351            TransItem<'a>,
352            Metadata<'a>, // [
353            Metadata<'a>, // *
354            RepeatRange<'a>,
355            Metadata<'a>, // ]
356        )>,
357    ),
358    GotoRepeat(
359        Box<(
360            TransItem<'a>,
361            Metadata<'a>, // [
362            Metadata<'a>, // ->
363            RepeatRange<'a>,
364            Metadata<'a>, // ]
365        )>,
366    ),
367    NonconsecutiveRepeat(
368        Box<(
369            TransItem<'a>,
370            Metadata<'a>, // [
371            Metadata<'a>, // =
372            RepeatRange<'a>,
373            Metadata<'a>, // ]
374        )>,
375    ),
376}
377
378#[derive(Clone, Debug, PartialEq)]
379pub struct TransItem<'a>(pub CovergroupRangeList<'a>);
380
381#[derive(Clone, Debug, PartialEq)]
382pub enum RepeatRange<'a> {
383    Expr(Box<CovergroupExpression<'a>>),
384    Range(
385        Box<(
386            CovergroupExpression<'a>,
387            Metadata<'a>, // :
388            CovergroupExpression<'a>,
389        )>,
390    ),
391}
392
393#[derive(Clone, Debug, PartialEq)]
394pub struct CoverCross<'a>(
395    pub  Option<(
396        CrossIdentifier<'a>,
397        Metadata<'a>, // :
398    )>,
399    pub Metadata<'a>, // cross
400    pub ListOfCrossItems<'a>,
401    pub  Option<(
402        Metadata<'a>, // iff
403        Metadata<'a>, // (
404        Expression<'a>,
405        Metadata<'a>, // )
406    )>,
407    pub CrossBody<'a>,
408);
409
410#[derive(Clone, Debug, PartialEq)]
411pub struct ListOfCrossItems<'a>(
412    pub CrossItem<'a>,
413    pub Metadata<'a>, // ,
414    pub CrossItem<'a>,
415    pub  Vec<(
416        Metadata<'a>, // ,
417        CrossItem<'a>,
418    )>,
419);
420
421#[derive(Clone, Debug, PartialEq)]
422pub enum CrossItem<'a> {
423    CoverPoint(Box<CoverPointIdentifier<'a>>),
424    Variable(Box<VariableIdentifier<'a>>),
425}
426
427#[derive(Clone, Debug, PartialEq)]
428pub enum CrossBody<'a> {
429    Items(
430        Box<(
431            Metadata<'a>, // {
432            Vec<CrossBodyItem<'a>>,
433            Metadata<'a>, // }
434        )>,
435    ),
436    Null(Box<Metadata<'a>>),
437}
438
439#[derive(Clone, Debug, PartialEq)]
440pub enum CrossBodyItem<'a> {
441    Function(Box<FunctionDeclaration<'a>>),
442    BinsSelection(
443        Box<(
444            BinsSelectionOrOption<'a>,
445            Metadata<'a>, // ;
446        )>,
447    ),
448}
449
450#[derive(Clone, Debug, PartialEq)]
451pub enum BinsSelectionOrOption<'a> {
452    Coverage(Box<(Vec<AttributeInstance<'a>>, CoverageOption<'a>)>),
453    Bins(Box<(Vec<AttributeInstance<'a>>, BinsSelection<'a>)>),
454}
455
456#[derive(Clone, Debug, PartialEq)]
457pub struct BinsSelection<'a>(
458    pub BinsKeyword<'a>,
459    pub BinIdentifier<'a>,
460    pub Metadata<'a>, // =
461    pub SelectExpression<'a>,
462    pub  Option<(
463        Metadata<'a>, // iff
464        Metadata<'a>, // (
465        Expression<'a>,
466        Metadata<'a>, // )
467    )>,
468);
469
470#[derive(Clone, Debug, PartialEq)]
471pub enum SelectExpression<'a> {
472    Condition(Box<SelectCondition<'a>>),
473    Not(
474        Box<(
475            Metadata<'a>, // !
476            SelectCondition<'a>,
477        )>,
478    ),
479    And(
480        Box<(
481            SelectExpression<'a>,
482            Metadata<'a>, // &&
483            SelectExpression<'a>,
484        )>,
485    ),
486    Or(
487        Box<(
488            SelectExpression<'a>,
489            Metadata<'a>, // ||
490            SelectExpression<'a>,
491        )>,
492    ),
493    Paren(
494        Box<(
495            Metadata<'a>, // (
496            SelectExpression<'a>,
497            Metadata<'a>, // )
498        )>,
499    ),
500    With(
501        Box<(
502            SelectExpression<'a>,
503            Metadata<'a>, // with
504            Metadata<'a>, // (
505            WithCovergroupExpression<'a>,
506            Metadata<'a>, // )
507            Option<(
508                Metadata<'a>, // matches
509                IntegerCovergroupExpression<'a>,
510            )>,
511        )>,
512    ),
513    CrossIdentifier(Box<CrossIdentifier<'a>>),
514    CrossSet(
515        Box<(
516            CrossSetExpression<'a>,
517            Option<(
518                Metadata<'a>, // matches
519                IntegerCovergroupExpression<'a>,
520            )>,
521        )>,
522    ),
523}
524
525#[derive(Clone, Debug, PartialEq)]
526pub struct SelectCondition<'a>(
527    pub Metadata<'a>, // binsof
528    pub Metadata<'a>, // (
529    pub BinsExpression<'a>,
530    pub Metadata<'a>, // )
531    pub  Option<(
532        Metadata<'a>, // intersect
533        Metadata<'a>, // {
534        CovergroupRangeList<'a>,
535        Metadata<'a>, // }
536    )>,
537);
538
539#[derive(Clone, Debug, PartialEq)]
540pub enum BinsExpression<'a> {
541    Variable(Box<VariableIdentifier<'a>>),
542    CoverPoint(
543        Box<(
544            CoverPointIdentifier<'a>,
545            Option<(
546                Metadata<'a>, // .
547                BinIdentifier<'a>,
548            )>,
549        )>,
550    ),
551}
552
553#[derive(Clone, Debug, PartialEq)]
554pub struct CovergroupRangeList<'a>(
555    pub CovergroupValueRange<'a>,
556    pub  Vec<(
557        Metadata<'a>, // ,
558        CovergroupValueRange<'a>,
559    )>,
560);
561
562#[derive(Clone, Debug, PartialEq)]
563pub enum CovergroupValueRange<'a> {
564    Expr(Box<CovergroupExpression<'a>>),
565    ExprRange(
566        Box<(
567            Metadata<'a>, // [
568            CovergroupExpression<'a>,
569            Metadata<'a>, // :
570            CovergroupExpression<'a>,
571            Metadata<'a>, // ]
572        )>,
573    ),
574    DollarLow(
575        Box<(
576            Metadata<'a>, // [
577            Metadata<'a>, // $
578            Metadata<'a>, // :
579            CovergroupExpression<'a>,
580            Metadata<'a>, // ]
581        )>,
582    ),
583    DollarHigh(
584        Box<(
585            Metadata<'a>, // [
586            CovergroupExpression<'a>,
587            Metadata<'a>, // :
588            Metadata<'a>, // $
589            Metadata<'a>, // ]
590        )>,
591    ),
592    AbsoluteTolerance(
593        Box<(
594            Metadata<'a>, // [
595            CovergroupExpression<'a>,
596            Metadata<'a>, // +/-
597            CovergroupExpression<'a>,
598            Metadata<'a>, // ]
599        )>,
600    ),
601    RelativeTolerance(
602        Box<(
603            Metadata<'a>, // [
604            CovergroupExpression<'a>,
605            Metadata<'a>, // +%-
606            CovergroupExpression<'a>,
607            Metadata<'a>, // ]
608        )>,
609    ),
610}
611
612#[derive(Clone, Debug, PartialEq)]
613pub struct WithCovergroupExpression<'a>(pub CovergroupExpression<'a>);
614
615#[derive(Clone, Debug, PartialEq)]
616pub struct SetCovergroupExpression<'a>(pub CovergroupExpression<'a>);
617
618#[derive(Clone, Debug, PartialEq)]
619pub enum IntegerCovergroupExpression<'a> {
620    Expression(Box<CovergroupExpression<'a>>),
621    Dollar(Box<Metadata<'a>>),
622}
623
624#[derive(Clone, Debug, PartialEq)]
625pub struct CrossSetExpression<'a>(pub CovergroupExpression<'a>);
626
627#[derive(Clone, Debug, PartialEq)]
628pub struct CovergroupExpression<'a>(pub Expression<'a>);
scarf_syntax/declarations/covergroup_declarations.rs

scarf_syntax/declarations/
covergroup_declarations.rs
