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
141
142
143
144
145
146
147
148

use crate::*;

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

#[derive(Clone, Debug, PartialEq, Node)]
pub enum FunctionDataTypeOrImplicit {
    DataTypeOrVoid(Box<DataTypeOrVoid>),
    ImplicitDataType(Box<ImplicitDataType>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionDeclaration {
    pub nodes: (Keyword, Option<Lifetime>, FunctionBodyDeclaration),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum FunctionBodyDeclaration {
    WithoutPort(Box<FunctionBodyDeclarationWithoutPort>),
    WithPort(Box<FunctionBodyDeclarationWithPort>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionBodyDeclarationWithoutPort {
    pub nodes: (
        FunctionDataTypeOrImplicit,
        Option<InterfaceIdentifierOrClassScope>,
        FunctionIdentifier,
        Symbol,
        Vec<TfItemDeclaration>,
        Vec<FunctionStatementOrNull>,
        Keyword,
        Option<(Symbol, FunctionIdentifier)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionBodyDeclarationWithPort {
    pub nodes: (
        FunctionDataTypeOrImplicit,
        Option<InterfaceIdentifierOrClassScope>,
        FunctionIdentifier,
        Paren<Option<TfPortList>>,
        Symbol,
        Vec<BlockItemDeclaration>,
        Vec<FunctionStatementOrNull>,
        Keyword,
        Option<(Symbol, FunctionIdentifier)>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum InterfaceIdentifierOrClassScope {
    InterfaceIdentifier(Box<(InterfaceIdentifier, Symbol)>),
    ClassScope(Box<ClassScope>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionPrototype {
    pub nodes: (
        Keyword,
        DataTypeOrVoid,
        FunctionIdentifier,
        Option<Paren<Option<TfPortList>>>,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum DpiImportExport {
    ImportFunction(Box<DpiImportExportImportFunction>),
    ImportTask(Box<DpiImportExportImportTask>),
    ExportFunction(Box<DpiImportExportExportFunction>),
    ExportTask(Box<DpiImportExportExportTask>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct DpiImportExportImportFunction {
    pub nodes: (
        Keyword,
        DpiSpecString,
        Option<DpiFunctionImportProperty>,
        Option<(CIdentifier, Symbol)>,
        DpiFunctionProto,
        Symbol,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct DpiImportExportImportTask {
    pub nodes: (
        Keyword,
        DpiSpecString,
        Option<DpiTaskImportProperty>,
        Option<(CIdentifier, Symbol)>,
        DpiTaskProto,
        Symbol,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct DpiImportExportExportFunction {
    pub nodes: (
        Keyword,
        DpiSpecString,
        Option<(CIdentifier, Symbol)>,
        Keyword,
        FunctionIdentifier,
        Symbol,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub struct DpiImportExportExportTask {
    pub nodes: (
        Keyword,
        DpiSpecString,
        Option<(CIdentifier, Symbol)>,
        Keyword,
        TaskIdentifier,
        Symbol,
    ),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum DpiSpecString {
    DpiC(Box<Keyword>),
    Dpi(Box<Keyword>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum DpiFunctionImportProperty {
    Context(Box<Keyword>),
    Pure(Box<Keyword>),
}

#[derive(Clone, Debug, PartialEq, Node)]
pub enum DpiTaskImportProperty {
    Context(Box<Keyword>),
}

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

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