use crate::*;
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CovergroupDeclaration {
pub nodes: (
Keyword,
CovergroupIdentifier,
Option<Paren<Option<TfPortList>>>,
Option<CoverageEvent>,
Symbol,
Vec<CoverageSpecOrOption>,
Keyword,
Option<(Symbol, CovergroupIdentifier)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CoverageSpecOrOption {
Spec(Box<CoverageSpecOrOptionSpec>),
Option(Box<CoverageSpecOrOptionOption>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageSpecOrOptionSpec {
pub nodes: (Vec<AttributeInstance>, CoverageSpec),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageSpecOrOptionOption {
pub nodes: (Vec<AttributeInstance>, CoverageOption, Symbol),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CoverageOption {
Option(Box<CoverageOptionOption>),
TypeOption(Box<CoverageOptionTypeOption>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageOptionOption {
pub nodes: (Keyword, Symbol, MemberIdentifier, Symbol, Expression),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageOptionTypeOption {
pub nodes: (
Keyword,
Symbol,
MemberIdentifier,
Symbol,
ConstantExpression,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CoverageSpec {
CoverPoint(Box<CoverPoint>),
CoverCross(Box<CoverCross>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CoverageEvent {
ClockingEvent(Box<ClockingEvent>),
Sample(Box<CoverageEventSample>),
At(Box<CoverageEventAt>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageEventSample {
pub nodes: (Keyword, Keyword, Keyword, Paren<Option<TfPortList>>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageEventAt {
pub nodes: (Symbol, Paren<BlockEventExpression>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BlockEventExpression {
Or(Box<BlockEventExpressionOr>),
Begin(Box<BlockEventExpressionBegin>),
End(Box<BlockEventExpressionEnd>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockEventExpressionOr {
pub nodes: (BlockEventExpression, Keyword, BlockEventExpression),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockEventExpressionBegin {
pub nodes: (Keyword, HierarchicalBtfIdentifier),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockEventExpressionEnd {
pub nodes: (Keyword, HierarchicalBtfIdentifier),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum HierarchicalBtfIdentifier {
HierarchicalTfIdentifier(Box<HierarchicalTfIdentifier>),
HierarchicalBlockIdentifier(Box<HierarchicalBlockIdentifier>),
Method(Box<HierarchicalBtfIdentifierMethod>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalBtfIdentifierMethod {
pub nodes: (Option<HierarchicalIdentifierOrClassScope>, MethodIdentifier),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum HierarchicalIdentifierOrClassScope {
HierarchicalIdentifier(Box<(HierarchicalIdentifier, Symbol)>),
ClassScope(Box<ClassScope>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverPoint {
pub nodes: (
Option<(Option<DataTypeOrImplicit>, CoverPointIdentifier, Symbol)>,
Keyword,
Expression,
Option<(Keyword, Paren<Expression>)>,
BinsOrEmpty,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BinsOrEmpty {
NonEmpty(Box<BinsOrEmptyNonEmpty>),
Empty(Box<Symbol>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrEmptyNonEmpty {
pub nodes: (Brace<(Vec<AttributeInstance>, Vec<(BinsOrOptions, Symbol)>)>,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BinsOrOptions {
CoverageOption(Box<CoverageOption>),
Covergroup(Box<BinsOrOptionsCovergroup>),
CoverPoint(Box<BinsOrOptionsCoverPoint>),
SetCovergroup(Box<BinsOrOptionsSetCovergroup>),
TransList(Box<BinsOrOptionsTransList>),
Default(Box<BinsOrOptionsDefault>),
DefaultSequence(Box<BinsOrOptionsDefaultSequence>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsCovergroup {
pub nodes: (
Option<Wildcard>,
BinsKeyword,
BinIdentifier,
Option<Bracket<Option<CovergroupExpression>>>,
Symbol,
Brace<CovergroupRangeList>,
Option<(Keyword, Paren<WithCovergroupExpression>)>,
Option<(Keyword, Paren<Expression>)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Wildcard {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsCoverPoint {
pub nodes: (
Option<Wildcard>,
BinsKeyword,
BinIdentifier,
Option<Bracket<Option<CovergroupExpression>>>,
Symbol,
CoverPointIdentifier,
Keyword,
Paren<WithCovergroupExpression>,
Option<(Keyword, Paren<Expression>)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsSetCovergroup {
pub nodes: (
Option<Wildcard>,
BinsKeyword,
BinIdentifier,
Option<Bracket<Option<CovergroupExpression>>>,
Symbol,
SetCovergroupExpression,
Option<(Keyword, Paren<Expression>)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsTransList {
pub nodes: (
Option<Wildcard>,
BinsKeyword,
BinIdentifier,
Option<(Symbol, Symbol)>,
Symbol,
TransList,
Option<(Keyword, Paren<Expression>)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsDefault {
pub nodes: (
BinsKeyword,
BinIdentifier,
Option<Bracket<Option<CovergroupExpression>>>,
Symbol,
Keyword,
Option<(Keyword, Paren<Expression>)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsDefaultSequence {
pub nodes: (
BinsKeyword,
BinIdentifier,
Symbol,
Keyword,
Keyword,
Option<(Keyword, Paren<Expression>)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BinsKeyword {
Bins(Box<Keyword>),
IllegalBins(Box<Keyword>),
IgnoreBins(Box<Keyword>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransList {
pub nodes: (List<Symbol, Paren<TransSet>>,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransSet {
pub nodes: (List<Symbol, TransRangeList>,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TransRangeList {
TransItem(Box<TransItem>),
Asterisk(Box<TransRangeListAsterisk>),
Arrow(Box<TransRangeListArrow>),
Equal(Box<TransRangeListEqual>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransRangeListAsterisk {
pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransRangeListArrow {
pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransRangeListEqual {
pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransItem {
pub nodes: (CovergroupRangeList,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum RepeatRange {
CovergroupExpression(Box<CovergroupExpression>),
Binary(Box<RepeatRangeBinary>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RepeatRangeBinary {
pub nodes: (CovergroupExpression, Symbol, CovergroupExpression),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverCross {
pub nodes: (
Option<(CrossIdentifier, Symbol)>,
Keyword,
ListOfCrossItems,
Option<(Keyword, Paren<Expression>)>,
CrossBody,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfCrossItems {
pub nodes: (CrossItem, Symbol, List<Symbol, CrossItem>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CrossItem {
CoverPointIdentifier(Box<CoverPointIdentifier>),
VariableIdentifier(Box<VariableIdentifier>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CrossBody {
NonEmpty(Box<CrossBodyNonEmpty>),
Empty(Box<Symbol>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CrossBodyNonEmpty {
pub nodes: (Brace<Vec<CrossBodyItem>>,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CrossBodyItem {
FunctionDeclaration(Box<FunctionDeclaration>),
BinsSelectionOrOption(Box<(BinsSelectionOrOption, Symbol)>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BinsSelectionOrOption {
Coverage(Box<BinsSelectionOrOptionCoverage>),
Bins(Box<BinsSelectionOrOptionBins>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsSelectionOrOptionCoverage {
pub nodes: (Vec<AttributeInstance>, CoverageOption),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsSelectionOrOptionBins {
pub nodes: (Vec<AttributeInstance>, BinsSelection),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsSelection {
pub nodes: (
BinsKeyword,
BinIdentifier,
Symbol,
SelectExpression,
Option<(Keyword, Paren<Expression>)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SelectExpression {
SelectCondition(Box<SelectCondition>),
Not(Box<SelectExpressionNot>),
And(Box<SelectExpressionAnd>),
Or(Box<SelectExpressionOr>),
Paren(Box<SelectExpressionParen>),
With(Box<SelectExpressionWith>),
CrossIdentifier(Box<CrossIdentifier>),
CrossSet(Box<SelectExpressionCrossSet>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionNot {
pub nodes: (Symbol, SelectCondition),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionAnd {
pub nodes: (SelectExpression, Symbol, SelectExpression),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionOr {
pub nodes: (SelectExpression, Symbol, SelectExpression),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionParen {
pub nodes: (Paren<SelectExpression>,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionWith {
pub nodes: (
SelectExpression,
Keyword,
Paren<WithCovergroupExpression>,
Option<(Keyword, IntegerCovergroupExpression)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionCrossSet {
pub nodes: (
CrossSetExpression,
Option<(Keyword, IntegerCovergroupExpression)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectCondition {
pub nodes: (
Keyword,
Paren<BinsExpression>,
Option<(Keyword, Brace<CovergroupRangeList>)>,
),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BinsExpression {
VariableIdentifier(Box<VariableIdentifier>),
CoverPoint(Box<BinsExpressionCoverPoint>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsExpressionCoverPoint {
pub nodes: (CoverPointIdentifier, Option<(Symbol, BinIdentifier)>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CovergroupRangeList {
pub nodes: (List<Symbol, CovergroupValueRange>,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CovergroupValueRange {
CovergroupExpression(Box<CovergroupExpression>),
Binary(Box<CovergroupValueRangeBinary>),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CovergroupValueRangeBinary {
pub nodes: (Bracket<(CovergroupExpression, Symbol, CovergroupExpression)>,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct WithCovergroupExpression {
pub nodes: (CovergroupExpression,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SetCovergroupExpression {
pub nodes: (CovergroupExpression,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IntegerCovergroupExpression {
pub nodes: (CovergroupExpression,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CrossSetExpression {
pub nodes: (CovergroupExpression,),
}
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CovergroupExpression {
pub nodes: (Expression,),
}