1use crate::*;
2
3#[derive(Clone, Debug, PartialEq, Node)]
6pub struct CovergroupDeclaration {
7 pub nodes: (
8 Keyword,
9 CovergroupIdentifier,
10 Option<Paren<Option<TfPortList>>>,
11 Option<CoverageEvent>,
12 Symbol,
13 Vec<CoverageSpecOrOption>,
14 Keyword,
15 Option<(Symbol, CovergroupIdentifier)>,
16 ),
17}
18
19#[derive(Clone, Debug, PartialEq, Node)]
20pub enum CoverageSpecOrOption {
21 Spec(Box<CoverageSpecOrOptionSpec>),
22 Option(Box<CoverageSpecOrOptionOption>),
23}
24
25#[derive(Clone, Debug, PartialEq, Node)]
26pub struct CoverageSpecOrOptionSpec {
27 pub nodes: (Vec<AttributeInstance>, CoverageSpec),
28}
29
30#[derive(Clone, Debug, PartialEq, Node)]
31pub struct CoverageSpecOrOptionOption {
32 pub nodes: (Vec<AttributeInstance>, CoverageOption, Symbol),
33}
34
35#[derive(Clone, Debug, PartialEq, Node)]
36pub enum CoverageOption {
37 Option(Box<CoverageOptionOption>),
38 TypeOption(Box<CoverageOptionTypeOption>),
39}
40
41#[derive(Clone, Debug, PartialEq, Node)]
42pub struct CoverageOptionOption {
43 pub nodes: (Keyword, Symbol, MemberIdentifier, Symbol, Expression),
44}
45
46#[derive(Clone, Debug, PartialEq, Node)]
47pub struct CoverageOptionTypeOption {
48 pub nodes: (
49 Keyword,
50 Symbol,
51 MemberIdentifier,
52 Symbol,
53 ConstantExpression,
54 ),
55}
56
57#[derive(Clone, Debug, PartialEq, Node)]
58pub enum CoverageSpec {
59 CoverPoint(Box<CoverPoint>),
60 CoverCross(Box<CoverCross>),
61}
62
63#[derive(Clone, Debug, PartialEq, Node)]
64pub enum CoverageEvent {
65 ClockingEvent(Box<ClockingEvent>),
66 Sample(Box<CoverageEventSample>),
67 At(Box<CoverageEventAt>),
68}
69
70#[derive(Clone, Debug, PartialEq, Node)]
71pub struct CoverageEventSample {
72 pub nodes: (Keyword, Keyword, Keyword, Paren<Option<TfPortList>>),
73}
74
75#[derive(Clone, Debug, PartialEq, Node)]
76pub struct CoverageEventAt {
77 pub nodes: (Symbol, Paren<BlockEventExpression>),
78}
79
80#[derive(Clone, Debug, PartialEq, Node)]
81pub enum BlockEventExpression {
82 Or(Box<BlockEventExpressionOr>),
83 Begin(Box<BlockEventExpressionBegin>),
84 End(Box<BlockEventExpressionEnd>),
85}
86
87#[derive(Clone, Debug, PartialEq, Node)]
88pub struct BlockEventExpressionOr {
89 pub nodes: (BlockEventExpression, Keyword, BlockEventExpression),
90}
91
92#[derive(Clone, Debug, PartialEq, Node)]
93pub struct BlockEventExpressionBegin {
94 pub nodes: (Keyword, HierarchicalBtfIdentifier),
95}
96
97#[derive(Clone, Debug, PartialEq, Node)]
98pub struct BlockEventExpressionEnd {
99 pub nodes: (Keyword, HierarchicalBtfIdentifier),
100}
101
102#[derive(Clone, Debug, PartialEq, Node)]
103pub enum HierarchicalBtfIdentifier {
104 HierarchicalTfIdentifier(Box<HierarchicalTfIdentifier>),
105 HierarchicalBlockIdentifier(Box<HierarchicalBlockIdentifier>),
106 Method(Box<HierarchicalBtfIdentifierMethod>),
107}
108
109#[derive(Clone, Debug, PartialEq, Node)]
110pub struct HierarchicalBtfIdentifierMethod {
111 pub nodes: (Option<HierarchicalIdentifierOrClassScope>, MethodIdentifier),
112}
113
114#[derive(Clone, Debug, PartialEq, Node)]
115pub enum HierarchicalIdentifierOrClassScope {
116 HierarchicalIdentifier(Box<(HierarchicalIdentifier, Symbol)>),
117 ClassScope(Box<ClassScope>),
118}
119
120#[derive(Clone, Debug, PartialEq, Node)]
121pub struct CoverPoint {
122 pub nodes: (
123 Option<(Option<DataTypeOrImplicit>, CoverPointIdentifier, Symbol)>,
124 Keyword,
125 Expression,
126 Option<(Keyword, Paren<Expression>)>,
127 BinsOrEmpty,
128 ),
129}
130
131#[derive(Clone, Debug, PartialEq, Node)]
132pub enum BinsOrEmpty {
133 NonEmpty(Box<BinsOrEmptyNonEmpty>),
134 Empty(Box<Symbol>),
135}
136
137#[derive(Clone, Debug, PartialEq, Node)]
138pub struct BinsOrEmptyNonEmpty {
139 pub nodes: (Brace<(Vec<AttributeInstance>, Vec<(BinsOrOptions, Symbol)>)>,),
140}
141
142#[derive(Clone, Debug, PartialEq, Node)]
143pub enum BinsOrOptions {
144 CoverageOption(Box<CoverageOption>),
145 Covergroup(Box<BinsOrOptionsCovergroup>),
146 CoverPoint(Box<BinsOrOptionsCoverPoint>),
147 SetCovergroup(Box<BinsOrOptionsSetCovergroup>),
148 TransList(Box<BinsOrOptionsTransList>),
149 Default(Box<BinsOrOptionsDefault>),
150 DefaultSequence(Box<BinsOrOptionsDefaultSequence>),
151}
152
153#[derive(Clone, Debug, PartialEq, Node)]
154pub struct BinsOrOptionsCovergroup {
155 pub nodes: (
156 Option<Wildcard>,
157 BinsKeyword,
158 BinIdentifier,
159 Option<Bracket<Option<CovergroupExpression>>>,
160 Symbol,
161 Brace<CovergroupRangeList>,
162 Option<(Keyword, Paren<WithCovergroupExpression>)>,
163 Option<(Keyword, Paren<Expression>)>,
164 ),
165}
166
167#[derive(Clone, Debug, PartialEq, Node)]
168pub struct Wildcard {
169 pub nodes: (Keyword,),
170}
171
172#[derive(Clone, Debug, PartialEq, Node)]
173pub struct BinsOrOptionsCoverPoint {
174 pub nodes: (
175 Option<Wildcard>,
176 BinsKeyword,
177 BinIdentifier,
178 Option<Bracket<Option<CovergroupExpression>>>,
179 Symbol,
180 CoverPointIdentifier,
181 Keyword,
182 Paren<WithCovergroupExpression>,
183 Option<(Keyword, Paren<Expression>)>,
184 ),
185}
186
187#[derive(Clone, Debug, PartialEq, Node)]
188pub struct BinsOrOptionsSetCovergroup {
189 pub nodes: (
190 Option<Wildcard>,
191 BinsKeyword,
192 BinIdentifier,
193 Option<Bracket<Option<CovergroupExpression>>>,
194 Symbol,
195 SetCovergroupExpression,
196 Option<(Keyword, Paren<Expression>)>,
197 ),
198}
199
200#[derive(Clone, Debug, PartialEq, Node)]
201pub struct BinsOrOptionsTransList {
202 pub nodes: (
203 Option<Wildcard>,
204 BinsKeyword,
205 BinIdentifier,
206 Option<(Symbol, Symbol)>,
207 Symbol,
208 TransList,
209 Option<(Keyword, Paren<Expression>)>,
210 ),
211}
212
213#[derive(Clone, Debug, PartialEq, Node)]
214pub struct BinsOrOptionsDefault {
215 pub nodes: (
216 BinsKeyword,
217 BinIdentifier,
218 Option<Bracket<Option<CovergroupExpression>>>,
219 Symbol,
220 Keyword,
221 Option<(Keyword, Paren<Expression>)>,
222 ),
223}
224
225#[derive(Clone, Debug, PartialEq, Node)]
226pub struct BinsOrOptionsDefaultSequence {
227 pub nodes: (
228 BinsKeyword,
229 BinIdentifier,
230 Symbol,
231 Keyword,
232 Keyword,
233 Option<(Keyword, Paren<Expression>)>,
234 ),
235}
236
237#[derive(Clone, Debug, PartialEq, Node)]
238pub enum BinsKeyword {
239 Bins(Box<Keyword>),
240 IllegalBins(Box<Keyword>),
241 IgnoreBins(Box<Keyword>),
242}
243
244#[derive(Clone, Debug, PartialEq, Node)]
245pub struct TransList {
246 pub nodes: (List<Symbol, Paren<TransSet>>,),
247}
248
249#[derive(Clone, Debug, PartialEq, Node)]
250pub struct TransSet {
251 pub nodes: (List<Symbol, TransRangeList>,),
252}
253
254#[derive(Clone, Debug, PartialEq, Node)]
255pub enum TransRangeList {
256 TransItem(Box<TransItem>),
257 Asterisk(Box<TransRangeListAsterisk>),
258 Arrow(Box<TransRangeListArrow>),
259 Equal(Box<TransRangeListEqual>),
260}
261
262#[derive(Clone, Debug, PartialEq, Node)]
263pub struct TransRangeListAsterisk {
264 pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
265}
266
267#[derive(Clone, Debug, PartialEq, Node)]
268pub struct TransRangeListArrow {
269 pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
270}
271
272#[derive(Clone, Debug, PartialEq, Node)]
273pub struct TransRangeListEqual {
274 pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
275}
276
277#[derive(Clone, Debug, PartialEq, Node)]
278pub struct TransItem {
279 pub nodes: (CovergroupRangeList,),
280}
281
282#[derive(Clone, Debug, PartialEq, Node)]
283pub enum RepeatRange {
284 CovergroupExpression(Box<CovergroupExpression>),
285 Binary(Box<RepeatRangeBinary>),
286}
287
288#[derive(Clone, Debug, PartialEq, Node)]
289pub struct RepeatRangeBinary {
290 pub nodes: (CovergroupExpression, Symbol, CovergroupExpression),
291}
292
293#[derive(Clone, Debug, PartialEq, Node)]
294pub struct CoverCross {
295 pub nodes: (
296 Option<(CrossIdentifier, Symbol)>,
297 Keyword,
298 ListOfCrossItems,
299 Option<(Keyword, Paren<Expression>)>,
300 CrossBody,
301 ),
302}
303
304#[derive(Clone, Debug, PartialEq, Node)]
305pub struct ListOfCrossItems {
306 pub nodes: (CrossItem, Symbol, List<Symbol, CrossItem>),
307}
308
309#[derive(Clone, Debug, PartialEq, Node)]
310pub enum CrossItem {
311 CoverPointIdentifier(Box<CoverPointIdentifier>),
312 VariableIdentifier(Box<VariableIdentifier>),
313}
314
315#[derive(Clone, Debug, PartialEq, Node)]
316pub enum CrossBody {
317 NonEmpty(Box<CrossBodyNonEmpty>),
318 Empty(Box<Symbol>),
319}
320
321#[derive(Clone, Debug, PartialEq, Node)]
322pub struct CrossBodyNonEmpty {
323 pub nodes: (Brace<Vec<CrossBodyItem>>,),
324}
325
326#[derive(Clone, Debug, PartialEq, Node)]
327pub enum CrossBodyItem {
328 FunctionDeclaration(Box<FunctionDeclaration>),
329 BinsSelectionOrOption(Box<(BinsSelectionOrOption, Symbol)>),
330}
331
332#[derive(Clone, Debug, PartialEq, Node)]
333pub enum BinsSelectionOrOption {
334 Coverage(Box<BinsSelectionOrOptionCoverage>),
335 Bins(Box<BinsSelectionOrOptionBins>),
336}
337
338#[derive(Clone, Debug, PartialEq, Node)]
339pub struct BinsSelectionOrOptionCoverage {
340 pub nodes: (Vec<AttributeInstance>, CoverageOption),
341}
342
343#[derive(Clone, Debug, PartialEq, Node)]
344pub struct BinsSelectionOrOptionBins {
345 pub nodes: (Vec<AttributeInstance>, BinsSelection),
346}
347
348#[derive(Clone, Debug, PartialEq, Node)]
349pub struct BinsSelection {
350 pub nodes: (
351 BinsKeyword,
352 BinIdentifier,
353 Symbol,
354 SelectExpression,
355 Option<(Keyword, Paren<Expression>)>,
356 ),
357}
358
359#[derive(Clone, Debug, PartialEq, Node)]
360pub enum SelectExpression {
361 SelectCondition(Box<SelectCondition>),
362 Not(Box<SelectExpressionNot>),
363 And(Box<SelectExpressionAnd>),
364 Or(Box<SelectExpressionOr>),
365 Paren(Box<SelectExpressionParen>),
366 With(Box<SelectExpressionWith>),
367 CrossIdentifier(Box<CrossIdentifier>),
368 CrossSet(Box<SelectExpressionCrossSet>),
369}
370
371#[derive(Clone, Debug, PartialEq, Node)]
372pub struct SelectExpressionNot {
373 pub nodes: (Symbol, SelectCondition),
374}
375
376#[derive(Clone, Debug, PartialEq, Node)]
377pub struct SelectExpressionAnd {
378 pub nodes: (SelectExpression, Symbol, SelectExpression),
379}
380
381#[derive(Clone, Debug, PartialEq, Node)]
382pub struct SelectExpressionOr {
383 pub nodes: (SelectExpression, Symbol, SelectExpression),
384}
385
386#[derive(Clone, Debug, PartialEq, Node)]
387pub struct SelectExpressionParen {
388 pub nodes: (Paren<SelectExpression>,),
389}
390
391#[derive(Clone, Debug, PartialEq, Node)]
392pub struct SelectExpressionWith {
393 pub nodes: (
394 SelectExpression,
395 Keyword,
396 Paren<WithCovergroupExpression>,
397 Option<(Keyword, IntegerCovergroupExpression)>,
398 ),
399}
400
401#[derive(Clone, Debug, PartialEq, Node)]
402pub struct SelectExpressionCrossSet {
403 pub nodes: (
404 CrossSetExpression,
405 Option<(Keyword, IntegerCovergroupExpression)>,
406 ),
407}
408
409#[derive(Clone, Debug, PartialEq, Node)]
410pub struct SelectCondition {
411 pub nodes: (
412 Keyword,
413 Paren<BinsExpression>,
414 Option<(Keyword, Brace<CovergroupRangeList>)>,
415 ),
416}
417
418#[derive(Clone, Debug, PartialEq, Node)]
419pub enum BinsExpression {
420 VariableIdentifier(Box<VariableIdentifier>),
421 CoverPoint(Box<BinsExpressionCoverPoint>),
422}
423
424#[derive(Clone, Debug, PartialEq, Node)]
425pub struct BinsExpressionCoverPoint {
426 pub nodes: (CoverPointIdentifier, Option<(Symbol, BinIdentifier)>),
427}
428
429#[derive(Clone, Debug, PartialEq, Node)]
430pub struct CovergroupRangeList {
431 pub nodes: (List<Symbol, CovergroupValueRange>,),
432}
433
434#[derive(Clone, Debug, PartialEq, Node)]
435pub enum CovergroupValueRange {
436 CovergroupExpression(Box<CovergroupExpression>),
437 Binary(Box<CovergroupValueRangeBinary>),
438}
439
440#[derive(Clone, Debug, PartialEq, Node)]
441pub struct CovergroupValueRangeBinary {
442 pub nodes: (Bracket<(CovergroupExpression, Symbol, CovergroupExpression)>,),
443}
444
445#[derive(Clone, Debug, PartialEq, Node)]
446pub struct WithCovergroupExpression {
447 pub nodes: (CovergroupExpression,),
448}
449
450#[derive(Clone, Debug, PartialEq, Node)]
451pub struct SetCovergroupExpression {
452 pub nodes: (CovergroupExpression,),
453}
454
455#[derive(Clone, Debug, PartialEq, Node)]
456pub struct IntegerCovergroupExpression {
457 pub nodes: (CovergroupExpression,),
458}
459
460#[derive(Clone, Debug, PartialEq, Node)]
461pub struct CrossSetExpression {
462 pub nodes: (CovergroupExpression,),
463}
464
465#[derive(Clone, Debug, PartialEq, Node)]
466pub struct CovergroupExpression {
467 pub nodes: (Expression,),
468}