1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use crate::*;

// -----------------------------------------------------------------------------

#[derive(Clone, Debug, PartialEq, Node)]
pub struct DefparamAssignment {
    pub nodes: (
        HierarchicalParameterIdentifier,
        Symbol,
        ConstantMintypmaxExpression,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetDeclAssignment {
    pub nodes: (
        NetIdentifier,
        Vec<UnpackedDimension>,
        Option<(Symbol, Expression)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParamAssignment {
    pub nodes: (
        ParameterIdentifier,
        Vec<UnpackedDimension>,
        Option<(Symbol, ConstantParamExpression)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum SpecparamAssignment {
    Mintypmax(Box<SpecparamAssignmentMintypmax>),
    PulseControlSpecparam(Box<PulseControlSpecparam>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct SpecparamAssignmentMintypmax {
    pub nodes: (SpecparamIdentifier, Symbol, ConstantMintypmaxExpression),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct TypeAssignment {
    pub nodes: (TypeIdentifier, Option<(Symbol, DataType)>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum PulseControlSpecparam {
    WithoutDescriptor(Box<PulseControlSpecparamWithoutDescriptor>),
    WithDescriptor(Box<PulseControlSpecparamWithDescriptor>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PulseControlSpecparamWithoutDescriptor {
    pub nodes: (
        Symbol,
        Symbol,
        Paren<(RejectLimitValue, Option<(Symbol, ErrorLimitValue)>)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct PulseControlSpecparamWithDescriptor {
    pub nodes: (
        Symbol,
        SpecifyInputTerminalDescriptor,
        Symbol,
        SpecifyOutputTerminalDescriptor,
        Symbol,
        Paren<(RejectLimitValue, Option<(Symbol, ErrorLimitValue)>)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct ErrorLimitValue {
    pub nodes: (LimitValue,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct RejectLimitValue {
    pub nodes: (LimitValue,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct LimitValue {
    pub nodes: (ConstantMintypmaxExpression,),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum VariableDeclAssignment {
    Variable(Box<VariableDeclAssignmentVariable>),
    DynamicArray(Box<VariableDeclAssignmentDynamicArray>),
    Class(Box<VariableDeclAssignmentClass>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableDeclAssignmentVariable {
    pub nodes: (
        VariableIdentifier,
        Vec<VariableDimension>,
        Option<(Symbol, Expression)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableDeclAssignmentDynamicArray {
    pub nodes: (
        DynamicArrayVariableIdentifier,
        UnsizedDimension,
        Vec<VariableDimension>,
        Option<(Symbol, DynamicArrayNew)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableDeclAssignmentClass {
    pub nodes: (ClassVariableIdentifier, (Symbol, ClassNew)),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClassNew {
    Argument(Box<ClassNewArgument>),
    Expression(Box<ClassNewExpression>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassNewArgument {
    pub nodes: (Option<ClassScope>, Keyword, Option<Paren<ListOfArguments>>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassNewExpression {
    pub nodes: (Keyword, Expression),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct DynamicArrayNew {
    pub nodes: (Keyword, Bracket<Expression>, Option<Paren<Expression>>),
}