kirigaya/sv-parser
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Add preprocessor

Browse Source
This commit is contained in:
dalance 2019-09-05 10:31:56 +09:00
parent 6cd5d30e66
commit e1d80ab007
83 changed files with 1548 additions and 1263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
sv-parser-macros/src/lib.rs
View File

@ -67,6 +67,38 @@ fn impl_node(ast: &DeriveInput) -> TokenStream {
}
}
impl<'a> From<&'a #name> for RefNode<'a> {
fn from(x: &'a #name) -> Self {
RefNode::#name(x)
}
}
impl core::convert::TryFrom<#name> for Locate {
type Error = ();
fn try_from(x: #name) -> Result<Self, Self::Error> {
Self::try_from(&x)
}
}
impl<'a> core::convert::TryFrom<&'a #name> for Locate {
type Error = ();
fn try_from(x: &'a #name) -> Result<Self, Self::Error> {
let mut locate: Option<Locate> = None;
for x in x {
match x {
RefNode::Locate(x) => if let Some(loc) = locate {
assert_eq!(x.offset, loc.offset + loc.len);
locate = Some(Locate { offset: loc.offset, line: loc.line, len: loc.len + x.len });
} else {
locate = Some(*x);
},
_ => (),
}
}
locate.ok_or(())
}
}
impl<'a> IntoIterator for &'a #name {
type Item = RefNode<'a>;
type IntoIter = Iter<'a>;

2
sv-parser-parser/src/general/compiler_directives.rs
View File

@ -137,7 +137,9 @@ pub(crate) fn angle_bracket_literal_impl(s: Span) -> IResult<Span, Locate> {
pub(crate) fn text_macro_definition(s: Span) -> IResult<Span, TextMacroDefinition> {
let (s, a) = symbol("`")(s)?;
let (s, b) = keyword("define")(s)?;
begin_lb_not_space();
let (s, c) = text_macro_name(s)?;
end_lb_not_space();
let (s, d) = opt(macro_text)(s)?;
Ok((
s,

12
sv-parser-parser/src/tests.rs
View File

@ -302,6 +302,18 @@ mod unit {
Ok((_, _))
);
test!(text_macro_definition, r##"`define a"##, Ok((_, _)));
test!(
source_text,
r##"module test(out);
`define nest_two
`ifdef wow
initial $display("wow is defined");
`else
initial $display("wow is not defined");
`endif
endmodule"##,
Ok((_, _))
);
}
}

37
sv-parser-parser/src/utils.rs
View File

@ -258,18 +258,14 @@ where
pub(crate) fn white_space(s: Span) -> IResult<Span, WhiteSpace> {
if in_directive() {
alt((
map(multispace1, |x: Span| {
WhiteSpace::Space(Box::new(into_locate(x)))
}),
map(space, |x: Span| WhiteSpace::Space(Box::new(into_locate(x)))),
map(preceded(peek(char('/')), comment), |x| {
WhiteSpace::Comment(Box::new(x))
}),
))(s)
} else {
alt((
map(multispace1, |x: Span| {
WhiteSpace::Space(Box::new(into_locate(x)))
}),
map(space, |x: Span| WhiteSpace::Space(Box::new(into_locate(x)))),
map(preceded(peek(char('/')), comment), |x| {
WhiteSpace::Comment(Box::new(x))
}),
@ -280,6 +276,14 @@ pub(crate) fn white_space(s: Span) -> IResult<Span, WhiteSpace> {
}
}
pub(crate) fn space(s: Span) -> IResult<Span, Span> {
if lb_not_space() {
space1(s)
} else {
multispace1(s)
}
}
thread_local!(
static IN_DIRECTIVE: core::cell::RefCell<Vec<()>> = {
core::cell::RefCell::new(Vec::new())
@ -301,6 +305,27 @@ pub(crate) fn end_directive() {
IN_DIRECTIVE.with(|x| x.borrow_mut().pop());
}
thread_local!(
static LB_NOT_SPACE: core::cell::RefCell<Vec<()>> = {
core::cell::RefCell::new(Vec::new())
}
);
pub(crate) fn lb_not_space() -> bool {
LB_NOT_SPACE.with(|x| match x.borrow().last() {
Some(_) => true,
None => false,
})
}
pub(crate) fn begin_lb_not_space() {
LB_NOT_SPACE.with(|x| x.borrow_mut().push(()));
}
pub(crate) fn end_lb_not_space() {
LB_NOT_SPACE.with(|x| x.borrow_mut().pop());
}
// -----------------------------------------------------------------------------
#[derive(Clone, Copy)]

9
sv-parser-pp/Cargo.toml
View File

@ -4,10 +4,11 @@ version = "0.1.0"
authors = ["dalance <dalance@gmail.com>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[features]
default = []
trace = ["sv-parser-parser/trace"]
[dependencies]
nom = "5.0.0"
nom_locate = "1.0.0"
nom-tracable = "0.3.1"
str-concat = "0.1.4"
sv-parser-parser = { path = "../sv-parser-parser" }
sv-parser-syntaxtree = { path = "../sv-parser-syntaxtree" }

149
sv-parser-pp/src/lib.rs
View File

@ -1,7 +1,154 @@
use std::collections::HashMap;
use std::convert::TryInto;
use sv_parser_parser::{pp_parser, Span, SpanInfo};
use sv_parser_syntaxtree::{Locate, NodeEvent, RefNode};
pub fn preprocessor(s: &str) -> String {
let mut ret = String::new();
let pp_text = pp_parser(Span::new_extra(s, SpanInfo::default()));
let mut skip = false;
let mut skip_nodes = vec![];
let mut defines = HashMap::new();
if let Ok((_, pp_text)) = pp_text {
for n in pp_text.into_iter().event() {
match n {
NodeEvent::Enter(RefNode::ResetallCompilerDirective(_)) if !skip => {
defines.clear();
}
NodeEvent::Enter(RefNode::UndefineCompilerDirective(x)) if !skip => {
let (_, _, ref name) = x.nodes;
let id = identifier((&name.nodes.0).into());
let id = String::from(id.unwrap().str(s));
defines.remove(&id);
}
NodeEvent::Enter(RefNode::UndefineallCompilerDirective(_)) if !skip => {
defines.clear();
}
NodeEvent::Enter(RefNode::SourceDescriptionNotDirective(x)) if !skip => {
let locate: Locate = x.try_into().unwrap();
ret.push_str(locate.str(s));
}
NodeEvent::Enter(RefNode::IfdefDirective(x)) if !skip => {
let (_, _, ref ifid, ref ifbody, ref elsif, ref elsebody, _, _) = x.nodes;
let ifid = identifier(ifid.into());
let ifid = String::from(ifid.unwrap().str(s));
let mut hit = false;
if defines.contains_key(&ifid) {
hit = true;
} else {
skip_nodes.push(ifbody.into());
}
for x in elsif {
let (_, _, ref elsifid, ref elsifbody) = x;
let elsifid = identifier(elsifid.into());
let elsifid = String::from(elsifid.unwrap().str(s));
if hit {
skip_nodes.push(elsifbody.into());
} else if defines.contains_key(&elsifid) {
hit = true;
} else {
skip_nodes.push(elsifbody.into());
}
}
if let Some(elsebody) = elsebody {
let (_, _, ref elsebody) = elsebody;
if hit {
skip_nodes.push(elsebody.into());
}
}
}
NodeEvent::Enter(RefNode::IfndefDirective(x)) if !skip => {
let (_, _, ref ifid, ref ifbody, ref elsif, ref elsebody, _, _) = x.nodes;
let ifid = identifier(ifid.into());
let mut hit = false;
if !defines.contains_key(&String::from(ifid.unwrap().str(s))) {
hit = true;
} else {
skip_nodes.push(ifbody.into());
}
for x in elsif {
let (_, _, ref elsifid, ref elsifbody) = x;
let elsifid = identifier(elsifid.into());
if hit {
skip_nodes.push(elsifbody.into());
} else if defines.contains_key(&String::from(elsifid.unwrap().str(s))) {
hit = true;
} else {
skip_nodes.push(elsifbody.into());
}
}
if let Some(elsebody) = elsebody {
let (_, _, ref elsebody) = elsebody;
if hit {
skip_nodes.push(elsebody.into());
}
}
}
NodeEvent::Enter(RefNode::TextMacroDefinition(x)) if !skip => {
let (_, _, ref name, _) = x.nodes;
let id = identifier((&name.nodes.0).into());
let id = String::from(id.unwrap().str(s));
defines.insert(id, x.clone());
}
NodeEvent::Enter(x) => {
if skip_nodes.contains(&x) {
skip = true;
}
}
NodeEvent::Leave(x) => {
if skip_nodes.contains(&x) {
skip = false;
}
}
}
}
}
//let ret = dbg!(ret);
println!("{}", ret);
ret
}
fn identifier(node: RefNode) -> Option<Locate> {
for x in node {
match x {
RefNode::SimpleIdentifier(x) => {
let x: Locate = x.nodes.0.try_into().unwrap();
return Some(x);
}
RefNode::EscapedIdentifier(x) => {
let x: Locate = x.nodes.0.try_into().unwrap();
return Some(x);
}
_ => (),
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
let s = r##"module and_op (a, b, c);
output a;
input b, c;
`define behavioral
`ifdef behavioral
wire a = b & c;
`else
and a1 (a,b,c);
`endif
endmodule"##;
preprocessor(s);
}
}

4
sv-parser-syntaxtree/build.rs
View File

@ -11,12 +11,12 @@ fn main() {
let mut out = File::create(&dest).unwrap();
let mut ref_node = String::new();
ref_node = format!("{}#[derive(Debug, Clone, RefNode)]\n", ref_node);
ref_node = format!("{}#[derive(Clone, Debug, PartialEq, RefNode)]\n", ref_node);
ref_node = format!("{}pub enum RefNode<'a> {{\n", ref_node);
ref_node = format!("{} Locate(&'a Locate),\n", ref_node);
let mut any_node = String::new();
any_node = format!("{}#[derive(Debug, Clone, AnyNode)]\n", any_node);
any_node = format!("{}#[derive(Clone, Debug, PartialEq, AnyNode)]\n", any_node);
any_node = format!("{}pub enum AnyNode {{\n", any_node);
any_node = format!("{} Locate(Locate),\n", any_node);

64
sv-parser-syntaxtree/src/any_node.rs
View File

@ -5,14 +5,21 @@ use core::convert::TryFrom;
include!(concat!(env!("OUT_DIR"), "/any_node.rs"));
pub struct RefNodes<'a>(pub Vec<RefNode<'a>>);
// -----------------------------------------------------------------------------
pub struct RefNodes<'a>(pub Vec<RefNode<'a>>);
pub struct Iter<'a> {
pub(crate) next: RefNodes<'a>,
}
impl<'a> Iter<'a> {
pub fn event(self) -> EventIter<'a> {
let next: NodeEvents = self.next.into();
EventIter { next }
}
}
impl<'a> Iterator for Iter<'a> {
type Item = RefNode<'a>;
@ -29,6 +36,59 @@ impl<'a> Iterator for Iter<'a> {
// -----------------------------------------------------------------------------
#[derive(Debug, Clone)]
pub enum NodeEvent<'a> {
Enter(RefNode<'a>),
Leave(RefNode<'a>),
}
pub struct NodeEvents<'a>(pub Vec<NodeEvent<'a>>);
pub struct EventIter<'a> {
pub(crate) next: NodeEvents<'a>,
}
impl<'a> Iterator for EventIter<'a> {
type Item = NodeEvent<'a>;
fn next(&mut self) -> Option<Self::Item> {
let ret = self.next.0.pop();
if let Some(x) = ret.clone() {
if let NodeEvent::Enter(x) = x {
self.next.0.push(NodeEvent::Leave(x.clone()));
let mut x: NodeEvents = x.next().into();
x.0.reverse();
self.next.0.append(&mut x.0);
}
}
ret
}
}
// -----------------------------------------------------------------------------
impl<'a> From<Iter<'a>> for EventIter<'a> {
fn from(x: Iter<'a>) -> Self {
let mut ret = Vec::new();
for x in x.next.0 {
ret.push(NodeEvent::Enter(x));
}
EventIter {
next: NodeEvents(ret),
}
}
}
impl<'a> From<RefNodes<'a>> for NodeEvents<'a> {
fn from(x: RefNodes<'a>) -> Self {
let mut ret = Vec::new();
for x in x.0 {
ret.push(NodeEvent::Enter(x));
}
NodeEvents(ret)
}
}
impl<'a> From<Vec<RefNode<'a>>> for RefNodes<'a> {
fn from(x: Vec<RefNode<'a>>) -> Self {
RefNodes(x)

26
sv-parser-syntaxtree/src/behavioral_statements/assertion_statements.rs
View File

@ -2,13 +2,13 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum AssertionItem {
Concurrent(Box<ConcurrentAssertionItem>),
Immediate(Box<DeferredImmediateAssetionItem>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DeferredImmediateAssetionItem {
pub nodes: (
Option<(BlockIdentifier, Symbol)>,
@ -16,64 +16,64 @@ pub struct DeferredImmediateAssetionItem {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ProceduralAssertionStatement {
Concurrent(Box<ConcurrentAssertionStatement>),
Immediate(Box<ImmediateAssetionStatement>),
Checker(Box<CheckerInstantiation>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ImmediateAssetionStatement {
Simple(Box<SimpleImmediateAssertionStatement>),
Deferred(Box<DeferredImmediateAssertionStatement>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SimpleImmediateAssertionStatement {
Assert(Box<SimpleImmediateAssertStatement>),
Assume(Box<SimpleImmediateAssumeStatement>),
Cover(Box<SimpleImmediateCoverStatement>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SimpleImmediateAssertStatement {
pub nodes: (Keyword, Paren<Expression>, ActionBlock),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SimpleImmediateAssumeStatement {
pub nodes: (Keyword, Paren<Expression>, ActionBlock),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SimpleImmediateCoverStatement {
pub nodes: (Keyword, Paren<Expression>, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DeferredImmediateAssertionStatement {
Assert(Box<DeferredImmediateAssertStatement>),
Assume(Box<DeferredImmediateAssumeStatement>),
Cover(Box<DeferredImmediateCoverStatement>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DeferredImmediateAssertStatement {
pub nodes: (Keyword, AssertTiming, Paren<Expression>, ActionBlock),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DeferredImmediateAssumeStatement {
pub nodes: (Keyword, AssertTiming, Paren<Expression>, ActionBlock),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DeferredImmediateCoverStatement {
pub nodes: (Keyword, AssertTiming, Paren<Expression>, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum AssertTiming {
Zero(Box<Symbol>),
Final(Box<Keyword>),

36
sv-parser-syntaxtree/src/behavioral_statements/case_statements.rs
View File

@ -2,14 +2,14 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CaseStatement {
Normal(Box<CaseStatementNormal>),
Matches(Box<CaseStatementMatches>),
Inside(Box<CaseStatementInside>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseStatementNormal {
pub nodes: (
Option<UniquePriority>,
@ -21,7 +21,7 @@ pub struct CaseStatementNormal {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseStatementMatches {
pub nodes: (
Option<UniquePriority>,
@ -34,7 +34,7 @@ pub struct CaseStatementMatches {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseStatementInside {
pub nodes: (
Option<UniquePriority>,
@ -47,41 +47,41 @@ pub struct CaseStatementInside {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CaseKeyword {
Case(Box<Keyword>),
Casez(Box<Keyword>),
Casex(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseExpression {
pub nodes: (Expression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CaseItem {
NonDefault(Box<CaseItemNondefault>),
Default(Box<CaseItemDefault>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseItemNondefault {
pub nodes: (List<Symbol, CaseItemExpression>, Symbol, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseItemDefault {
pub nodes: (Keyword, Option<Symbol>, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CasePatternItem {
NonDefault(Box<CasePatternItemNondefault>),
Default(Box<CaseItemDefault>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CasePatternItemNondefault {
pub nodes: (
Pattern,
@ -91,38 +91,38 @@ pub struct CasePatternItemNondefault {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CaseInsideItem {
NonDefault(Box<CaseInsideItemNondefault>),
Default(Box<CaseItemDefault>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseInsideItemNondefault {
pub nodes: (OpenRangeList, Symbol, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseItemExpression {
pub nodes: (Expression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RandcaseStatement {
pub nodes: (Keyword, RandcaseItem, Vec<RandcaseItem>, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RandcaseItem {
pub nodes: (Expression, Symbol, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OpenRangeList {
pub nodes: (List<Symbol, OpenValueRange>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OpenValueRange {
pub nodes: (ValueRange,),
}

60
sv-parser-syntaxtree/src/behavioral_statements/clocking_block.rs
View File

@ -2,13 +2,13 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClockingDeclaration {
Local(Box<ClockingDeclarationLocal>),
Global(Box<ClockingDeclarationGlobal>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingDeclarationLocal {
pub nodes: (
Option<Default>,
@ -22,12 +22,12 @@ pub struct ClockingDeclarationLocal {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Default {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingDeclarationGlobal {
pub nodes: (
Keyword,
@ -40,67 +40,67 @@ pub struct ClockingDeclarationGlobal {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClockingEvent {
Identifier(Box<ClockingEventIdentifier>),
Expression(Box<ClockingEventExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingEventIdentifier {
pub nodes: (Symbol, Identifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingEventExpression {
pub nodes: (Symbol, Paren<EventExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClockingItem {
Default(Box<ClockingItemDefault>),
Direction(Box<ClockingItemDirection>),
Assertion(Box<ClockingItemAssertion>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingItemDefault {
pub nodes: (Keyword, DefaultSkew, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingItemDirection {
pub nodes: (ClockingDirection, ListOfClockingDeclAssign, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingItemAssertion {
pub nodes: (Vec<AttributeInstance>, AssertionItemDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DefaultSkew {
Input(Box<DefaultSkewInput>),
Output(Box<DefaultSkewOutput>),
InputOutput(Box<DefaultSkewInputOutput>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DefaultSkewInput {
pub nodes: (Keyword, ClockingSkew),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DefaultSkewOutput {
pub nodes: (Keyword, ClockingSkew),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DefaultSkewInputOutput {
pub nodes: (Keyword, ClockingSkew, Keyword, ClockingSkew),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClockingDirection {
Input(Box<ClockingDirectionInput>),
Output(Box<ClockingDirectionOutput>),
@ -108,75 +108,75 @@ pub enum ClockingDirection {
Inout(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingDirectionInput {
pub nodes: (Keyword, Option<ClockingSkew>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingDirectionOutput {
pub nodes: (Keyword, Option<ClockingSkew>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingDirectionInputOutput {
pub nodes: (Keyword, Option<ClockingSkew>, Keyword, Option<ClockingSkew>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfClockingDeclAssign {
pub nodes: (List<Symbol, ClockingDeclAssign>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingDeclAssign {
pub nodes: (SignalIdentifier, Option<(Symbol, Expression)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClockingSkew {
Edge(Box<ClockingSkewEdge>),
DelayControl(Box<DelayControl>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingSkewEdge {
pub nodes: (EdgeIdentifier, Option<DelayControl>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingDrive {
pub nodes: (ClockvarExpression, Symbol, Option<CycleDelay>, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CycleDelay {
Integral(Box<CycleDelayIntegral>),
Identifier(Box<CycleDelayIdentifier>),
Expression(Box<CycleDelayExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayIntegral {
pub nodes: (Symbol, IntegralNumber),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayIdentifier {
pub nodes: (Symbol, Identifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayExpression {
pub nodes: (Symbol, Paren<Expression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Clockvar {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockvarExpression {
pub nodes: (Clockvar, Select),
}

10
sv-parser-syntaxtree/src/behavioral_statements/conditional_statements.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConditionalStatement {
pub nodes: (
Option<UniquePriority>,
@ -14,25 +14,25 @@ pub struct ConditionalStatement {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum UniquePriority {
Unique(Box<Keyword>),
Unique0(Box<Keyword>),
Priority(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CondPredicate {
pub nodes: (List<Symbol, ExpressionOrCondPattern>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ExpressionOrCondPattern {
Expression(Box<Expression>),
CondPattern(Box<CondPattern>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CondPattern {
pub nodes: (Expression, Keyword, Pattern),
}

14
sv-parser-syntaxtree/src/behavioral_statements/continuous_assignment_and_net_alias_statements.rs
View File

@ -2,13 +2,13 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ContinuousAssign {
Net(Box<ContinuousAssignNet>),
Variable(Box<ContinuousAssignVariable>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ContinuousAssignNet {
pub nodes: (
Keyword,
@ -19,7 +19,7 @@ pub struct ContinuousAssignNet {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ContinuousAssignVariable {
pub nodes: (
Keyword,
@ -29,22 +29,22 @@ pub struct ContinuousAssignVariable {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfNetAssignments {
pub nodes: (List<Symbol, NetAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfVariableAssignments {
pub nodes: (List<Symbol, VariableAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetAlias {
pub nodes: (Keyword, NetLvalue, Symbol, List<Symbol, NetLvalue>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetAssignment {
pub nodes: (NetLvalue, Symbol, Expression),
}

28
sv-parser-syntaxtree/src/behavioral_statements/looping_statements.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum LoopStatement {
Forever(Box<LoopStatementForever>),
Repeat(Box<LoopStatementRepeat>),
@ -12,22 +12,22 @@ pub enum LoopStatement {
Foreach(Box<LoopStatementForeach>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LoopStatementForever {
pub nodes: (Keyword, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LoopStatementRepeat {
pub nodes: (Keyword, Paren<Expression>, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LoopStatementWhile {
pub nodes: (Keyword, Paren<Expression>, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LoopStatementFor {
pub nodes: (
Keyword,
@ -42,12 +42,12 @@ pub struct LoopStatementFor {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LoopStatementDoWhile {
pub nodes: (Keyword, StatementOrNull, Keyword, Paren<Expression>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LoopStatementForeach {
pub nodes: (
Keyword,
@ -56,18 +56,18 @@ pub struct LoopStatementForeach {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ForInitialization {
ListOfVariableAssignments(Box<ListOfVariableAssignments>),
Declaration(Box<ForInitializationDeclaration>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ForInitializationDeclaration {
pub nodes: (List<Symbol, ForVariableDeclaration>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ForVariableDeclaration {
pub nodes: (
Option<Var>,
@ -76,24 +76,24 @@ pub struct ForVariableDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Var {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ForStep {
pub nodes: (List<Symbol, ForStepAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ForStepAssignment {
OperatorAssignment(Box<OperatorAssignment>),
IncOrDecExpression(Box<IncOrDecExpression>),
FunctionSubroutineCall(Box<FunctionSubroutineCall>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LoopVariables {
pub nodes: (List<Symbol, Option<IndexVariableIdentifier>>,),
}

10
sv-parser-syntaxtree/src/behavioral_statements/parallel_and_sequential_blocks.rs
View File

@ -2,18 +2,18 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ActionBlock {
StatementOrNull(Box<StatementOrNull>),
Else(Box<ActionBlockElse>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ActionBlockElse {
pub nodes: (Option<Statement>, Keyword, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SeqBlock {
pub nodes: (
Keyword,
@ -25,7 +25,7 @@ pub struct SeqBlock {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParBlock {
pub nodes: (
Keyword,
@ -37,7 +37,7 @@ pub struct ParBlock {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum JoinKeyword {
Join(Box<Keyword>),
JoinAny(Box<Keyword>),

36
sv-parser-syntaxtree/src/behavioral_statements/patterns.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Pattern {
Variable(Box<PatternVariable>),
Asterisk(Box<Symbol>),
@ -12,27 +12,27 @@ pub enum Pattern {
IdentifierList(Box<PatternIdentifierList>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PatternVariable {
pub nodes: (Symbol, VariableIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PatternTagged {
pub nodes: (Keyword, MemberIdentifier, Option<Pattern>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PatternList {
pub nodes: (ApostropheBrace<List<Symbol, Pattern>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PatternIdentifierList {
pub nodes: (ApostropheBrace<List<Symbol, (MemberIdentifier, Symbol, Pattern)>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum AssignmentPattern {
List(Box<AssignmentPatternList>),
Structure(Box<AssignmentPatternStructure>),
@ -40,50 +40,50 @@ pub enum AssignmentPattern {
Repeat(Box<AssignmentPatternRepeat>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssignmentPatternList {
pub nodes: (ApostropheBrace<List<Symbol, Expression>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssignmentPatternStructure {
pub nodes: (ApostropheBrace<List<Symbol, (StructurePatternKey, Symbol, Expression)>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssignmentPatternArray {
pub nodes: (ApostropheBrace<List<Symbol, (ArrayPatternKey, Symbol, Expression)>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssignmentPatternRepeat {
pub nodes: (ApostropheBrace<(ConstantExpression, Brace<List<Symbol, Expression>>)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum StructurePatternKey {
MemberIdentifier(Box<MemberIdentifier>),
AssignmentPatternKey(Box<AssignmentPatternKey>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ArrayPatternKey {
ConstantExpression(Box<ConstantExpression>),
AssignmentPatternKey(Box<AssignmentPatternKey>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum AssignmentPatternKey {
SimpleType(Box<SimpleType>),
Default(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssignmentPatternExpression {
pub nodes: (Option<AssignmentPatternExpressionType>, AssignmentPattern),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum AssignmentPatternExpressionType {
PsTypeIdentifier(Box<PsTypeIdentifier>),
PsParameterIdentifier(Box<PsParameterIdentifier>),
@ -91,17 +91,17 @@ pub enum AssignmentPatternExpressionType {
TypeReference(Box<TypeReference>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantAssignmentPatternExpression {
pub nodes: (AssignmentPatternExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssignmentPatternNetLvalue {
pub nodes: (ApostropheBrace<List<Symbol, NetLvalue>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssignmentPatternVariableLvalue {
pub nodes: (ApostropheBrace<List<Symbol, VariableLvalue>>,),
}

38
sv-parser-syntaxtree/src/behavioral_statements/procedural_blocks_and_assignments.rs
View File

@ -2,17 +2,17 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InitialConstruct {
pub nodes: (Keyword, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AlwaysConstruct {
pub nodes: (AlwaysKeyword, Statement),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum AlwaysKeyword {
Always(Box<Keyword>),
AlwaysComb(Box<Keyword>),
@ -20,12 +20,12 @@ pub enum AlwaysKeyword {
AlwaysFf(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FinalConstruct {
pub nodes: (Keyword, FunctionStatement),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BlockingAssignment {
Variable(Box<BlockingAssignmentVariable>),
NonrangeVariable(Box<BlockingAssignmentNonrangeVariable>),
@ -33,17 +33,17 @@ pub enum BlockingAssignment {
OperatorAssignment(Box<OperatorAssignment>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockingAssignmentVariable {
pub nodes: (VariableLvalue, Symbol, DelayOrEventControl, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockingAssignmentNonrangeVariable {
pub nodes: (NonrangeVariableLvalue, Symbol, DynamicArrayNew),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockingAssignmentHierarchicalVariable {
pub nodes: (
Option<ImplicitClassHandleOrClassScopeOrPackageScope>,
@ -54,17 +54,17 @@ pub struct BlockingAssignmentHierarchicalVariable {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OperatorAssignment {
pub nodes: (VariableLvalue, AssignmentOperator, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssignmentOperator {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonblockingAssignment {
pub nodes: (
VariableLvalue,
@ -74,7 +74,7 @@ pub struct NonblockingAssignment {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ProceduralContinuousAssignment {
Assign(Box<ProceduralContinuousAssignmentAssign>),
Deassign(Box<ProceduralContinuousAssignmentDeassign>),
@ -84,37 +84,37 @@ pub enum ProceduralContinuousAssignment {
ReleaseNet(Box<ProceduralContinuousAssignmentReleaseNet>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProceduralContinuousAssignmentAssign {
pub nodes: (Keyword, VariableAssignment),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProceduralContinuousAssignmentDeassign {
pub nodes: (Keyword, VariableLvalue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProceduralContinuousAssignmentForceVariable {
pub nodes: (Keyword, VariableAssignment),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProceduralContinuousAssignmentForceNet {
pub nodes: (Keyword, NetAssignment),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProceduralContinuousAssignmentReleaseVariable {
pub nodes: (Keyword, VariableLvalue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProceduralContinuousAssignmentReleaseNet {
pub nodes: (Keyword, NetLvalue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableAssignment {
pub nodes: (VariableLvalue, Symbol, Expression),
}

34
sv-parser-syntaxtree/src/behavioral_statements/randsequence.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RandsequenceStatement {
pub nodes: (
Keyword,
@ -13,7 +13,7 @@ pub struct RandsequenceStatement {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Production {
pub nodes: (
Option<DataTypeOrVoid>,
@ -25,7 +25,7 @@ pub struct Production {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RsRule {
pub nodes: (
RsProductionList,
@ -33,18 +33,18 @@ pub struct RsRule {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum RsProductionList {
Prod(Box<RsProductionListProd>),
Join(Box<RsProductionListJoin>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RsProductionListProd {
pub nodes: (RsProd, Vec<RsProd>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RsProductionListJoin {
pub nodes: (
Keyword,
@ -56,24 +56,24 @@ pub struct RsProductionListJoin {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum WeightSpecification {
IntegralNumber(Box<IntegralNumber>),
PsIdentifier(Box<PsIdentifier>),
Expression(Box<WeightSpecificationExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct WeightSpecificationExpression {
pub nodes: (Paren<Expression>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RsCodeBlock {
pub nodes: (Brace<(Vec<DataDeclaration>, Vec<StatementOrNull>)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum RsProd {
ProductionItem(Box<ProductionItem>),
RsCodeBlock(Box<RsCodeBlock>),
@ -82,12 +82,12 @@ pub enum RsProd {
RsCase(Box<RsCase>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProductionItem {
pub nodes: (ProductionIdentifier, Option<Paren<ListOfArguments>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RsIfElse {
pub nodes: (
Keyword,
@ -97,12 +97,12 @@ pub struct RsIfElse {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RsRepeat {
pub nodes: (Keyword, Paren<Expression>, ProductionItem),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RsCase {
pub nodes: (
Keyword,
@ -113,13 +113,13 @@ pub struct RsCase {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum RsCaseItem {
NonDefault(Box<RsCaseItemNondefault>),
Default(Box<RsCaseItemDefault>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RsCaseItemNondefault {
pub nodes: (
List<Symbol, CaseItemExpression>,
@ -129,7 +129,7 @@ pub struct RsCaseItemNondefault {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RsCaseItemDefault {
pub nodes: (Keyword, Option<Symbol>, ProductionItem, Symbol),
}

16
sv-parser-syntaxtree/src/behavioral_statements/statements.rs
View File

@ -2,18 +2,18 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum StatementOrNull {
Statement(Box<Statement>),
Attribute(Box<StatementOrNullAttribute>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StatementOrNullAttribute {
pub nodes: (Vec<AttributeInstance>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Statement {
pub nodes: (
Option<(BlockIdentifier, Symbol)>,
@ -22,7 +22,7 @@ pub struct Statement {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum StatementItem {
BlockingAssignment(Box<(BlockingAssignment, Symbol)>),
NonblockingAssignment(Box<(NonblockingAssignment, Symbol)>),
@ -46,23 +46,23 @@ pub enum StatementItem {
ExpectPropertyStatement(Box<ExpectPropertyStatement>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionStatement {
pub nodes: (Statement,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum FunctionStatementOrNull {
Statement(Box<FunctionStatement>),
Attribute(Box<FunctionStatementOrNullAttribute>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionStatementOrNullAttribute {
pub nodes: (Vec<AttributeInstance>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableIdentifierList {
pub nodes: (List<Symbol, VariableIdentifier>,),
}

4
sv-parser-syntaxtree/src/behavioral_statements/subroutine_call_statements.rs
View File

@ -2,13 +2,13 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SubroutineCallStatement {
SubroutineCall(Box<(SubroutineCall, Symbol)>),
Function(Box<SubroutineCallStatementFunction>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SubroutineCallStatementFunction {
pub nodes: (Keyword, Symbol, Paren<FunctionSubroutineCall>, Symbol),
}

68
sv-parser-syntaxtree/src/behavioral_statements/timing_control_statements.rs
View File

@ -2,40 +2,40 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProceduralTimingControlStatement {
pub nodes: (ProceduralTimingControl, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DelayOrEventControl {
Delay(Box<DelayControl>),
Event(Box<EventControl>),
Repeat(Box<DelayOrEventControlRepeat>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DelayOrEventControlRepeat {
pub nodes: (Keyword, Paren<Expression>, EventControl),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DelayControl {
Delay(Box<DelayControlDelay>),
Mintypmax(Box<DelayControlMintypmax>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DelayControlDelay {
pub nodes: (Symbol, DelayValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DelayControlMintypmax {
pub nodes: (Symbol, Paren<MintypmaxExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum EventControl {
EventIdentifier(Box<EventControlEventIdentifier>),
EventExpression(Box<EventControlEventExpression>),
@ -44,32 +44,32 @@ pub enum EventControl {
SequenceIdentifier(Box<EventControlSequenceIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventControlEventIdentifier {
pub nodes: (Symbol, HierarchicalEventIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventControlEventExpression {
pub nodes: (Symbol, Paren<EventExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventControlAsterisk {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventControlParenAsterisk {
pub nodes: (Symbol, Paren<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventControlSequenceIdentifier {
pub nodes: (Symbol, PsOrHierarchicalSequenceIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum EventExpression {
Expression(Box<EventExpressionExpression>),
Sequence(Box<EventExpressionSequence>),
@ -78,7 +78,7 @@ pub enum EventExpression {
Paren(Box<EventExpressionParen>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventExpressionExpression {
pub nodes: (
Option<EdgeIdentifier>,
@ -87,73 +87,73 @@ pub struct EventExpressionExpression {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventExpressionSequence {
pub nodes: (SequenceInstance, Option<(Keyword, Expression)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventExpressionOr {
pub nodes: (EventExpression, Keyword, EventExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventExpressionComma {
pub nodes: (EventExpression, Symbol, EventExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventExpressionParen {
pub nodes: (Paren<EventExpression>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ProceduralTimingControl {
DelayControl(Box<DelayControl>),
EventControl(Box<EventControl>),
CycleDelay(Box<CycleDelay>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum JumpStatement {
Return(Box<JumpStatementReturn>),
Break(Box<JumpStatementBreak>),
Continue(Box<JumpStatementContinue>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct JumpStatementReturn {
pub nodes: (Keyword, Option<Expression>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct JumpStatementBreak {
pub nodes: (Keyword, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct JumpStatementContinue {
pub nodes: (Keyword, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum WaitStatement {
Wait(Box<WaitStatementWait>),
Fork(Box<WaitStatementFork>),
Order(Box<WaitStatementOrder>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct WaitStatementWait {
pub nodes: (Keyword, Paren<Expression>, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct WaitStatementFork {
pub nodes: (Keyword, Keyword, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct WaitStatementOrder {
pub nodes: (
Keyword,
@ -162,18 +162,18 @@ pub struct WaitStatementOrder {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum EventTrigger {
Named(Box<EventTriggerNamed>),
Nonblocking(Box<EventTriggerNonblocking>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventTriggerNamed {
pub nodes: (Symbol, HierarchicalEventIdentifier, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventTriggerNonblocking {
pub nodes: (
Symbol,
@ -183,24 +183,24 @@ pub struct EventTriggerNonblocking {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DisableStatement {
Task(Box<DisableStatementTask>),
Block(Box<DisableStatementBlock>),
Fork(Box<DisableStatementFork>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DisableStatementTask {
pub nodes: (Keyword, HierarchicalTaskIdentifier, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DisableStatementBlock {
pub nodes: (Keyword, HierarchicalBlockIdentifier, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DisableStatementFork {
pub nodes: (Keyword, Keyword, Symbol),
}

170
sv-parser-syntaxtree/src/declarations/assertion_declarations.rs
View File

@ -2,13 +2,13 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConcurrentAssertionItem {
Statement(Box<ConcurrentAssertionItemStatement>),
CheckerInstantiation(Box<CheckerInstantiation>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConcurrentAssertionItemStatement {
pub nodes: (
Option<(BlockIdentifier, Symbol)>,
@ -16,7 +16,7 @@ pub struct ConcurrentAssertionItemStatement {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConcurrentAssertionStatement {
AssertPropertyStatement(Box<AssertPropertyStatement>),
AssumePropertyStatement(Box<AssumePropertyStatement>),
@ -25,27 +25,27 @@ pub enum ConcurrentAssertionStatement {
RestrictPropertyStatement(Box<RestrictPropertyStatement>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssertPropertyStatement {
pub nodes: (Keyword, Keyword, Paren<PropertySpec>, ActionBlock),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssumePropertyStatement {
pub nodes: (Keyword, Keyword, Paren<PropertySpec>, ActionBlock),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverPropertyStatement {
pub nodes: (Keyword, Keyword, Paren<PropertySpec>, StatementOrNull),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ExpectPropertyStatement {
pub nodes: (Keyword, Paren<PropertySpec>, ActionBlock),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverSequenceStatement {
pub nodes: (
Keyword,
@ -59,12 +59,12 @@ pub struct CoverSequenceStatement {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RestrictPropertyStatement {
pub nodes: (Keyword, Keyword, Paren<PropertySpec>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyInstance {
pub nodes: (
PsOrHierarchicalPropertyIdentifier,
@ -72,13 +72,13 @@ pub struct PropertyInstance {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyListOfArguments {
Ordered(Box<PropertyListOfArgumentsOrdered>),
Named(Box<PropertyListOfArgumentsNamed>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyListOfArgumentsOrdered {
pub nodes: (
List<Symbol, Option<PropertyActualArg>>,
@ -86,25 +86,25 @@ pub struct PropertyListOfArgumentsOrdered {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyListOfArgumentsNamed {
pub nodes: (List<Symbol, (Symbol, Identifier, Paren<Option<PropertyActualArg>>)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyActualArg {
PropertyExpr(Box<PropertyExpr>),
SequenceActualArg(Box<SequenceActualArg>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum AssertionItemDeclaration {
PropertyDeclaration(Box<PropertyDeclaration>),
SequenceDeclaration(Box<SequenceDeclaration>),
LetDeclaration(Box<LetDeclaration>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyDeclaration {
pub nodes: (
Keyword,
@ -119,12 +119,12 @@ pub struct PropertyDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyPortList {
pub nodes: (List<Symbol, PropertyPortItem>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyPortItem {
pub nodes: (
Vec<AttributeInstance>,
@ -136,18 +136,18 @@ pub struct PropertyPortItem {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyLvarPortDirection {
Input(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyFormalType {
SequenceFormalType(Box<SequenceFormalType>),
Property(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertySpec {
pub nodes: (
Option<ClockingEvent>,
@ -156,7 +156,7 @@ pub struct PropertySpec {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyExpr {
SequenceExpr(Box<SequenceExpr>),
Strong(Box<PropertyExprStrong>),
@ -181,37 +181,37 @@ pub enum PropertyExpr {
ClockingEvent(Box<PropertyExprClockingEvent>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprStrong {
pub nodes: (Keyword, Paren<SequenceExpr>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprWeak {
pub nodes: (Keyword, Paren<SequenceExpr>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprParen {
pub nodes: (Paren<PropertyExpr>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprNot {
pub nodes: (Keyword, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprBinaryProperty {
pub nodes: (PropertyExpr, Keyword, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprBinarySequence {
pub nodes: (SequenceExpr, Symbol, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprIf {
pub nodes: (
Keyword,
@ -221,7 +221,7 @@ pub struct PropertyExprIf {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprCase {
pub nodes: (
Keyword,
@ -232,17 +232,17 @@ pub struct PropertyExprCase {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprNexttime {
pub nodes: (Keyword, Option<Bracket<ConstantExpression>>, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprSNexttime {
pub nodes: (Keyword, Option<Bracket<ConstantExpression>>, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprAlways {
pub nodes: (
Keyword,
@ -251,7 +251,7 @@ pub struct PropertyExprAlways {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprSAlways {
pub nodes: (
Keyword,
@ -260,12 +260,12 @@ pub struct PropertyExprSAlways {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprEventually {
pub nodes: (Keyword, Bracket<ConstantRange>, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprSEventually {
pub nodes: (
Keyword,
@ -274,48 +274,48 @@ pub struct PropertyExprSEventually {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprAcceptOn {
pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprRejectOn {
pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprSyncAcceptOn {
pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprSyncRejectOn {
pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyExprClockingEvent {
pub nodes: (ClockingEvent, PropertyExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyCaseItem {
Nondefault(Box<PropertyCaseItemNondefault>),
Default(Box<PropertyCaseItemDefault>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyCaseItemNondefault {
pub nodes: (List<Symbol, ExpressionOrDist>, Symbol, PropertyExpr, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyCaseItemDefault {
pub nodes: (Keyword, Option<Symbol>, PropertyExpr, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceDeclaration {
pub nodes: (
Keyword,
@ -330,12 +330,12 @@ pub struct SequenceDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequencePortList {
pub nodes: (List<Symbol, SequencePortItem>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequencePortItem {
pub nodes: (
Vec<AttributeInstance>,
@ -347,21 +347,21 @@ pub struct SequencePortItem {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceLvarPortDirection {
Input(Box<Keyword>),
Inout(Box<Keyword>),
Output(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceFormalType {
DataTypeOrImplicit(Box<DataTypeOrImplicit>),
Sequence(Box<Keyword>),
Untyped(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceExpr {
CycleDelayExpr(Box<SequenceExprCycleDelayExpr>),
ExprCycleDelayExpr(Box<SequenceExprExprCycleDelayExpr>),
@ -374,7 +374,7 @@ pub enum SequenceExpr {
ClockingEvent(Box<SequenceExprClockingEvent>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprCycleDelayExpr {
pub nodes: (
CycleDelayRange,
@ -383,7 +383,7 @@ pub struct SequenceExprCycleDelayExpr {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprExprCycleDelayExpr {
pub nodes: (
SequenceExpr,
@ -393,17 +393,17 @@ pub struct SequenceExprExprCycleDelayExpr {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprExpression {
pub nodes: (ExpressionOrDist, Option<BooleanAbbrev>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprInstance {
pub nodes: (SequenceInstance, Option<SequenceAbbrev>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprParen {
pub nodes: (
Paren<(SequenceExpr, Vec<(Symbol, SequenceMatchItem)>)>,
@ -411,12 +411,12 @@ pub struct SequenceExprParen {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprBinary {
pub nodes: (SequenceExpr, Keyword, SequenceExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprFirstMatch {
pub nodes: (
Keyword,
@ -424,17 +424,17 @@ pub struct SequenceExprFirstMatch {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprThroughout {
pub nodes: (ExpressionOrDist, Keyword, SequenceExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceExprClockingEvent {
pub nodes: (ClockingEvent, SequenceExpr),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CycleDelayRange {
Primary(Box<CycleDelayRangePrimary>),
Expression(Box<CycleDelayRangeExpression>),
@ -442,39 +442,39 @@ pub enum CycleDelayRange {
Plus(Box<CycleDelayRangePlus>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayRangePrimary {
pub nodes: (Symbol, ConstantPrimary),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayRangeExpression {
pub nodes: (Symbol, Bracket<CycleDelayConstRangeExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayRangeAsterisk {
pub nodes: (Symbol, Bracket<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayRangePlus {
pub nodes: (Symbol, Bracket<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceMethodCall {
pub nodes: (SequenceInstance, Symbol, MethodIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceMatchItem {
OperatorAssignment(Box<OperatorAssignment>),
IncOrDecExpression(Box<IncOrDecExpression>),
SubroutineCall(Box<SubroutineCall>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceInstance {
pub nodes: (
PsOrHierarchicalSequenceIdentifier,
@ -482,13 +482,13 @@ pub struct SequenceInstance {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceListOfArguments {
Ordered(Box<SequenceListOfArgumentsOrdered>),
Named(Box<SequenceListOfArgumentsNamed>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceListOfArgumentsOrdered {
pub nodes: (
List<Symbol, Option<SequenceActualArg>>,
@ -496,89 +496,89 @@ pub struct SequenceListOfArgumentsOrdered {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceListOfArgumentsNamed {
pub nodes: (List<Symbol, (Symbol, Identifier, Paren<Option<SequenceActualArg>>)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SequenceActualArg {
EventExpression(Box<EventExpression>),
SequenceExpr(Box<SequenceExpr>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BooleanAbbrev {
ConsecutiveRepetition(Box<ConsecutiveRepetition>),
NonConsecutiveRepetition(Box<NonConsecutiveRepetition>),
GotoRepetition(Box<GotoRepetition>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceAbbrev {
pub nodes: (ConsecutiveRepetition,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConsecutiveRepetition {
Expression(Box<ConsecutiveRepetitionExpression>),
Asterisk(Box<ConsecutiveRepetitionAsterisk>),
Plus(Box<ConsecutiveRepetitionPlus>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConsecutiveRepetitionExpression {
pub nodes: (Bracket<(Symbol, ConstOrRangeExpression)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConsecutiveRepetitionAsterisk {
pub nodes: (Bracket<Symbol>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConsecutiveRepetitionPlus {
pub nodes: (Bracket<Symbol>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonConsecutiveRepetition {
pub nodes: (Bracket<(Symbol, ConstOrRangeExpression)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GotoRepetition {
pub nodes: (Bracket<(Symbol, ConstOrRangeExpression)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstOrRangeExpression {
ConstantExpression(Box<ConstantExpression>),
CycleDelayConstRangeExpression(Box<CycleDelayConstRangeExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CycleDelayConstRangeExpression {
Binary(Box<CycleDelayConstRangeExpressionBinary>),
Dollar(Box<CycleDelayConstRangeExpressionDollar>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayConstRangeExpressionBinary {
pub nodes: (ConstantExpression, Symbol, ConstantExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CycleDelayConstRangeExpressionDollar {
pub nodes: (ConstantExpression, Symbol, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ExpressionOrDist {
pub nodes: (Expression, Option<(Keyword, Brace<DistList>)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssertionVariableDeclaration {
pub nodes: (VarDataType, ListOfVariableDeclAssignments, Symbol),
}

10
sv-parser-syntaxtree/src/declarations/block_item_declarations.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BlockItemDeclaration {
Data(Box<BlockItemDeclarationData>),
LocalParameter(Box<BlockItemDeclarationLocalParameter>),
@ -10,22 +10,22 @@ pub enum BlockItemDeclaration {
Let(Box<BlockItemDeclarationLet>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockItemDeclarationData {
pub nodes: (Vec<AttributeInstance>, DataDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockItemDeclarationLocalParameter {
pub nodes: (Vec<AttributeInstance>, LocalParameterDeclaration, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockItemDeclarationParameter {
pub nodes: (Vec<AttributeInstance>, ParameterDeclaration, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockItemDeclarationLet {
pub nodes: (Vec<AttributeInstance>, LetDeclaration),
}

134
sv-parser-syntaxtree/src/declarations/covergroup_declarations.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CovergroupDeclaration {
pub nodes: (
Keyword,
@ -16,34 +16,34 @@ pub struct CovergroupDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CoverageSpecOrOption {
Spec(Box<CoverageSpecOrOptionSpec>),
Option(Box<CoverageSpecOrOptionOption>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageSpecOrOptionSpec {
pub nodes: (Vec<AttributeInstance>, CoverageSpec),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageSpecOrOptionOption {
pub nodes: (Vec<AttributeInstance>, CoverageOption, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CoverageOption {
Option(Box<CoverageOptionOption>),
TypeOption(Box<CoverageOptionTypeOption>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageOptionOption {
pub nodes: (Keyword, Symbol, MemberIdentifier, Symbol, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageOptionTypeOption {
pub nodes: (
Keyword,
@ -54,70 +54,70 @@ pub struct CoverageOptionTypeOption {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CoverageSpec {
CoverPoint(Box<CoverPoint>),
CoverCross(Box<CoverCross>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CoverageEvent {
ClockingEvent(Box<ClockingEvent>),
Sample(Box<CoverageEventSample>),
At(Box<CoverageEventAt>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageEventSample {
pub nodes: (Keyword, Keyword, Keyword, Paren<Option<TfPortList>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverageEventAt {
pub nodes: (Symbol, Paren<BlockEventExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BlockEventExpression {
Or(Box<BlockEventExpressionOr>),
Begin(Box<BlockEventExpressionBegin>),
End(Box<BlockEventExpressionEnd>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockEventExpressionOr {
pub nodes: (BlockEventExpression, Keyword, BlockEventExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockEventExpressionBegin {
pub nodes: (Keyword, HierarchicalBtfIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockEventExpressionEnd {
pub nodes: (Keyword, HierarchicalBtfIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum HierarchicalBtfIdentifier {
HierarchicalTfIdentifier(Box<HierarchicalTfIdentifier>),
HierarchicalBlockIdentifier(Box<HierarchicalBlockIdentifier>),
Method(Box<HierarchicalBtfIdentifierMethod>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalBtfIdentifierMethod {
pub nodes: (Option<HierarchicalIdentifierOrClassScope>, MethodIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum HierarchicalIdentifierOrClassScope {
HierarchicalIdentifier(Box<(HierarchicalIdentifier, Symbol)>),
ClassScope(Box<ClassScope>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverPoint {
pub nodes: (
Option<(Option<DataTypeOrImplicit>, CoverPointIdentifier, Symbol)>,
@ -128,18 +128,18 @@ pub struct CoverPoint {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BinsOrEmpty {
NonEmpty(Box<BinsOrEmptyNonEmpty>),
Empty(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrEmptyNonEmpty {
pub nodes: (Brace<(Vec<AttributeInstance>, Vec<(BinsOrOptions, Symbol)>)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BinsOrOptions {
CoverageOption(Box<CoverageOption>),
Covergroup(Box<BinsOrOptionsCovergroup>),
@ -150,7 +150,7 @@ pub enum BinsOrOptions {
DefaultSequence(Box<BinsOrOptionsDefaultSequence>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsCovergroup {
pub nodes: (
Option<Wildcard>,
@ -164,12 +164,12 @@ pub struct BinsOrOptionsCovergroup {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Wildcard {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsCoverPoint {
pub nodes: (
Option<Wildcard>,
@ -184,7 +184,7 @@ pub struct BinsOrOptionsCoverPoint {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsSetCovergroup {
pub nodes: (
Option<Wildcard>,
@ -197,7 +197,7 @@ pub struct BinsOrOptionsSetCovergroup {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsTransList {
pub nodes: (
Option<Wildcard>,
@ -210,7 +210,7 @@ pub struct BinsOrOptionsTransList {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsDefault {
pub nodes: (
BinsKeyword,
@ -222,7 +222,7 @@ pub struct BinsOrOptionsDefault {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsOrOptionsDefaultSequence {
pub nodes: (
BinsKeyword,
@ -234,24 +234,24 @@ pub struct BinsOrOptionsDefaultSequence {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BinsKeyword {
Bins(Box<Keyword>),
IllegalBins(Box<Keyword>),
IgnoreBins(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransList {
pub nodes: (List<Symbol, Paren<TransSet>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransSet {
pub nodes: (List<Symbol, TransRangeList>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TransRangeList {
TransItem(Box<TransItem>),
Asterisk(Box<TransRangeListAsterisk>),
@ -259,38 +259,38 @@ pub enum TransRangeList {
Equal(Box<TransRangeListEqual>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransRangeListAsterisk {
pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransRangeListArrow {
pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransRangeListEqual {
pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TransItem {
pub nodes: (CovergroupRangeList,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum RepeatRange {
CovergroupExpression(Box<CovergroupExpression>),
Binary(Box<RepeatRangeBinary>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RepeatRangeBinary {
pub nodes: (CovergroupExpression, Symbol, CovergroupExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverCross {
pub nodes: (
Option<(CrossIdentifier, Symbol)>,
@ -301,51 +301,51 @@ pub struct CoverCross {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfCrossItems {
pub nodes: (CrossItem, Symbol, List<Symbol, CrossItem>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CrossItem {
CoverPointIdentifier(Box<CoverPointIdentifier>),
VariableIdentifier(Box<VariableIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CrossBody {
NonEmpty(Box<CrossBodyNonEmpty>),
Empty(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CrossBodyNonEmpty {
pub nodes: (Brace<Vec<CrossBodyItem>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CrossBodyItem {
FunctionDeclaration(Box<FunctionDeclaration>),
BinsSelectionOrOption(Box<(BinsSelectionOrOption, Symbol)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BinsSelectionOrOption {
Coverage(Box<BinsSelectionOrOptionCoverage>),
Bins(Box<BinsSelectionOrOptionBins>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsSelectionOrOptionCoverage {
pub nodes: (Vec<AttributeInstance>, CoverageOption),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsSelectionOrOptionBins {
pub nodes: (Vec<AttributeInstance>, BinsSelection),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsSelection {
pub nodes: (
BinsKeyword,
@ -356,7 +356,7 @@ pub struct BinsSelection {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SelectExpression {
SelectCondition(Box<SelectCondition>),
Not(Box<SelectExpressionNot>),
@ -368,27 +368,27 @@ pub enum SelectExpression {
CrossSet(Box<SelectExpressionCrossSet>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionNot {
pub nodes: (Symbol, SelectCondition),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionAnd {
pub nodes: (SelectExpression, Symbol, SelectExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionOr {
pub nodes: (SelectExpression, Symbol, SelectExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionParen {
pub nodes: (Paren<SelectExpression>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionWith {
pub nodes: (
SelectExpression,
@ -398,7 +398,7 @@ pub struct SelectExpressionWith {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectExpressionCrossSet {
pub nodes: (
CrossSetExpression,
@ -406,7 +406,7 @@ pub struct SelectExpressionCrossSet {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SelectCondition {
pub nodes: (
Keyword,
@ -415,54 +415,54 @@ pub struct SelectCondition {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BinsExpression {
VariableIdentifier(Box<VariableIdentifier>),
CoverPoint(Box<BinsExpressionCoverPoint>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinsExpressionCoverPoint {
pub nodes: (CoverPointIdentifier, Option<(Symbol, BinIdentifier)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CovergroupRangeList {
pub nodes: (List<Symbol, CovergroupValueRange>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CovergroupValueRange {
CovergroupExpression(Box<CovergroupExpression>),
Binary(Box<CovergroupValueRangeBinary>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CovergroupValueRangeBinary {
pub nodes: (Bracket<(CovergroupExpression, Symbol, CovergroupExpression)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct WithCovergroupExpression {
pub nodes: (CovergroupExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SetCovergroupExpression {
pub nodes: (CovergroupExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IntegerCovergroupExpression {
pub nodes: (CovergroupExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CrossSetExpression {
pub nodes: (CovergroupExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CovergroupExpression {
pub nodes: (Expression,),
}

40
sv-parser-syntaxtree/src/declarations/declaration_assignments.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DefparamAssignment {
pub nodes: (
HierarchicalParameterIdentifier,
@ -11,7 +11,7 @@ pub struct DefparamAssignment {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetDeclAssignment {
pub nodes: (
NetIdentifier,
@ -20,7 +20,7 @@ pub struct NetDeclAssignment {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParamAssignment {
pub nodes: (
ParameterIdentifier,
@ -29,29 +29,29 @@ pub struct ParamAssignment {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SpecparamAssignment {
Mintypmax(Box<SpecparamAssignmentMintypmax>),
PulseControlSpecparam(Box<PulseControlSpecparam>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SpecparamAssignmentMintypmax {
pub nodes: (SpecparamIdentifier, Symbol, ConstantMintypmaxExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TypeAssignment {
pub nodes: (TypeIdentifier, Option<(Symbol, DataType)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PulseControlSpecparam {
WithoutDescriptor(Box<PulseControlSpecparamWithoutDescriptor>),
WithDescriptor(Box<PulseControlSpecparamWithDescriptor>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PulseControlSpecparamWithoutDescriptor {
pub nodes: (
Symbol,
@ -60,7 +60,7 @@ pub struct PulseControlSpecparamWithoutDescriptor {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PulseControlSpecparamWithDescriptor {
pub nodes: (
Symbol,
@ -72,29 +72,29 @@ pub struct PulseControlSpecparamWithDescriptor {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ErrorLimitValue {
pub nodes: (LimitValue,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RejectLimitValue {
pub nodes: (LimitValue,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LimitValue {
pub nodes: (ConstantMintypmaxExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum VariableDeclAssignment {
Variable(Box<VariableDeclAssignmentVariable>),
DynamicArray(Box<VariableDeclAssignmentDynamicArray>),
Class(Box<VariableDeclAssignmentClass>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableDeclAssignmentVariable {
pub nodes: (
VariableIdentifier,
@ -103,7 +103,7 @@ pub struct VariableDeclAssignmentVariable {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableDeclAssignmentDynamicArray {
pub nodes: (
DynamicArrayVariableIdentifier,
@ -113,28 +113,28 @@ pub struct VariableDeclAssignmentDynamicArray {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableDeclAssignmentClass {
pub nodes: (ClassVariableIdentifier, (Symbol, ClassNew)),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClassNew {
Argument(Box<ClassNewArgument>),
Expression(Box<ClassNewExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassNewArgument {
pub nodes: (Option<ClassScope>, Keyword, Option<Paren<ListOfArguments>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassNewExpression {
pub nodes: (Keyword, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DynamicArrayNew {
pub nodes: (Keyword, Bracket<Expression>, Option<Paren<Expression>>),
}

26
sv-parser-syntaxtree/src/declarations/declaration_lists.rs
View File

@ -2,47 +2,47 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfDefparamAssignments {
pub nodes: (List<Symbol, DefparamAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfGenvarIdentifiers {
pub nodes: (List<Symbol, GenvarIdentifier>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfInterfaceIdentifiers {
pub nodes: (List<Symbol, (InterfaceIdentifier, Vec<UnpackedDimension>)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfNetDeclAssignments {
pub nodes: (List<Symbol, NetDeclAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfParamAssignments {
pub nodes: (List<Symbol, ParamAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfPortIdentifiers {
pub nodes: (List<Symbol, (PortIdentifier, Vec<UnpackedDimension>)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfUdpPortIdentifiers {
pub nodes: (List<Symbol, PortIdentifier>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfSpecparamAssignments {
pub nodes: (List<Symbol, SpecparamAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfTfVariableIdentifiers {
pub nodes: (
List<
@ -56,22 +56,22 @@ pub struct ListOfTfVariableIdentifiers {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfTypeAssignments {
pub nodes: (List<Symbol, TypeAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfVariableDeclAssignments {
pub nodes: (List<Symbol, VariableDeclAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfVariableIdentifiers {
pub nodes: (List<Symbol, (VariableIdentifier, Vec<VariableDimension>)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfVariablePortIdentifiers {
pub nodes: (
List<

22
sv-parser-syntaxtree/src/declarations/declaration_ranges.rs
View File

@ -2,50 +2,50 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum UnpackedDimension {
Range(Box<UnpackedDimensionRange>),
Expression(Box<UnpackedDimensionExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UnpackedDimensionRange {
pub nodes: (Bracket<ConstantRange>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UnpackedDimensionExpression {
pub nodes: (Bracket<ConstantExpression>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PackedDimension {
Range(Box<PackedDimensionRange>),
UnsizedDimension(Box<UnsizedDimension>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PackedDimensionRange {
pub nodes: (Bracket<ConstantRange>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum AssociativeDimension {
DataType(Box<AssociativeDimensionDataType>),
Asterisk(Box<AssociativeDimensionAsterisk>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssociativeDimensionDataType {
pub nodes: (Bracket<DataType>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AssociativeDimensionAsterisk {
pub nodes: (Bracket<Symbol>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum VariableDimension {
UnsizedDimension(Box<UnsizedDimension>),
UnpackedDimension(Box<UnpackedDimension>),
@ -53,12 +53,12 @@ pub enum VariableDimension {
QueueDimension(Box<QueueDimension>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct QueueDimension {
pub nodes: (Bracket<(Symbol, Option<(Symbol, ConstantExpression)>)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UnsizedDimension {
pub nodes: (Symbol, Symbol),
}

14
sv-parser-syntaxtree/src/declarations/delays.rs
View File

@ -2,18 +2,18 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Delay3 {
Single(Box<Delay3Single>),
Mintypmax(Box<Delay3Mintypmax>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Delay3Single {
pub nodes: (Symbol, DelayValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Delay3Mintypmax {
pub nodes: (
Symbol,
@ -28,18 +28,18 @@ pub struct Delay3Mintypmax {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Delay2 {
Single(Box<Delay2Single>),
Mintypmax(Box<Delay2Mintypmax>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Delay2Single {
pub nodes: (Symbol, DelayValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Delay2Mintypmax {
pub nodes: (
Symbol,
@ -47,7 +47,7 @@ pub struct Delay2Mintypmax {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DelayValue {
UnsignedNumber(Box<UnsignedNumber>),
RealNumber(Box<RealNumber>),

34
sv-parser-syntaxtree/src/declarations/function_declarations.rs
View File

@ -2,24 +2,24 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum FunctionDataTypeOrImplicit {
DataTypeOrVoid(Box<DataTypeOrVoid>),
ImplicitDataType(Box<ImplicitDataType>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionDeclaration {
pub nodes: (Keyword, Option<Lifetime>, FunctionBodyDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum FunctionBodyDeclaration {
WithoutPort(Box<FunctionBodyDeclarationWithoutPort>),
WithPort(Box<FunctionBodyDeclarationWithPort>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionBodyDeclarationWithoutPort {
pub nodes: (
FunctionDataTypeOrImplicit,
@ -33,7 +33,7 @@ pub struct FunctionBodyDeclarationWithoutPort {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionBodyDeclarationWithPort {
pub nodes: (
FunctionDataTypeOrImplicit,
@ -48,13 +48,13 @@ pub struct FunctionBodyDeclarationWithPort {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum InterfaceIdentifierOrClassScope {
InterfaceIdentifier(Box<(InterfaceIdentifier, Symbol)>),
ClassScope(Box<ClassScope>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionPrototype {
pub nodes: (
Keyword,
@ -64,7 +64,7 @@ pub struct FunctionPrototype {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DpiImportExport {
ImportFunction(Box<DpiImportExportImportFunction>),
ImportTask(Box<DpiImportExportImportTask>),
@ -72,7 +72,7 @@ pub enum DpiImportExport {
ExportTask(Box<DpiImportExportExportTask>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DpiImportExportImportFunction {
pub nodes: (
Keyword,
@ -84,7 +84,7 @@ pub struct DpiImportExportImportFunction {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DpiImportExportImportTask {
pub nodes: (
Keyword,
@ -96,7 +96,7 @@ pub struct DpiImportExportImportTask {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DpiImportExportExportFunction {
pub nodes: (
Keyword,
@ -108,7 +108,7 @@ pub struct DpiImportExportExportFunction {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DpiImportExportExportTask {
pub nodes: (
Keyword,
@ -120,29 +120,29 @@ pub struct DpiImportExportExportTask {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DpiSpecString {
DpiC(Box<Keyword>),
Dpi(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DpiFunctionImportProperty {
Context(Box<Keyword>),
Pure(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DpiTaskImportProperty {
Context(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DpiFunctionProto {
pub nodes: (FunctionPrototype,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DpiTaskProto {
pub nodes: (TaskPrototype,),
}

28
sv-parser-syntaxtree/src/declarations/interface_declarations.rs
View File

@ -2,12 +2,12 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportDeclaration {
pub nodes: (Keyword, List<Symbol, ModportItem>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportItem {
pub nodes: (
ModportIdentifier,
@ -15,66 +15,66 @@ pub struct ModportItem {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModportPortsDeclaraton {
Simple(Box<ModportPortsDeclaratonSimple>),
Tf(Box<ModportPortsDeclaratonTf>),
Clocking(Box<ModportPortsDeclaratonClocking>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportPortsDeclaratonSimple {
pub nodes: (Vec<AttributeInstance>, ModportSimplePortsDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportPortsDeclaratonTf {
pub nodes: (Vec<AttributeInstance>, ModportTfPortsDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportPortsDeclaratonClocking {
pub nodes: (Vec<AttributeInstance>, ModportClockingDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportClockingDeclaration {
pub nodes: (Keyword, ClockingIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportSimplePortsDeclaration {
pub nodes: (PortDirection, List<Symbol, ModportSimplePort>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModportSimplePort {
Ordered(Box<ModportSimplePortOrdered>),
Named(Box<ModportSimplePortNamed>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportSimplePortOrdered {
pub nodes: (PortIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportSimplePortNamed {
pub nodes: (Symbol, PortIdentifier, Paren<Option<Expression>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportTfPortsDeclaration {
pub nodes: (ImportExport, List<Symbol, ModportTfPort>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModportTfPort {
MethodPrototype(Box<MethodPrototype>),
TfIdentifier(Box<TfIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ImportExport {
Import(Box<Keyword>),
Export(Box<Keyword>),

20
sv-parser-syntaxtree/src/declarations/let_declarations.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LetDeclaration {
pub nodes: (
Keyword,
@ -14,17 +14,17 @@ pub struct LetDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LetIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LetPortList {
pub nodes: (List<Symbol, LetPortItem>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LetPortItem {
pub nodes: (
Vec<AttributeInstance>,
@ -35,13 +35,13 @@ pub struct LetPortItem {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum LetFormalType {
DataTypeOrImplicit(Box<DataTypeOrImplicit>),
Untyped(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LetExpression {
pub nodes: (
Option<PackageScope>,
@ -50,13 +50,13 @@ pub struct LetExpression {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum LetListOfArguments {
Ordered(Box<LetListOfArgumentsOrdered>),
Named(Box<LetListOfArgumentsNamed>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LetListOfArgumentsOrdered {
pub nodes: (
List<Symbol, Option<LetActualArg>>,
@ -64,12 +64,12 @@ pub struct LetListOfArgumentsOrdered {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LetListOfArgumentsNamed {
pub nodes: (List<Symbol, (Symbol, Identifier, Paren<Option<LetActualArg>>)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LetActualArg {
pub nodes: (Expression,),
}

14
sv-parser-syntaxtree/src/declarations/module_parameter_declarations.rs
View File

@ -2,39 +2,39 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum LocalParameterDeclaration {
Param(Box<LocalParameterDeclarationParam>),
Type(Box<LocalParameterDeclarationType>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LocalParameterDeclarationParam {
pub nodes: (Keyword, DataTypeOrImplicit, ListOfParamAssignments),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LocalParameterDeclarationType {
pub nodes: (Keyword, Keyword, ListOfTypeAssignments),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ParameterDeclaration {
Param(Box<ParameterDeclarationParam>),
Type(Box<ParameterDeclarationType>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParameterDeclarationParam {
pub nodes: (Keyword, DataTypeOrImplicit, ListOfParamAssignments),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParameterDeclarationType {
pub nodes: (Keyword, Keyword, ListOfTypeAssignments),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SpecparamDeclaration {
pub nodes: (
Keyword,

76
sv-parser-syntaxtree/src/declarations/net_and_variable_types.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CastingType {
SimpleType(Box<SimpleType>),
ConstantPrimary(Box<ConstantPrimary>),
@ -11,7 +11,7 @@ pub enum CastingType {
Const(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DataType {
Vector(Box<DataTypeVector>),
Atom(Box<DataTypeAtom>),
@ -28,17 +28,17 @@ pub enum DataType {
TypeReference(Box<TypeReference>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DataTypeVector {
pub nodes: (IntegerVectorType, Option<Signing>, Vec<PackedDimension>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DataTypeAtom {
pub nodes: (IntegerAtomType, Option<Signing>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DataTypeStructUnion {
pub nodes: (
StructUnion,
@ -48,12 +48,12 @@ pub struct DataTypeStructUnion {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Packed {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DataTypeEnum {
pub nodes: (
Keyword,
@ -63,7 +63,7 @@ pub struct DataTypeEnum {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DataTypeVirtual {
pub nodes: (
Keyword,
@ -74,12 +74,12 @@ pub struct DataTypeVirtual {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Interface {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DataTypeType {
pub nodes: (
Option<PackageScopeOrClassScope>,
@ -88,40 +88,40 @@ pub struct DataTypeType {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DataTypeOrImplicit {
DataType(Box<DataType>),
ImplicitDataType(Box<ImplicitDataType>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ImplicitDataType {
pub nodes: (Option<Signing>, Vec<PackedDimension>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum EnumBaseType {
Atom(Box<EnumBaseTypeAtom>),
Vector(Box<EnumBaseTypeVector>),
Type(Box<EnumBaseTypeType>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EnumBaseTypeAtom {
pub nodes: (IntegerAtomType, Option<Signing>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EnumBaseTypeVector {
pub nodes: (IntegerVectorType, Option<Signing>, Option<PackedDimension>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EnumBaseTypeType {
pub nodes: (TypeIdentifier, Option<PackedDimension>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EnumNameDeclaration {
pub nodes: (
EnumIdentifier,
@ -130,12 +130,12 @@ pub struct EnumNameDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassScope {
pub nodes: (ClassType, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassType {
pub nodes: (
PsClassIdentifier,
@ -144,13 +144,13 @@ pub struct ClassType {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum IntegerType {
IntegerVectorType(Box<IntegerVectorType>),
IntegerAtomType(Box<IntegerAtomType>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum IntegerAtomType {
Byte(Box<Keyword>),
Shortint(Box<Keyword>),
@ -160,21 +160,21 @@ pub enum IntegerAtomType {
Time(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum IntegerVectorType {
Bit(Box<Keyword>),
Logic(Box<Keyword>),
Reg(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NonIntegerType {
Shortreal(Box<Keyword>),
Real(Box<Keyword>),
Realtime(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NetType {
Supply0(Box<Keyword>),
Supply1(Box<Keyword>),
@ -190,46 +190,46 @@ pub enum NetType {
Wor(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NetPortType {
DataType(Box<NetPortTypeDataType>),
NetTypeIdentifier(Box<NetTypeIdentifier>),
Interconnect(Box<NetPortTypeInterconnect>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetPortTypeDataType {
pub nodes: (Option<NetType>, DataTypeOrImplicit),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetPortTypeInterconnect {
pub nodes: (Keyword, ImplicitDataType),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariablePortType {
pub nodes: (VarDataType,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum VarDataType {
DataType(Box<DataType>),
Var(Box<VarDataTypeVar>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VarDataTypeVar {
pub nodes: (Keyword, DataTypeOrImplicit),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Signing {
Signed(Box<Keyword>),
Unsigned(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SimpleType {
IntegerType(Box<IntegerType>),
NonIntegerType(Box<NonIntegerType>),
@ -237,7 +237,7 @@ pub enum SimpleType {
PsParameterIdentifier(Box<PsParameterIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StructUnionMember {
pub nodes: (
Vec<AttributeInstance>,
@ -248,31 +248,31 @@ pub struct StructUnionMember {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DataTypeOrVoid {
DataType(Box<DataType>),
Void(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum StructUnion {
Struct(Box<Keyword>),
Union(Box<Keyword>),
UnionTagged(Box<(Keyword, Keyword)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TypeReference {
Expression(Box<TypeReferenceExpression>),
DataType(Box<TypeReferenceDataType>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TypeReferenceExpression {
pub nodes: (Keyword, Paren<Expression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TypeReferenceDataType {
pub nodes: (Keyword, Paren<DataType>),
}

18
sv-parser-syntaxtree/src/declarations/port_declarations.rs
View File

@ -2,44 +2,44 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InoutDeclaration {
pub nodes: (Keyword, NetPortType, ListOfPortIdentifiers),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum InputDeclaration {
Net(Box<InputDeclarationNet>),
Variable(Box<InputDeclarationVariable>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InputDeclarationNet {
pub nodes: (Keyword, NetPortType, ListOfPortIdentifiers),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InputDeclarationVariable {
pub nodes: (Keyword, VariablePortType, ListOfVariableIdentifiers),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum OutputDeclaration {
Net(Box<OutputDeclarationNet>),
Variable(Box<OutputDeclarationVariable>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OutputDeclarationNet {
pub nodes: (Keyword, NetPortType, ListOfPortIdentifiers),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OutputDeclarationVariable {
pub nodes: (Keyword, VariablePortType, ListOfVariablePortIdentifiers),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfacePortDeclaration {
pub nodes: (
InterfaceIdentifier,
@ -48,7 +48,7 @@ pub struct InterfacePortDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RefDeclaration {
pub nodes: (Keyword, VariablePortType, ListOfVariableIdentifiers),
}

26
sv-parser-syntaxtree/src/declarations/strengths.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DriveStrength {
Strength01(Box<DriveStrength01>),
Strength10(Box<DriveStrength10>),
@ -12,37 +12,37 @@ pub enum DriveStrength {
Strengthz1(Box<DriveStrengthz1>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DriveStrength01 {
pub nodes: (Paren<(Strength0, Symbol, Strength1)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DriveStrength10 {
pub nodes: (Paren<(Strength1, Symbol, Strength0)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DriveStrength0z {
pub nodes: (Paren<(Strength0, Symbol, Keyword)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DriveStrength1z {
pub nodes: (Paren<(Strength1, Symbol, Keyword)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DriveStrengthz1 {
pub nodes: (Paren<(Keyword, Symbol, Strength1)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DriveStrengthz0 {
pub nodes: (Paren<(Keyword, Symbol, Strength0)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Strength0 {
Supply0(Box<Keyword>),
Strong0(Box<Keyword>),
@ -50,7 +50,7 @@ pub enum Strength0 {
Weak0(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Strength1 {
Supply1(Box<Keyword>),
Strong1(Box<Keyword>),
@ -58,24 +58,24 @@ pub enum Strength1 {
Weak1(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ChargeStrength {
Small(Box<ChargeStrengthSmall>),
Medium(Box<ChargeStrengthMedium>),
Large(Box<ChargeStrengthLarge>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ChargeStrengthSmall {
pub nodes: (Paren<Keyword>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ChargeStrengthMedium {
pub nodes: (Paren<Keyword>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ChargeStrengthLarge {
pub nodes: (Paren<Keyword>,),
}

20
sv-parser-syntaxtree/src/declarations/task_declarations.rs
View File

@ -2,18 +2,18 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TaskDeclaration {
pub nodes: (Keyword, Option<Lifetime>, TaskBodyDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TaskBodyDeclaration {
WithoutPort(Box<TaskBodyDeclarationWithoutPort>),
WithPort(Box<TaskBodyDeclarationWithPort>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TaskBodyDeclarationWithoutPort {
pub nodes: (
Option<InterfaceIdentifierOrClassScope>,
@ -26,7 +26,7 @@ pub struct TaskBodyDeclarationWithoutPort {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TaskBodyDeclarationWithPort {
pub nodes: (
Option<InterfaceIdentifierOrClassScope>,
@ -40,18 +40,18 @@ pub struct TaskBodyDeclarationWithPort {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TfItemDeclaration {
BlockItemDeclaration(Box<BlockItemDeclaration>),
TfPortDeclaration(Box<TfPortDeclaration>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TfPortList {
pub nodes: (List<Symbol, TfPortItem>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TfPortItem {
pub nodes: (
Vec<AttributeInstance>,
@ -66,13 +66,13 @@ pub struct TfPortItem {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TfPortDirection {
PortDirection(Box<PortDirection>),
ConstRef(Box<(Keyword, Keyword)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TfPortDeclaration {
pub nodes: (
Vec<AttributeInstance>,
@ -84,7 +84,7 @@ pub struct TfPortDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TaskPrototype {
pub nodes: (Keyword, TaskIdentifier, Option<Paren<Option<TfPortList>>>),
}

52
sv-parser-syntaxtree/src/declarations/type_declarations.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DataDeclaration {
Variable(Box<DataDeclarationVariable>),
TypeDeclaration(Box<TypeDeclaration>),
@ -10,7 +10,7 @@ pub enum DataDeclaration {
NetTypeDeclaration(Box<NetTypeDeclaration>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DataDeclarationVariable {
pub nodes: (
Option<Const>,
@ -22,61 +22,61 @@ pub struct DataDeclarationVariable {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Const {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PackageImportDeclaration {
pub nodes: (Keyword, List<Symbol, PackageImportItem>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PackageImportItem {
Identifier(Box<PackageImportItemIdentifier>),
Asterisk(Box<PackageImportItemAsterisk>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PackageImportItemIdentifier {
pub nodes: (PackageIdentifier, Symbol, Identifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PackageImportItemAsterisk {
pub nodes: (PackageIdentifier, Symbol, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PackageExportDeclaration {
Asterisk(Box<PackageExportDeclarationAsterisk>),
Item(Box<PackageExportDeclarationItem>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PackageExportDeclarationAsterisk {
pub nodes: (Keyword, Symbol, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PackageExportDeclarationItem {
pub nodes: (Keyword, List<Symbol, PackageImportItem>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GenvarDeclaration {
pub nodes: (Keyword, ListOfGenvarIdentifiers, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NetDeclaration {
NetType(Box<NetDeclarationNetType>),
NetTypeIdentifier(Box<NetDeclarationNetTypeIdentifier>),
Interconnect(Box<NetDeclarationInterconnect>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetDeclarationNetType {
pub nodes: (
NetType,
@ -89,19 +89,19 @@ pub struct NetDeclarationNetType {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Strength {
Drive(Box<DriveStrength>),
Charge(Box<ChargeStrength>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum VectorScalar {
Vectored(Box<Keyword>),
Scalared(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetDeclarationNetTypeIdentifier {
pub nodes: (
NetTypeIdentifier,
@ -111,7 +111,7 @@ pub struct NetDeclarationNetTypeIdentifier {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetDeclarationInterconnect {
pub nodes: (
Keyword,
@ -124,14 +124,14 @@ pub struct NetDeclarationInterconnect {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TypeDeclaration {
DataType(Box<TypeDeclarationDataType>),
Interface(Box<TypeDeclarationInterface>),
Reserved(Box<TypeDeclarationReserved>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TypeDeclarationDataType {
pub nodes: (
Keyword,
@ -142,7 +142,7 @@ pub struct TypeDeclarationDataType {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TypeDeclarationInterface {
pub nodes: (
Keyword,
@ -155,7 +155,7 @@ pub struct TypeDeclarationInterface {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TypeDeclarationReserved {
pub nodes: (
Keyword,
@ -165,7 +165,7 @@ pub struct TypeDeclarationReserved {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TypeDeclarationKeyword {
Enum(Box<Keyword>),
Struct(Box<Keyword>),
@ -174,13 +174,13 @@ pub enum TypeDeclarationKeyword {
InterfaceClass(Box<(Keyword, Keyword)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NetTypeDeclaration {
DataType(Box<NetTypeDeclarationDataType>),
NetType(Box<NetTypeDeclarationNetType>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetTypeDeclarationDataType {
pub nodes: (
Keyword,
@ -191,7 +191,7 @@ pub struct NetTypeDeclarationDataType {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetTypeDeclarationNetType {
pub nodes: (
Keyword,
@ -202,7 +202,7 @@ pub struct NetTypeDeclarationNetType {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Lifetime {
Static(Box<Keyword>),
Automatic(Box<Keyword>),

32
sv-parser-syntaxtree/src/expressions/concatenations.rs
View File

@ -2,63 +2,63 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Concatenation {
pub nodes: (Brace<List<Symbol, Expression>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantConcatenation {
pub nodes: (Brace<List<Symbol, ConstantExpression>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantMultipleConcatenation {
pub nodes: (Brace<(ConstantExpression, ConstantConcatenation)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModulePathConcatenation {
pub nodes: (Brace<List<Symbol, ModulePathExpression>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModulePathMultipleConcatenation {
pub nodes: (Brace<(ConstantExpression, ModulePathConcatenation)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct MultipleConcatenation {
pub nodes: (Brace<(Expression, Concatenation)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StreamingConcatenation {
pub nodes: (Brace<(StreamOperator, Option<SliceSize>, StreamConcatenation)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StreamOperator {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SliceSize {
SimpleType(Box<SimpleType>),
ConstantExpression(Box<ConstantExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StreamConcatenation {
pub nodes: (Brace<List<Symbol, StreamExpression>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StreamExpression {
pub nodes: (Expression, Option<(Keyword, Bracket<ArrayRangeExpression>)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ArrayRangeExpression {
Expression(Box<Expression>),
Colon(Box<ArrayRangeExpressionColon>),
@ -66,22 +66,22 @@ pub enum ArrayRangeExpression {
MinusColon(Box<ArrayRangeExpressionMinusColon>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ArrayRangeExpressionColon {
pub nodes: (Expression, Symbol, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ArrayRangeExpressionPlusColon {
pub nodes: (Expression, Symbol, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ArrayRangeExpressionMinusColon {
pub nodes: (Expression, Symbol, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EmptyUnpackedArrayConcatenation {
pub nodes: (Symbol, Symbol),
}

18
sv-parser-syntaxtree/src/expressions/expression_leftside_values.rs
View File

@ -2,24 +2,24 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NetLvalue {
Identifier(Box<NetLvalueIdentifier>),
Lvalue(Box<NetLvalueLvalue>),
Pattern(Box<NetLvaluePattern>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetLvalueIdentifier {
pub nodes: (PsOrHierarchicalNetIdentifier, ConstantSelect),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetLvalueLvalue {
pub nodes: (Brace<List<Symbol, NetLvalue>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetLvaluePattern {
pub nodes: (
Option<AssignmentPatternExpressionType>,
@ -27,7 +27,7 @@ pub struct NetLvaluePattern {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum VariableLvalue {
Identifier(Box<VariableLvalueIdentifier>),
Lvalue(Box<VariableLvalueLvalue>),
@ -35,7 +35,7 @@ pub enum VariableLvalue {
StreamingConcatenation(Box<StreamingConcatenation>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableLvalueIdentifier {
pub nodes: (
Option<ImplicitClassHandleOrPackageScope>,
@ -44,12 +44,12 @@ pub struct VariableLvalueIdentifier {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableLvalueLvalue {
pub nodes: (Brace<List<Symbol, VariableLvalue>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableLvaluePattern {
pub nodes: (
Option<AssignmentPatternExpressionType>,
@ -57,7 +57,7 @@ pub struct VariableLvaluePattern {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonrangeVariableLvalue {
pub nodes: (
Option<ImplicitClassHandleOrPackageScope>,

70
sv-parser-syntaxtree/src/expressions/expressions.rs
View File

@ -2,23 +2,23 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum IncOrDecExpression {
Prefix(Box<IncOrDecExpressionPrefix>),
Suffix(Box<IncOrDecExpressionSuffix>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IncOrDecExpressionPrefix {
pub nodes: (IncOrDecOperator, Vec<AttributeInstance>, VariableLvalue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IncOrDecExpressionSuffix {
pub nodes: (VariableLvalue, Vec<AttributeInstance>, IncOrDecOperator),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConditionalExpression {
pub nodes: (
CondPredicate,
@ -30,7 +30,7 @@ pub struct ConditionalExpression {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstantExpression {
ConstantPrimary(Box<ConstantPrimary>),
Unary(Box<ConstantExpressionUnary>),
@ -38,12 +38,12 @@ pub enum ConstantExpression {
Ternary(Box<ConstantExpressionTernary>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantExpressionUnary {
pub nodes: (UnaryOperator, Vec<AttributeInstance>, ConstantPrimary),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantExpressionBinary {
pub nodes: (
ConstantExpression,
@ -53,7 +53,7 @@ pub struct ConstantExpressionBinary {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantExpressionTernary {
pub nodes: (
ConstantExpression,
@ -65,13 +65,13 @@ pub struct ConstantExpressionTernary {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstantMintypmaxExpression {
Unary(Box<ConstantExpression>),
Ternary(Box<ConstantMintypmaxExpressionTernary>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantMintypmaxExpressionTernary {
pub nodes: (
ConstantExpression,
@ -82,43 +82,43 @@ pub struct ConstantMintypmaxExpressionTernary {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstantParamExpression {
ConstantMintypmaxExpression(Box<ConstantMintypmaxExpression>),
DataType(Box<DataType>),
Dollar(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ParamExpression {
MintypmaxExpression(Box<MintypmaxExpression>),
DataType(Box<DataType>),
Dollar(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstantRangeExpression {
ConstantExpression(Box<ConstantExpression>),
ConstantPartSelectRange(Box<ConstantPartSelectRange>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstantPartSelectRange {
ConstantRange(Box<ConstantRange>),
ConstantIndexedRange(Box<ConstantIndexedRange>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantRange {
pub nodes: (ConstantExpression, Symbol, ConstantExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantIndexedRange {
pub nodes: (ConstantExpression, Symbol, ConstantExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Expression {
Primary(Box<Primary>),
Unary(Box<ExpressionUnary>),
@ -130,17 +130,17 @@ pub enum Expression {
TaggedUnionExpression(Box<TaggedUnionExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ExpressionUnary {
pub nodes: (UnaryOperator, Vec<AttributeInstance>, Primary),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ExpressionOperatorAssignment {
pub nodes: (Paren<OperatorAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ExpressionBinary {
pub nodes: (
Expression,
@ -150,39 +150,39 @@ pub struct ExpressionBinary {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TaggedUnionExpression {
pub nodes: (Keyword, MemberIdentifier, Option<Expression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InsideExpression {
pub nodes: (Expression, Keyword, Brace<OpenRangeList>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ValueRange {
Expression(Box<Expression>),
Binary(Box<ValueRangeBinary>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ValueRangeBinary {
pub nodes: (Bracket<(Expression, Symbol, Expression)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum MintypmaxExpression {
Expression(Box<Expression>),
Ternary(Box<MintypmaxExpressionTernary>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct MintypmaxExpressionTernary {
pub nodes: (Expression, Symbol, Expression, Symbol, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModulePathConditionalExpression {
pub nodes: (
ModulePathExpression,
@ -194,7 +194,7 @@ pub struct ModulePathConditionalExpression {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModulePathExpression {
ModulePathPrimary(Box<ModulePathPrimary>),
Unary(Box<ModulePathExpressionUnary>),
@ -202,7 +202,7 @@ pub enum ModulePathExpression {
ModulePathConditionalExpression(Box<ModulePathConditionalExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModulePathExpressionUnary {
pub nodes: (
UnaryModulePathOperator,
@ -211,7 +211,7 @@ pub struct ModulePathExpressionUnary {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModulePathExpressionBinary {
pub nodes: (
ModulePathExpression,
@ -221,13 +221,13 @@ pub struct ModulePathExpressionBinary {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModulePathMintypmaxExpression {
ModulePathExpression(Box<ModulePathExpression>),
Ternary(Box<ModulePathMintypmaxExpressionTernary>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModulePathMintypmaxExpressionTernary {
pub nodes: (
ModulePathExpression,
@ -238,18 +238,18 @@ pub struct ModulePathMintypmaxExpressionTernary {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PartSelectRange {
ConstantRange(Box<ConstantRange>),
IndexedRange(Box<IndexedRange>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IndexedRange {
pub nodes: (Expression, Symbol, ConstantExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GenvarExpression {
pub nodes: (ConstantExpression,),
}

54
sv-parser-syntaxtree/src/expressions/numbers.rs
View File

@ -2,13 +2,13 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Number {
IntegralNumber(Box<IntegralNumber>),
RealNumber(Box<RealNumber>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum IntegralNumber {
DecimalNumber(Box<DecimalNumber>),
OctalNumber(Box<OctalNumber>),
@ -16,7 +16,7 @@ pub enum IntegralNumber {
HexNumber(Box<HexNumber>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DecimalNumber {
UnsignedNumber(Box<UnsignedNumber>),
BaseUnsigned(Box<DecimalNumberBaseUnsigned>),
@ -24,59 +24,59 @@ pub enum DecimalNumber {
BaseZNumber(Box<DecimalNumberBaseZNumber>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DecimalNumberBaseUnsigned {
pub nodes: (Option<Size>, DecimalBase, UnsignedNumber),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DecimalNumberBaseXNumber {
pub nodes: (Option<Size>, DecimalBase, XNumber),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DecimalNumberBaseZNumber {
pub nodes: (Option<Size>, DecimalBase, ZNumber),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinaryNumber {
pub nodes: (Option<Size>, BinaryBase, BinaryValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OctalNumber {
pub nodes: (Option<Size>, OctalBase, OctalValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HexNumber {
pub nodes: (Option<Size>, HexBase, HexValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Sign {
Plus(Box<Symbol>),
Minus(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Size {
pub nodes: (NonZeroUnsignedNumber,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonZeroUnsignedNumber {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum RealNumber {
FixedPointNumber(Box<FixedPointNumber>),
Floating(Box<RealNumberFloating>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RealNumberFloating {
pub nodes: (
UnsignedNumber,
@ -87,67 +87,67 @@ pub struct RealNumberFloating {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FixedPointNumber {
pub nodes: (UnsignedNumber, Symbol, UnsignedNumber),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Exp {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UnsignedNumber {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinaryValue {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OctalValue {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HexValue {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DecimalBase {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinaryBase {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OctalBase {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HexBase {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct XNumber {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ZNumber {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UnbasedUnsizedLiteral {
pub nodes: (Symbol,),
}

10
sv-parser-syntaxtree/src/expressions/operators.rs
View File

@ -2,27 +2,27 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UnaryOperator {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinaryOperator {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IncOrDecOperator {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UnaryModulePathOperator {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinaryModulePathOperator {
pub nodes: (Symbol,),
}

64
sv-parser-syntaxtree/src/expressions/primaries.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstantPrimary {
PrimaryLiteral(Box<PrimaryLiteral>),
PsParameter(Box<ConstantPrimaryPsParameter>),
@ -21,12 +21,12 @@ pub enum ConstantPrimary {
Null(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantPrimaryPsParameter {
pub nodes: (PsParameterIdentifier, ConstantSelect),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantPrimarySpecparam {
pub nodes: (
SpecparamIdentifier,
@ -34,17 +34,17 @@ pub struct ConstantPrimarySpecparam {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantPrimaryFormalPort {
pub nodes: (FormalPortIdentifier, ConstantSelect),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantPrimaryEnum {
pub nodes: (PackageScopeOrClassScope, EnumIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantPrimaryConcatenation {
pub nodes: (
ConstantConcatenation,
@ -52,7 +52,7 @@ pub struct ConstantPrimaryConcatenation {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantPrimaryMultipleConcatenation {
pub nodes: (
ConstantMultipleConcatenation,
@ -60,12 +60,12 @@ pub struct ConstantPrimaryMultipleConcatenation {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantPrimaryMintypmaxExpression {
pub nodes: (Paren<ConstantMintypmaxExpression>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModulePathPrimary {
Number(Box<Number>),
Identifier(Box<Identifier>),
@ -75,12 +75,12 @@ pub enum ModulePathPrimary {
Mintypmax(Box<ModulePathPrimaryMintypmax>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModulePathPrimaryMintypmax {
pub nodes: (Paren<ModulePathMintypmaxExpression>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Primary {
PrimaryLiteral(Box<PrimaryLiteral>),
Hierarchical(Box<PrimaryHierarchical>),
@ -99,7 +99,7 @@ pub enum Primary {
Null(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PrimaryHierarchical {
pub nodes: (
Option<ClassQualifierOrPackageScope>,
@ -108,39 +108,39 @@ pub struct PrimaryHierarchical {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PrimaryConcatenation {
pub nodes: (Concatenation, Option<Bracket<RangeExpression>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PrimaryMultipleConcatenation {
pub nodes: (MultipleConcatenation, Option<Bracket<RangeExpression>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PrimaryMintypmaxExpression {
pub nodes: (Paren<MintypmaxExpression>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClassQualifierOrPackageScope {
ClassQualifier(Box<ClassQualifier>),
PackageScope(Box<PackageScope>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassQualifier {
pub nodes: (Option<Local>, Option<ImplicitClassHandleOrClassScope>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum RangeExpression {
Expression(Box<Expression>),
PartSelectRange(Box<PartSelectRange>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PrimaryLiteral {
Number(Box<Number>),
TimeLiteral(Box<TimeLiteral>),
@ -148,23 +148,23 @@ pub enum PrimaryLiteral {
StringLiteral(Box<StringLiteral>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TimeLiteral {
Unsigned(Box<TimeLiteralUnsigned>),
FixedPoint(Box<TimeLiteralFixedPoint>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimeLiteralUnsigned {
pub nodes: (UnsignedNumber, TimeUnit),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimeLiteralFixedPoint {
pub nodes: (FixedPointNumber, TimeUnit),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TimeUnit {
S(Box<Keyword>),
MS(Box<Keyword>),
@ -174,19 +174,19 @@ pub enum TimeUnit {
FS(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ImplicitClassHandle {
This(Box<Keyword>),
Super(Box<Keyword>),
ThisSuper(Box<(Keyword, Symbol, Keyword)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BitSelect {
pub nodes: (Vec<Bracket<Expression>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Select {
pub nodes: (
Option<(
@ -199,7 +199,7 @@ pub struct Select {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonrangeSelect {
pub nodes: (
Option<(
@ -211,12 +211,12 @@ pub struct NonrangeSelect {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantBitSelect {
pub nodes: (Vec<Bracket<ConstantExpression>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantSelect {
pub nodes: (
Option<(
@ -229,17 +229,17 @@ pub struct ConstantSelect {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantCast {
pub nodes: (CastingType, Symbol, Paren<ConstantExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantLetExpression {
pub nodes: (LetExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Cast {
pub nodes: (CastingType, Symbol, Paren<Expression>),
}

2
sv-parser-syntaxtree/src/expressions/strings.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StringLiteral {
pub nodes: (Locate, Vec<WhiteSpace>),
}

42
sv-parser-syntaxtree/src/expressions/subroutine_calls.rs
View File

@ -2,12 +2,12 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstantFunctionCall {
pub nodes: (FunctionSubroutineCall,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TfCall {
pub nodes: (
PsOrHierarchicalTfIdentifier,
@ -16,19 +16,19 @@ pub struct TfCall {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SystemTfCall {
ArgOptionl(Box<SystemTfCallArgOptional>),
ArgDataType(Box<SystemTfCallArgDataType>),
ArgExpression(Box<SystemTfCallArgExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SystemTfCallArgOptional {
pub nodes: (SystemTfIdentifier, Option<Paren<ListOfArguments>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SystemTfCallArgDataType {
pub nodes: (
SystemTfIdentifier,
@ -36,7 +36,7 @@ pub struct SystemTfCallArgDataType {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SystemTfCallArgExpression {
pub nodes: (
SystemTfIdentifier,
@ -47,7 +47,7 @@ pub struct SystemTfCallArgExpression {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SubroutineCall {
TfCall(Box<TfCall>),
SystemTfCall(Box<SystemTfCall>),
@ -55,23 +55,23 @@ pub enum SubroutineCall {
Randomize(Box<SubroutineCallRandomize>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SubroutineCallRandomize {
pub nodes: (Option<(Keyword, Symbol)>, RandomizeCall),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionSubroutineCall {
pub nodes: (SubroutineCall,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ListOfArguments {
Ordered(Box<ListOfArgumentsOrdered>),
Named(Box<ListOfArgumentsNamed>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfArgumentsOrdered {
pub nodes: (
List<Symbol, Option<Expression>>,
@ -79,7 +79,7 @@ pub struct ListOfArgumentsOrdered {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfArgumentsNamed {
pub nodes: (
Symbol,
@ -89,18 +89,18 @@ pub struct ListOfArgumentsNamed {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct MethodCall {
pub nodes: (MethodCallRoot, Symbol, MethodCallBody),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum MethodCallBody {
User(Box<MethodCallBodyUser>),
BuiltInMethodCall(Box<BuiltInMethodCall>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct MethodCallBodyUser {
pub nodes: (
MethodIdentifier,
@ -109,13 +109,13 @@ pub struct MethodCallBodyUser {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BuiltInMethodCall {
ArrayManipulationCall(Box<ArrayManipulationCall>),
RandomizeCall(Box<RandomizeCall>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ArrayManipulationCall {
pub nodes: (
ArrayMethodName,
@ -125,7 +125,7 @@ pub struct ArrayManipulationCall {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RandomizeCall {
pub nodes: (
Keyword,
@ -139,19 +139,19 @@ pub struct RandomizeCall {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum VariableIdentifierListOrNull {
VariableIdentifierList(Box<VariableIdentifierList>),
Null(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum MethodCallRoot {
Primary(Box<Primary>),
ImplicitClassHandle(Box<ImplicitClassHandle>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ArrayMethodName {
MethodIdentifier(Box<MethodIdentifier>),
Unique(Box<Keyword>),

4
sv-parser-syntaxtree/src/general/attributes.rs
View File

@ -2,12 +2,12 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AttributeInstance {
pub nodes: (Symbol, List<Symbol, AttrSpec>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AttrSpec {
pub nodes: (Identifier, Option<(Symbol, ConstantExpression)>),
}

2
sv-parser-syntaxtree/src/general/comments.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Comment {
pub nodes: (Locate,),
}

94
sv-parser-syntaxtree/src/general/compiler_directives.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CompilerDirective {
ResetallCompilerDirective(Box<ResetallCompilerDirective>),
IncludeCompilerDirective(Box<IncludeCompilerDirective>),
@ -24,68 +24,68 @@ pub enum CompilerDirective {
EndkeywordsDirective(Box<EndkeywordsDirective>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ResetallCompilerDirective {
pub nodes: (Symbol, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum IncludeCompilerDirective {
DoubleQuote(Box<IncludeCompilerDirectiveDoubleQuote>),
AngleBracket(Box<IncludeCompilerDirectiveAngleBracket>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IncludeCompilerDirectiveDoubleQuote {
pub nodes: (Symbol, Keyword, StringLiteral),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IncludeCompilerDirectiveAngleBracket {
pub nodes: (Symbol, Keyword, AngleBracketLiteral),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AngleBracketLiteral {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TextMacroDefinition {
pub nodes: (Symbol, Keyword, TextMacroName, Option<MacroText>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TextMacroName {
pub nodes: (TextMacroIdentifier, Option<Paren<ListOfFormalArguments>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfFormalArguments {
pub nodes: (List<Symbol, FormalArgument>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FormalArgument {
pub nodes: (SimpleIdentifier, Option<(Symbol, DefaultText)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TextMacroIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct MacroText {
pub nodes: (Locate,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DefaultText {
pub nodes: (Locate,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TextMacroUsage {
pub nodes: (
Symbol,
@ -94,33 +94,33 @@ pub struct TextMacroUsage {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfActualArguments {
pub nodes: (List<Symbol, ActualArgument>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ActualArgument {
pub nodes: (Expression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UndefineCompilerDirective {
pub nodes: (Symbol, Keyword, TextMacroIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UndefineallCompilerDirective {
pub nodes: (Symbol, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConditionalCompilerDirective {
IfdefDirective(Box<IfdefDirective>),
IfndefDirective(Box<IfndefDirective>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IfdefDirective {
pub nodes: (
Symbol,
@ -134,7 +134,7 @@ pub struct IfdefDirective {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IfndefDirective {
pub nodes: (
Symbol,
@ -148,74 +148,74 @@ pub struct IfndefDirective {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IfdefGroupOfLines {
pub nodes: (Vec<SourceDescription>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IfndefGroupOfLines {
pub nodes: (Vec<SourceDescription>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ElsifGroupOfLines {
pub nodes: (Vec<SourceDescription>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ElseGroupOfLines {
pub nodes: (Vec<SourceDescription>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SourceDescription {
Comment(Box<Comment>),
NotDirective(Box<SourceDescriptionNotDirective>),
CompilerDirective(Box<CompilerDirective>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SourceDescriptionNotDirective {
pub nodes: (Locate,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimescaleCompilerDirective {
pub nodes: (Symbol, Keyword, TimeLiteral, Symbol, TimeLiteral),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DefaultNettypeCompilerDirective {
pub nodes: (Symbol, Keyword, DefaultNettypeValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DefaultNettypeValue {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UnconnectedDriveCompilerDirective {
pub nodes: (Symbol, Keyword, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NounconnectedDriveCompilerDirective {
pub nodes: (Symbol, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CelldefineDriveCompilerDirective {
pub nodes: (Symbol, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EndcelldefineDriveCompilerDirective {
pub nodes: (Symbol, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Pragma {
pub nodes: (
Symbol,
@ -225,24 +225,24 @@ pub struct Pragma {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PragmaName {
pub nodes: (SimpleIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PragmaExpression {
PragmaKeyword(Box<PragmaKeyword>),
Assignment(Box<PragmaExpressionAssignment>),
PragmaValue(Box<PragmaValue>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PragmaExpressionAssignment {
pub nodes: (PragmaKeyword, Symbol, PragmaValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PragmaValue {
Paren(Box<PragmaValueParen>),
Number(Box<Number>),
@ -250,42 +250,42 @@ pub enum PragmaValue {
Identifier(Box<Identifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PragmaValueParen {
pub nodes: (Paren<List<Symbol, PragmaExpression>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PragmaKeyword {
pub nodes: (SimpleIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LineCompilerDirective {
pub nodes: (Symbol, Keyword, Number, StringLiteral, Level),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PositionCompilerDirective {
pub nodes: (Symbol, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Level {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct KeywordsDirective {
pub nodes: (Symbol, Keyword, Symbol, VersionSpecifier, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VersionSpecifier {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EndkeywordsDirective {
pub nodes: (Symbol, Keyword),
}

198
sv-parser-syntaxtree/src/general/identifiers.rs
View File

@ -2,142 +2,142 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ArrayIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BlockIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BinIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CIdentifier {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CellIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CheckerIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassVariableIdentifier {
pub nodes: (VariableIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClockingIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConfigIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CovergroupIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CovergroupVariableIdentifier {
pub nodes: (VariableIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CoverPointIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CrossIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DynamicArrayVariableIdentifier {
pub nodes: (VariableIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EnumIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EscapedIdentifier {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FormalIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FormalPortIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FunctionIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GenerateBlockIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GenvarIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalArrayIdentifier {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalBlockIdentifier {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalEventIdentifier {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalIdentifier {
pub nodes: (
Option<Root>,
@ -146,189 +146,189 @@ pub struct HierarchicalIdentifier {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Root {
pub nodes: (Keyword, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalNetIdentifier {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalParameterIdentifier {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalPropertyIdentifier {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalSequenceIdentifier {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalTaskIdentifier {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalTfIdentifier {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalVariableIdentifier {
pub nodes: (HierarchicalIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Identifier {
SimpleIdentifier(Box<SimpleIdentifier>),
EscapedIdentifier(Box<EscapedIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IndexVariableIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceInstanceIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InoutPortIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InputPortIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InstanceIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LibraryIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct MemberIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct MethodIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModportIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetTypeIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OutputPortIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PackageIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PackageScope {
Package(Box<PackageScopePackage>),
Unit(Box<Unit>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PackageScopePackage {
pub nodes: (PackageIdentifier, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Unit {
pub nodes: (Keyword, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParameterIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PortIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProductionIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProgramIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PropertyIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsClassIdentifier {
pub nodes: (Option<PackageScope>, ClassIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsCovergroupIdentifier {
pub nodes: (Option<PackageScope>, CovergroupIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsCheckerIdentifier {
pub nodes: (Option<PackageScope>, CheckerIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsIdentifier {
pub nodes: (Option<PackageScope>, Identifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsOrHierarchicalArrayIdentifier {
pub nodes: (
Option<ImplicitClassHandleOrClassScopeOrPackageScope>,
@ -336,82 +336,82 @@ pub struct PsOrHierarchicalArrayIdentifier {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PsOrHierarchicalNetIdentifier {
PackageScope(Box<PsOrHierarchicalNetIdentifierPackageScope>),
HierarchicalNetIdentifier(Box<HierarchicalNetIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsOrHierarchicalNetIdentifierPackageScope {
pub nodes: (Option<PackageScope>, NetIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsOrHierarchicalNetIdentifierHierarchical {
pub nodes: (HierarchicalNetIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PsOrHierarchicalPropertyIdentifier {
PackageScope(Box<PsOrHierarchicalPropertyIdentifierPackageScope>),
HierarchicalPropertyIdentifier(Box<HierarchicalPropertyIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsOrHierarchicalPropertyIdentifierPackageScope {
pub nodes: (Option<PackageScope>, PropertyIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsOrHierarchicalPropertyIdentifierHierarchical {
pub nodes: (HierarchicalPropertyIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PsOrHierarchicalSequenceIdentifier {
PackageScope(Box<PsOrHierarchicalSequenceIdentifierPackageScope>),
HierarchicalSequenceIdentifier(Box<HierarchicalSequenceIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsOrHierarchicalSequenceIdentifierPackageScope {
pub nodes: (Option<PackageScope>, SequenceIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsOrHierarchicalSequenceIdentifierHierarchical {
pub nodes: (HierarchicalSequenceIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PsOrHierarchicalTfIdentifier {
PackageScope(Box<PsOrHierarchicalTfIdentifierPackageScope>),
HierarchicalTfIdentifier(Box<HierarchicalTfIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsOrHierarchicalTfIdentifierPackageScope {
pub nodes: (Option<PackageScope>, TfIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsOrHierarchicalTfIdentifierHierarchical {
pub nodes: (HierarchicalTfIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PsParameterIdentifier {
Scope(Box<PsParameterIdentifierScope>),
Generate(Box<PsParameterIdentifierGenerate>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsParameterIdentifierScope {
pub nodes: (Option<PackageScopeOrClassScope>, ParameterIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsParameterIdentifierGenerate {
pub nodes: (
Vec<(
@ -423,103 +423,103 @@ pub struct PsParameterIdentifierGenerate {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PsTypeIdentifier {
pub nodes: (Option<LocalOrPackageScopeOrClassScope>, TypeIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum LocalOrPackageScopeOrClassScope {
Local(Box<Local>),
PackageScope(Box<PackageScope>),
ClassScope(Box<ClassScope>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Local {
pub nodes: (Keyword, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequenceIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SignalIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SimpleIdentifier {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SpecparamIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SystemTfIdentifier {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TaskIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TfIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TerminalIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TopmoduleIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TypeIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariableIdentifier {
pub nodes: (Identifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ImplicitClassHandleOrClassScopeOrPackageScope {
ImplicitClassHandle(Box<(ImplicitClassHandle, Symbol)>),
ClassScope(Box<ClassScope>),
PackageScope(Box<PackageScope>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ImplicitClassHandleOrPackageScope {
ImplicitClassHandle(Box<(ImplicitClassHandle, Symbol)>),
PackageScope(Box<PackageScope>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ImplicitClassHandleOrClassScope {
ImplicitClassHandle(Box<(ImplicitClassHandle, Symbol)>),
ClassScope(Box<ClassScope>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PackageScopeOrClassScope {
PackageScope(Box<PackageScope>),
ClassScope(Box<ClassScope>),

16
sv-parser-syntaxtree/src/instantiations/checker_instantiation.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CheckerInstantiation {
pub nodes: (
PsCheckerIdentifier,
@ -12,34 +12,34 @@ pub struct CheckerInstantiation {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ListOfCheckerPortConnections {
Ordered(Box<ListOfCheckerPortConnectionsOrdered>),
Named(Box<ListOfCheckerPortConnectionsNamed>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfCheckerPortConnectionsOrdered {
pub nodes: (List<Symbol, OrderedCheckerPortConnection>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfCheckerPortConnectionsNamed {
pub nodes: (List<Symbol, NamedCheckerPortConnection>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OrderedCheckerPortConnection {
pub nodes: (Vec<AttributeInstance>, Option<PropertyActualArg>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NamedCheckerPortConnection {
Identifier(Box<NamedCheckerPortConnectionIdentifier>),
Asterisk(Box<NamedCheckerPortConnectionAsterisk>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NamedCheckerPortConnectionIdentifier {
pub nodes: (
Vec<AttributeInstance>,
@ -49,7 +49,7 @@ pub struct NamedCheckerPortConnectionIdentifier {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NamedCheckerPortConnectionAsterisk {
pub nodes: (Vec<AttributeInstance>, Symbol),
}

34
sv-parser-syntaxtree/src/instantiations/generated_instantiation.rs
View File

@ -2,12 +2,12 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GenerateRegion {
pub nodes: (Keyword, Vec<GenerateItem>, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LoopGenerateConstruct {
pub nodes: (
Keyword,
@ -22,45 +22,45 @@ pub struct LoopGenerateConstruct {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GenvarInitialization {
pub nodes: (Option<Genvar>, GenvarIdentifier, Symbol, ConstantExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Genvar {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum GenvarIteration {
Assignment(Box<GenvarIterationAssignment>),
Prefix(Box<GenvarIterationPrefix>),
Suffix(Box<GenvarIterationSuffix>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GenvarIterationAssignment {
pub nodes: (GenvarIdentifier, AssignmentOperator, GenvarExpression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GenvarIterationPrefix {
pub nodes: (IncOrDecOperator, GenvarIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GenvarIterationSuffix {
pub nodes: (GenvarIdentifier, IncOrDecOperator),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConditionalGenerateConstruct {
If(Box<IfGenerateConstruct>),
Case(Box<CaseGenerateConstruct>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IfGenerateConstruct {
pub nodes: (
Keyword,
@ -70,7 +70,7 @@ pub struct IfGenerateConstruct {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseGenerateConstruct {
pub nodes: (
Keyword,
@ -80,29 +80,29 @@ pub struct CaseGenerateConstruct {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CaseGenerateItem {
Nondefault(Box<CaseGenerateItemNondefault>),
Default(Box<CaseGenerateItemDefault>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseGenerateItemNondefault {
pub nodes: (List<Symbol, ConstantExpression>, Symbol, GenerateBlock),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CaseGenerateItemDefault {
pub nodes: (Keyword, Option<Symbol>, GenerateBlock),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum GenerateBlock {
GenerateItem(Box<GenerateItem>),
Multiple(Box<GenerateBlockMultiple>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GenerateBlockMultiple {
pub nodes: (
Option<(GenerateBlockIdentifier, Symbol)>,
@ -114,7 +114,7 @@ pub struct GenerateBlockMultiple {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum GenerateItem {
ModuleOrGenerateItem(Box<ModuleOrGenerateItem>),
InterfaceOrGenerateItem(Box<InterfaceOrGenerateItem>),

2
sv-parser-syntaxtree/src/instantiations/interface_instantiation.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceInstantiation {
pub nodes: (
InterfaceIdentifier,

32
sv-parser-syntaxtree/src/instantiations/module_instantiation.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleInstantiation {
pub nodes: (
ModuleIdentifier,
@ -12,75 +12,75 @@ pub struct ModuleInstantiation {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParameterValueAssignment {
pub nodes: (Symbol, Paren<Option<ListOfParameterAssignments>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ListOfParameterAssignments {
Ordered(Box<ListOfParameterAssignmentsOrdered>),
Named(Box<ListOfParameterAssignmentsNamed>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfParameterAssignmentsOrdered {
pub nodes: (List<Symbol, OrderedParameterAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfParameterAssignmentsNamed {
pub nodes: (List<Symbol, NamedParameterAssignment>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OrderedParameterAssignment {
pub nodes: (ParamExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NamedParameterAssignment {
pub nodes: (Symbol, ParameterIdentifier, Paren<Option<ParamExpression>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HierarchicalInstance {
pub nodes: (NameOfInstance, Paren<Option<ListOfPortConnections>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NameOfInstance {
pub nodes: (InstanceIdentifier, Vec<UnpackedDimension>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ListOfPortConnections {
Ordered(Box<ListOfPortConnectionsOrdered>),
Named(Box<ListOfPortConnectionsNamed>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfPortConnectionsOrdered {
pub nodes: (List<Symbol, OrderedPortConnection>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfPortConnectionsNamed {
pub nodes: (List<Symbol, NamedPortConnection>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OrderedPortConnection {
pub nodes: (Vec<AttributeInstance>, Option<Expression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NamedPortConnection {
Identifier(Box<NamedPortConnectionIdentifier>),
Asterisk(Box<NamedPortConnectionAsterisk>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NamedPortConnectionIdentifier {
pub nodes: (
Vec<AttributeInstance>,
@ -90,7 +90,7 @@ pub struct NamedPortConnectionIdentifier {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NamedPortConnectionAsterisk {
pub nodes: (Vec<AttributeInstance>, Symbol),
}

2
sv-parser-syntaxtree/src/instantiations/program_instantiation.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProgramInstantiation {
pub nodes: (
ProgramIdentifier,

6
sv-parser-syntaxtree/src/lib.rs
View File

@ -36,6 +36,12 @@ pub struct Locate {
pub len: usize,
}
impl Locate {
pub fn str<'a, 'b>(&'a self, s: &'b str) -> &'b str {
&s[self.offset..self.offset + self.len]
}
}
// -----------------------------------------------------------------------------
pub trait Node<'a> {

2
sv-parser-syntaxtree/src/preprocessor/preprocessor.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PreprocessorText {
pub nodes: (Vec<SourceDescription>,),
}

14
sv-parser-syntaxtree/src/primitive_instances/primitive_gate_and_switch_types.rs
View File

@ -2,37 +2,37 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CmosSwitchtype {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EnableGatetype {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct MosSwitchtype {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NInputGatetype {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NOutputGatetype {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PassEnSwitchtype {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PassSwitchtype {
pub nodes: (Keyword,),
}

36
sv-parser-syntaxtree/src/primitive_instances/primitive_instantiation_and_instances.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum GateInstantiation {
Cmos(Box<GateInstantiationCmos>),
Enable(Box<GateInstantiationEnable>),
@ -15,7 +15,7 @@ pub enum GateInstantiation {
Pullup(Box<GateInstantiationPullup>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GateInstantiationCmos {
pub nodes: (
CmosSwitchtype,
@ -25,7 +25,7 @@ pub struct GateInstantiationCmos {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GateInstantiationEnable {
pub nodes: (
EnableGatetype,
@ -36,7 +36,7 @@ pub struct GateInstantiationEnable {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GateInstantiationMos {
pub nodes: (
MosSwitchtype,
@ -46,7 +46,7 @@ pub struct GateInstantiationMos {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GateInstantiationNInput {
pub nodes: (
NInputGatetype,
@ -57,7 +57,7 @@ pub struct GateInstantiationNInput {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GateInstantiationNOutput {
pub nodes: (
NOutputGatetype,
@ -68,7 +68,7 @@ pub struct GateInstantiationNOutput {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GateInstantiationPassEn {
pub nodes: (
PassEnSwitchtype,
@ -78,12 +78,12 @@ pub struct GateInstantiationPassEn {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GateInstantiationPass {
pub nodes: (PassSwitchtype, List<Symbol, PassSwitchInstance>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GateInstantiationPulldown {
pub nodes: (
Keyword,
@ -93,7 +93,7 @@ pub struct GateInstantiationPulldown {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct GateInstantiationPullup {
pub nodes: (
Keyword,
@ -103,7 +103,7 @@ pub struct GateInstantiationPullup {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CmosSwitchInstance {
pub nodes: (
Option<NameOfInstance>,
@ -119,7 +119,7 @@ pub struct CmosSwitchInstance {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EnableGateInstance {
pub nodes: (
Option<NameOfInstance>,
@ -133,7 +133,7 @@ pub struct EnableGateInstance {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct MosSwitchInstance {
pub nodes: (
Option<NameOfInstance>,
@ -147,7 +147,7 @@ pub struct MosSwitchInstance {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NInputGateInstance {
pub nodes: (
Option<NameOfInstance>,
@ -155,7 +155,7 @@ pub struct NInputGateInstance {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NOutputGateInstance {
pub nodes: (
Option<NameOfInstance>,
@ -163,7 +163,7 @@ pub struct NOutputGateInstance {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PassSwitchInstance {
pub nodes: (
Option<NameOfInstance>,
@ -171,7 +171,7 @@ pub struct PassSwitchInstance {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PassEnableSwitchInstance {
pub nodes: (
Option<NameOfInstance>,
@ -179,7 +179,7 @@ pub struct PassEnableSwitchInstance {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PullGateInstance {
pub nodes: (Option<NameOfInstance>, Paren<OutputTerminal>),
}

16
sv-parser-syntaxtree/src/primitive_instances/primitive_strengths.rs
View File

@ -2,46 +2,46 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PulldownStrength {
Strength01(Box<PulldownStrength01>),
Strength10(Box<PulldownStrength10>),
Strength0(Box<PulldownStrength0>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PulldownStrength01 {
pub nodes: (Paren<(Strength0, Symbol, Strength1)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PulldownStrength10 {
pub nodes: (Paren<(Strength1, Symbol, Strength0)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PulldownStrength0 {
pub nodes: (Paren<Strength0>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PullupStrength {
Strength01(Box<PullupStrength01>),
Strength10(Box<PullupStrength10>),
Strength1(Box<PullupStrength1>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PullupStrength01 {
pub nodes: (Paren<(Strength0, Symbol, Strength1)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PullupStrength10 {
pub nodes: (Paren<(Strength1, Symbol, Strength0)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PullupStrength1 {
pub nodes: (Paren<Strength1>,),
}

12
sv-parser-syntaxtree/src/primitive_instances/primitive_terminals.rs
View File

@ -2,32 +2,32 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EnableTerminal {
pub nodes: (Expression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InoutTerminal {
pub nodes: (NetLvalue,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InputTerminal {
pub nodes: (Expression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NcontrolTerminal {
pub nodes: (Expression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OutputTerminal {
pub nodes: (NetLvalue,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PcontrolTerminal {
pub nodes: (Expression,),
}

20
sv-parser-syntaxtree/src/source_text/checker_items.rs
View File

@ -2,12 +2,12 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CheckerPortList {
pub nodes: (List<Symbol, CheckerPortItem>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CheckerPortItem {
pub nodes: (
Vec<AttributeInstance>,
@ -19,13 +19,13 @@ pub struct CheckerPortItem {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CheckerPortDirection {
Input(Box<Keyword>),
Output(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CheckerOrGenerateItem {
CheckerOrGenerateItemDeclaration(Box<CheckerOrGenerateItemDeclaration>),
InitialConstruct(Box<InitialConstruct>),
@ -36,7 +36,7 @@ pub enum CheckerOrGenerateItem {
CheckerGenerateItem(Box<CheckerGenerateItem>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CheckerOrGenerateItemDeclaration {
Data(Box<CheckerOrGenerateItemDeclarationData>),
FunctionDeclaration(Box<FunctionDeclaration>),
@ -50,27 +50,27 @@ pub enum CheckerOrGenerateItemDeclaration {
Empty(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CheckerOrGenerateItemDeclarationData {
pub nodes: (Option<Rand>, DataDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Rand {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CheckerOrGenerateItemDeclarationClocking {
pub nodes: (Keyword, Keyword, ClockingIdentifier, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CheckerOrGenerateItemDeclarationDisable {
pub nodes: (Keyword, Keyword, Keyword, ExpressionOrDist, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum CheckerGenerateItem {
LoopGenerateConstruct(Box<LoopGenerateConstruct>),
ConditionalGenerateConstruct(Box<ConditionalGenerateConstruct>),

50
sv-parser-syntaxtree/src/source_text/class_items.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClassItem {
Property(Box<ClassItemProperty>),
Method(Box<ClassItemMethod>),
@ -14,43 +14,43 @@ pub enum ClassItem {
Empty(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassItemProperty {
pub nodes: (Vec<AttributeInstance>, ClassProperty),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassItemMethod {
pub nodes: (Vec<AttributeInstance>, ClassMethod),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassItemConstraint {
pub nodes: (Vec<AttributeInstance>, ClassConstraint),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassItemDeclaration {
pub nodes: (Vec<AttributeInstance>, ClassDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassItemCovergroup {
pub nodes: (Vec<AttributeInstance>, CovergroupDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClassProperty {
NonConst(Box<ClassPropertyNonConst>),
Const(Box<ClassPropertyConst>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassPropertyNonConst {
pub nodes: (Vec<PropertyQualifier>, DataDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassPropertyConst {
pub nodes: (
Keyword,
@ -62,7 +62,7 @@ pub struct ClassPropertyConst {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClassMethod {
Task(Box<ClassMethodTask>),
Function(Box<ClassMethodFunction>),
@ -72,17 +72,17 @@ pub enum ClassMethod {
ExternConstructor(Box<ClassMethodExternConstructor>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassMethodTask {
pub nodes: (Vec<MethodQualifier>, TaskDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassMethodFunction {
pub nodes: (Vec<MethodQualifier>, FunctionDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassMethodPureVirtual {
pub nodes: (
Keyword,
@ -93,65 +93,65 @@ pub struct ClassMethodPureVirtual {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassMethodExternMethod {
pub nodes: (Keyword, Vec<MethodQualifier>, MethodPrototype, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassMethodConstructor {
pub nodes: (Vec<MethodQualifier>, ClassConstructorDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassMethodExternConstructor {
pub nodes: (Keyword, Vec<MethodQualifier>, ClassConstructorPrototype),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassConstructorPrototype {
pub nodes: (Keyword, Keyword, Option<Paren<Option<TfPortList>>>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClassConstraint {
ConstraintPrototype(Box<ConstraintPrototype>),
ConstraintDeclaration(Box<ConstraintDeclaration>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ClassItemQualifier {
Static(Box<Keyword>),
Protected(Box<Keyword>),
Local(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PropertyQualifier {
RandomQualifier(Box<RandomQualifier>),
ClassItemQualifier(Box<ClassItemQualifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum RandomQualifier {
Rand(Box<Keyword>),
Randc(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum MethodQualifier {
Virtual(Box<Keyword>),
PureVirtual(Box<(Keyword, Keyword)>),
ClassItemQualifier(Box<ClassItemQualifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum MethodPrototype {
TaskPrototype(Box<TaskPrototype>),
FunctionPrototype(Box<FunctionPrototype>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassConstructorDeclaration {
pub nodes: (
Keyword,
@ -173,7 +173,7 @@ pub struct ClassConstructorDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct New {
pub nodes: (Keyword,),
}

36
sv-parser-syntaxtree/src/source_text/configuration_source_text.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConfigDeclaration {
pub nodes: (
Keyword,
@ -16,7 +16,7 @@ pub struct ConfigDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DesignStatement {
pub nodes: (
Keyword,
@ -25,7 +25,7 @@ pub struct DesignStatement {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConfigRuleStatement {
Default(Box<ConfigRuleStatementDefault>),
InstLib(Box<ConfigRuleStatementInstLib>),
@ -34,64 +34,64 @@ pub enum ConfigRuleStatement {
CellUse(Box<ConfigRuleStatementCellUse>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConfigRuleStatementDefault {
pub nodes: (DefaultClause, LiblistClause, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConfigRuleStatementInstLib {
pub nodes: (InstClause, LiblistClause, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConfigRuleStatementInstUse {
pub nodes: (InstClause, UseClause, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConfigRuleStatementCellLib {
pub nodes: (CellClause, LiblistClause, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConfigRuleStatementCellUse {
pub nodes: (CellClause, UseClause, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DefaultClause {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InstClause {
pub nodes: (Keyword, InstName),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InstName {
pub nodes: (TopmoduleIdentifier, Vec<(Symbol, InstanceIdentifier)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CellClause {
pub nodes: (Keyword, Option<(LibraryIdentifier, Symbol)>, CellIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LiblistClause {
pub nodes: (Keyword, Vec<LibraryIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum UseClause {
Cell(Box<UseClauseCell>),
Named(Box<UseClauseNamed>),
CellNamed(Box<UseClauseCellNamed>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UseClauseCell {
pub nodes: (
Keyword,
@ -101,7 +101,7 @@ pub struct UseClauseCell {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UseClauseNamed {
pub nodes: (
Keyword,
@ -110,7 +110,7 @@ pub struct UseClauseNamed {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UseClauseCellNamed {
pub nodes: (
Keyword,
@ -121,7 +121,7 @@ pub struct UseClauseCellNamed {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Config {
pub nodes: (Keyword,),
}

52
sv-parser-syntaxtree/src/source_text/constraints.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintDeclaration {
pub nodes: (
Option<Static>,
@ -12,33 +12,33 @@ pub struct ConstraintDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Static {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintBlock {
pub nodes: (Brace<Vec<ConstraintBlockItem>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstraintBlockItem {
Solve(Box<ConstraintBlockItemSolve>),
ConstraintExpression(Box<ConstraintExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintBlockItemSolve {
pub nodes: (Keyword, SolveBeforeList, Keyword, SolveBeforeList, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SolveBeforeList {
pub nodes: (List<Symbol, ConstraintPrimary>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintPrimary {
pub nodes: (
Option<ImplicitClassHandleOrClassScope>,
@ -47,7 +47,7 @@ pub struct ConstraintPrimary {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstraintExpression {
Expression(Box<ConstraintExpressionExpression>),
UniquenessConstraint(Box<(UniquenessConstraint, Symbol)>),
@ -57,22 +57,22 @@ pub enum ConstraintExpression {
Disable(Box<ConstraintExpressionDisable>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintExpressionExpression {
pub nodes: (Option<Soft>, ExpressionOrDist, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Soft {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintExpressionArrow {
pub nodes: (Expression, Symbol, ConstraintSet),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintExpressionIf {
pub nodes: (
Keyword,
@ -82,7 +82,7 @@ pub struct ConstraintExpressionIf {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintExpressionForeach {
pub nodes: (
Keyword,
@ -91,54 +91,54 @@ pub struct ConstraintExpressionForeach {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintExpressionDisable {
pub nodes: (Keyword, Keyword, ConstraintPrimary, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UniquenessConstraint {
pub nodes: (Keyword, Brace<OpenRangeList>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstraintSet {
ConstraintExpression(Box<ConstraintExpression>),
Brace(Box<ConstraintSetBrace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintSetBrace {
pub nodes: (Brace<Vec<ConstraintExpression>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DistList {
pub nodes: (List<Symbol, DistItem>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DistItem {
pub nodes: (ValueRange, Option<DistWeight>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DistWeight {
Equal(Box<DistWeightEqual>),
Divide(Box<DistWeightDivide>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DistWeightEqual {
pub nodes: (Symbol, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DistWeightDivide {
pub nodes: (Symbol, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ConstraintPrototype {
pub nodes: (
Option<ConstraintPrototypeQualifier>,
@ -149,13 +149,13 @@ pub struct ConstraintPrototype {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ConstraintPrototypeQualifier {
Extern(Box<Keyword>),
Pure(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ExternConstraintDeclaration {
pub nodes: (
Option<Static>,
@ -166,7 +166,7 @@ pub struct ExternConstraintDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IdentifierList {
pub nodes: (List<Symbol, Identifier>,),
}

16
sv-parser-syntaxtree/src/source_text/interface_items.rs
View File

@ -2,45 +2,45 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum InterfaceOrGenerateItem {
Module(Box<InterfaceOrGenerateItemModule>),
Extern(Box<InterfaceOrGenerateItemExtern>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceOrGenerateItemModule {
pub nodes: (Vec<AttributeInstance>, ModuleCommonItem),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceOrGenerateItemExtern {
pub nodes: (Vec<AttributeInstance>, ExternTfDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ExternTfDeclaration {
Method(Box<ExternTfDeclarationMethod>),
Task(Box<ExternTfDeclarationTask>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ExternTfDeclarationMethod {
pub nodes: (Keyword, MethodPrototype, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ExternTfDeclarationTask {
pub nodes: (Keyword, Keyword, TaskPrototype, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum InterfaceItem {
PortDeclaration(Box<(PortDeclaration, Symbol)>),
NonPortInterfaceItem(Box<NonPortInterfaceItem>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NonPortInterfaceItem {
GenerateRegion(Box<GenerateRegion>),
InterfaceOrGenerateItem(Box<InterfaceOrGenerateItem>),

12
sv-parser-syntaxtree/src/source_text/library_source_text.rs
View File

@ -2,12 +2,12 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LibraryText {
pub nodes: (Vec<WhiteSpace>, Vec<LibraryDescription>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum LibraryDescription {
LibraryDeclaration(Box<LibraryDeclaration>),
IncludeStatement(Box<IncludeStatement>),
@ -15,7 +15,7 @@ pub enum LibraryDescription {
Null(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LibraryDeclaration {
pub nodes: (
Keyword,
@ -26,18 +26,18 @@ pub struct LibraryDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct IncludeStatement {
pub nodes: (Keyword, FilePathSpec, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum FilePathSpec {
Literal(StringLiteral),
NonLiteral(FilePathSpecNonLiteral),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FilePathSpecNonLiteral {
pub nodes: (Locate, Vec<WhiteSpace>),
}

54
sv-parser-syntaxtree/src/source_text/module_items.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ElaborationSystemTask {
TaskFatal(Box<ElaborationSystemTaskFatal>),
TaskError(Box<ElaborationSystemTaskError>),
@ -10,7 +10,7 @@ pub enum ElaborationSystemTask {
TaskInfo(Box<ElaborationSystemTaskInfo>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ElaborationSystemTaskFatal {
pub nodes: (
Keyword,
@ -19,29 +19,29 @@ pub struct ElaborationSystemTaskFatal {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ElaborationSystemTaskError {
pub nodes: (Keyword, Option<Paren<Option<ListOfArguments>>>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ElaborationSystemTaskWarning {
pub nodes: (Keyword, Option<Paren<Option<ListOfArguments>>>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ElaborationSystemTaskInfo {
pub nodes: (Keyword, Option<Paren<Option<ListOfArguments>>>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum FinishNumber {
Zero(Box<Symbol>),
One(Box<Symbol>),
Two(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModuleCommonItem {
ModuleOrGenerateItemDeclaration(Box<ModuleOrGenerateItemDeclaration>),
InterfaceInstantiation(Box<InterfaceInstantiation>),
@ -58,13 +58,13 @@ pub enum ModuleCommonItem {
ElaborationSystemTask(Box<ElaborationSystemTask>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModuleItem {
PortDeclaration(Box<(PortDeclaration, Symbol)>),
NonPortModuleItem(Box<NonPortModuleItem>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModuleOrGenerateItem {
Parameter(Box<ModuleOrGenerateItemParameter>),
Gate(Box<ModuleOrGenerateItemGate>),
@ -73,32 +73,32 @@ pub enum ModuleOrGenerateItem {
ModuleItem(Box<ModuleOrGenerateItemModuleItem>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleOrGenerateItemParameter {
pub nodes: (Vec<AttributeInstance>, ParameterOverride),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleOrGenerateItemGate {
pub nodes: (Vec<AttributeInstance>, GateInstantiation),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleOrGenerateItemUdp {
pub nodes: (Vec<AttributeInstance>, UdpInstantiation),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleOrGenerateItemModule {
pub nodes: (Vec<AttributeInstance>, ModuleInstantiation),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleOrGenerateItemModuleItem {
pub nodes: (Vec<AttributeInstance>, ModuleCommonItem),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModuleOrGenerateItemDeclaration {
PackageOrGenerateItemDeclaration(Box<PackageOrGenerateItemDeclaration>),
GenvarDeclaration(Box<GenvarDeclaration>),
@ -107,17 +107,17 @@ pub enum ModuleOrGenerateItemDeclaration {
Disable(Box<ModuleOrGenerateItemDeclarationDisable>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleOrGenerateItemDeclarationClocking {
pub nodes: (Keyword, Keyword, ClockingIdentifier, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleOrGenerateItemDeclarationDisable {
pub nodes: (Keyword, Keyword, Keyword, ExpressionOrDist, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NonPortModuleItem {
GenerateRegion(Box<GenerateRegion>),
ModuleOrGenerateItem(Box<ModuleOrGenerateItem>),
@ -129,23 +129,23 @@ pub enum NonPortModuleItem {
TimeunitsDeclaration(Box<TimeunitsDeclaration>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonPortModuleItemSpecparam {
pub nodes: (Vec<AttributeInstance>, SpecparamDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParameterOverride {
pub nodes: (Keyword, ListOfDefparamAssignments, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BindDirective {
Scope(Box<BindDirectiveScope>),
Instance(Box<BindDirectiveInstance>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BindDirectiveScope {
pub nodes: (
Keyword,
@ -155,28 +155,28 @@ pub struct BindDirectiveScope {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BindDirectiveInstance {
pub nodes: (Keyword, BindTargetInstance, BindInstantiation),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BindTargetScope {
ModuleIdentifier(Box<ModuleIdentifier>),
InterfaceIdentifier(Box<InterfaceIdentifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BindTargetInstance {
pub nodes: (HierarchicalIdentifier, ConstantBitSelect),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct BindTargetInstanceList {
pub nodes: (List<Symbol, BindTargetInstance>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum BindInstantiation {
ProgramInstantiation(Box<ProgramInstantiation>),
ModuleInstantiation(Box<ModuleInstantiation>),

62
sv-parser-syntaxtree/src/source_text/module_parameters_and_ports.rs
View File

@ -2,14 +2,14 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ParameterPortList {
Assignment(Box<ParameterPortListAssignment>),
Declaration(Box<ParameterPortListDeclaration>),
Empty(Box<(Symbol, Symbol, Symbol)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParameterPortListAssignment {
pub nodes: (
Symbol,
@ -20,12 +20,12 @@ pub struct ParameterPortListAssignment {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParameterPortListDeclaration {
pub nodes: (Symbol, Paren<List<Symbol, ParameterPortDeclaration>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ParameterPortDeclaration {
ParameterDeclaration(Box<ParameterDeclaration>),
LocalParameterDeclaration(Box<LocalParameterDeclaration>),
@ -33,27 +33,27 @@ pub enum ParameterPortDeclaration {
TypeList(Box<ParameterPortDeclarationTypeList>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParameterPortDeclarationParamList {
pub nodes: (DataType, ListOfParamAssignments),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParameterPortDeclarationTypeList {
pub nodes: (Keyword, ListOfTypeAssignments),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfPorts {
pub nodes: (Paren<List<Symbol, Port>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfPortDeclarations {
pub nodes: (Paren<Option<List<Symbol, (Vec<AttributeInstance>, AnsiPortDeclaration)>>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PortDeclaration {
Inout(Box<PortDeclarationInout>),
Input(Box<PortDeclarationInput>),
@ -62,64 +62,64 @@ pub enum PortDeclaration {
Interface(Box<PortDeclarationInterface>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PortDeclarationInout {
pub nodes: (Vec<AttributeInstance>, InoutDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PortDeclarationInput {
pub nodes: (Vec<AttributeInstance>, InputDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PortDeclarationOutput {
pub nodes: (Vec<AttributeInstance>, OutputDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PortDeclarationRef {
pub nodes: (Vec<AttributeInstance>, RefDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PortDeclarationInterface {
pub nodes: (Vec<AttributeInstance>, InterfacePortDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Port {
NonNamed(Box<PortNonNamed>),
Named(Box<PortNamed>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PortNonNamed {
pub nodes: (Option<PortExpression>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PortNamed {
pub nodes: (Symbol, PortIdentifier, Paren<Option<PortExpression>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PortExpression {
PortReference(Box<PortReference>),
Brace(Box<PortExpressionBrace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PortExpressionBrace {
pub nodes: (Brace<List<Symbol, PortReference>>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PortReference {
pub nodes: (PortIdentifier, ConstantSelect),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PortDirection {
Input(Box<Keyword>),
Output(Box<Keyword>),
@ -127,45 +127,45 @@ pub enum PortDirection {
Ref(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NetPortHeader {
pub nodes: (Option<PortDirection>, NetPortType),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct VariablePortHeader {
pub nodes: (Option<PortDirection>, VariablePortType),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum InterfacePortHeader {
Identifier(Box<InterfacePortHeaderIdentifier>),
Interface(Box<InterfacePortHeaderInterface>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfacePortHeaderIdentifier {
pub nodes: (InterfaceIdentifier, Option<(Symbol, ModportIdentifier)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfacePortHeaderInterface {
pub nodes: (Keyword, Option<(Symbol, ModportIdentifier)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NetPortHeaderOrInterfacePortHeader {
NetPortHeader(Box<NetPortHeader>),
InterfacePortHeader(Box<InterfacePortHeader>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum AnsiPortDeclaration {
Net(Box<AnsiPortDeclarationNet>),
Variable(Box<AnsiPortDeclarationVariable>),
Paren(Box<AnsiPortDeclarationParen>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AnsiPortDeclarationNet {
pub nodes: (
Option<NetPortHeaderOrInterfacePortHeader>,
@ -175,7 +175,7 @@ pub struct AnsiPortDeclarationNet {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AnsiPortDeclarationVariable {
pub nodes: (
Option<VariablePortHeader>,
@ -185,7 +185,7 @@ pub struct AnsiPortDeclarationVariable {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AnsiPortDeclarationParen {
pub nodes: (
Option<PortDirection>,

8
sv-parser-syntaxtree/src/source_text/package_items.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PackageItem {
PackageOrGenerateItemDeclaration(Box<PackageOrGenerateItemDeclaration>),
AnonymousProgram(Box<AnonymousProgram>),
@ -10,7 +10,7 @@ pub enum PackageItem {
TimeunitsDeclaration(Box<TimeunitsDeclaration>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PackageOrGenerateItemDeclaration {
NetDeclaration(Box<NetDeclaration>),
DataDeclaration(Box<DataDeclaration>),
@ -29,12 +29,12 @@ pub enum PackageOrGenerateItemDeclaration {
Empty(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct AnonymousProgram {
pub nodes: (Keyword, Symbol, Vec<AnonymousProgramItem>, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum AnonymousProgramItem {
TaskDeclaration(Box<TaskDeclaration>),
FunctionDeclaration(Box<FunctionDeclaration>),

16
sv-parser-syntaxtree/src/source_text/program_items.rs
View File

@ -2,13 +2,13 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ProgramItem {
PortDeclaration(Box<(PortDeclaration, Symbol)>),
NonPortProgramItem(Box<NonPortProgramItem>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NonPortProgramItem {
Assign(Box<NonPortProgramItemAssign>),
Module(Box<NonPortProgramItemModule>),
@ -19,32 +19,32 @@ pub enum NonPortProgramItem {
ProgramGenerateItem(Box<ProgramGenerateItem>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonPortProgramItemAssign {
pub nodes: (Vec<AttributeInstance>, ContinuousAssign),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonPortProgramItemModule {
pub nodes: (Vec<AttributeInstance>, ModuleOrGenerateItemDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonPortProgramItemInitial {
pub nodes: (Vec<AttributeInstance>, InitialConstruct),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonPortProgramItemFinal {
pub nodes: (Vec<AttributeInstance>, FinalConstruct),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NonPortProgramItemAssertion {
pub nodes: (Vec<AttributeInstance>, ConcurrentAssertionItem),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ProgramGenerateItem {
LoopGenerateConstruct(Box<LoopGenerateConstruct>),
ConditionalGenerateConstruct(Box<ConditionalGenerateConstruct>),

86
sv-parser-syntaxtree/src/source_text/system_verilog_source_text.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SourceText {
pub nodes: (
Vec<WhiteSpace>,
@ -11,7 +11,7 @@ pub struct SourceText {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum Description {
ModuleDeclaration(Box<ModuleDeclaration>),
UdpDeclaration(Box<UdpDeclaration>),
@ -24,17 +24,17 @@ pub enum Description {
ConfigDeclaration(Box<ConfigDeclaration>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DescriptionPackageItem {
pub nodes: (Vec<AttributeInstance>, PackageItem),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DescriptionBindDirective {
pub nodes: (Vec<AttributeInstance>, BindDirective),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleNonansiHeader {
pub nodes: (
Vec<AttributeInstance>,
@ -48,7 +48,7 @@ pub struct ModuleNonansiHeader {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleAnsiHeader {
pub nodes: (
Vec<AttributeInstance>,
@ -62,7 +62,7 @@ pub struct ModuleAnsiHeader {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModuleDeclaration {
Nonansi(Box<ModuleDeclarationNonansi>),
Ansi(Box<ModuleDeclarationAnsi>),
@ -71,7 +71,7 @@ pub enum ModuleDeclaration {
ExternAnsi(Box<ModuleDeclarationExternAnsi>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleDeclarationNonansi {
pub nodes: (
ModuleNonansiHeader,
@ -82,7 +82,7 @@ pub struct ModuleDeclarationNonansi {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleDeclarationAnsi {
pub nodes: (
ModuleAnsiHeader,
@ -93,7 +93,7 @@ pub struct ModuleDeclarationAnsi {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleDeclarationWildcard {
pub nodes: (
Vec<AttributeInstance>,
@ -109,23 +109,23 @@ pub struct ModuleDeclarationWildcard {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleDeclarationExternNonansi {
pub nodes: (Keyword, ModuleNonansiHeader),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ModuleDeclarationExternAnsi {
pub nodes: (Keyword, ModuleAnsiHeader),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ModuleKeyword {
Module(Box<Keyword>),
Macromodule(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum InterfaceDeclaration {
Nonansi(Box<InterfaceDeclarationNonansi>),
Ansi(Box<InterfaceDeclarationAnsi>),
@ -134,7 +134,7 @@ pub enum InterfaceDeclaration {
ExternAnsi(Box<InterfaceDeclarationExternAnsi>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceDeclarationNonansi {
pub nodes: (
InterfaceNonansiHeader,
@ -145,7 +145,7 @@ pub struct InterfaceDeclarationNonansi {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceDeclarationAnsi {
pub nodes: (
InterfaceAnsiHeader,
@ -156,7 +156,7 @@ pub struct InterfaceDeclarationAnsi {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceDeclarationWildcard {
pub nodes: (
Vec<AttributeInstance>,
@ -172,17 +172,17 @@ pub struct InterfaceDeclarationWildcard {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceDeclarationExternNonansi {
pub nodes: (Keyword, InterfaceNonansiHeader),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceDeclarationExternAnsi {
pub nodes: (Keyword, InterfaceAnsiHeader),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceNonansiHeader {
pub nodes: (
Vec<AttributeInstance>,
@ -196,7 +196,7 @@ pub struct InterfaceNonansiHeader {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceAnsiHeader {
pub nodes: (
Vec<AttributeInstance>,
@ -210,7 +210,7 @@ pub struct InterfaceAnsiHeader {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ProgramDeclaration {
Nonansi(Box<ProgramDeclarationNonansi>),
Ansi(Box<ProgramDeclarationAnsi>),
@ -219,7 +219,7 @@ pub enum ProgramDeclaration {
ExternAnsi(Box<ProgramDeclarationExternAnsi>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProgramDeclarationNonansi {
pub nodes: (
ProgramNonansiHeader,
@ -230,7 +230,7 @@ pub struct ProgramDeclarationNonansi {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProgramDeclarationAnsi {
pub nodes: (
ProgramAnsiHeader,
@ -241,7 +241,7 @@ pub struct ProgramDeclarationAnsi {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProgramDeclarationWildcard {
pub nodes: (
Vec<AttributeInstance>,
@ -256,17 +256,17 @@ pub struct ProgramDeclarationWildcard {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProgramDeclarationExternNonansi {
pub nodes: (Keyword, ProgramNonansiHeader),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProgramDeclarationExternAnsi {
pub nodes: (Keyword, ProgramAnsiHeader),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProgramNonansiHeader {
pub nodes: (
Vec<AttributeInstance>,
@ -280,7 +280,7 @@ pub struct ProgramNonansiHeader {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ProgramAnsiHeader {
pub nodes: (
Vec<AttributeInstance>,
@ -294,7 +294,7 @@ pub struct ProgramAnsiHeader {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CheckerDeclaration {
pub nodes: (
Keyword,
@ -307,7 +307,7 @@ pub struct CheckerDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ClassDeclaration {
pub nodes: (
Option<Virtual>,
@ -324,17 +324,17 @@ pub struct ClassDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Virtual {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceClassType {
pub nodes: (PsClassIdentifier, Option<ParameterValueAssignment>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceClassDeclaration {
pub nodes: (
Keyword,
@ -349,7 +349,7 @@ pub struct InterfaceClassDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum InterfaceClassItem {
TypeDeclaration(Box<TypeDeclaration>),
Method(Box<InterfaceClassItemMethod>),
@ -358,17 +358,17 @@ pub enum InterfaceClassItem {
Null(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceClassItemMethod {
pub nodes: (Vec<AttributeInstance>, InterfaceClassMethod),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InterfaceClassMethod {
pub nodes: (Keyword, Keyword, MethodPrototype, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PackageDeclaration {
pub nodes: (
Vec<AttributeInstance>,
@ -383,7 +383,7 @@ pub struct PackageDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TimeunitsDeclaration {
Timeunit(Box<TimeunitsDeclarationTimeunit>),
Timeprecision(Box<TimeunitsDeclarationTimeprecision>),
@ -391,22 +391,22 @@ pub enum TimeunitsDeclaration {
TimeprecisionTimeunit(Box<TimeunitsDeclarationTimeprecisionTimeunit>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimeunitsDeclarationTimeunit {
pub nodes: (Keyword, TimeLiteral, Option<(Symbol, TimeLiteral)>, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimeunitsDeclarationTimeprecision {
pub nodes: (Keyword, TimeLiteral, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimeunitsDeclarationTimeunitTimeprecision {
pub nodes: (Keyword, TimeLiteral, Symbol, Keyword, TimeLiteral, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimeunitsDeclarationTimeprecisionTimeunit {
pub nodes: (Keyword, TimeLiteral, Symbol, Keyword, TimeLiteral, Symbol),
}

16
sv-parser-syntaxtree/src/special_node.rs
View File

@ -2,44 +2,44 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Symbol {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Keyword {
pub nodes: (Locate, Vec<WhiteSpace>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum WhiteSpace {
Space(Box<Locate>),
Comment(Box<Comment>),
CompilerDirective(Box<CompilerDirective>),
}
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq)]
pub struct Paren<T> {
pub nodes: (Symbol, T, Symbol),
}
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq)]
pub struct Brace<T> {
pub nodes: (Symbol, T, Symbol),
}
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq)]
pub struct Bracket<T> {
pub nodes: (Symbol, T, Symbol),
}
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq)]
pub struct ApostropheBrace<T> {
pub nodes: (Symbol, T, Symbol),
}
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq)]
pub struct List<T, U> {
pub nodes: (U, Vec<(T, U)>),
}

8
sv-parser-syntaxtree/src/specify_section/specify_block_declaration.rs
View File

@ -2,12 +2,12 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SpecifyBlock {
pub nodes: (Keyword, Vec<SpecifyItem>, Keyword),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SpecifyItem {
SpecparamDeclaration(Box<SpecparamDeclaration>),
PulsestyleDeclaration(Box<PulsestyleDeclaration>),
@ -16,12 +16,12 @@ pub enum SpecifyItem {
SystemTimingCheck(Box<SystemTimingCheck>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PulsestyleDeclaration {
pub nodes: (Keyword, ListOfPathOutputs, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ShowcancelledDeclaration {
pub nodes: (Keyword, ListOfPathOutputs, Symbol),
}

12
sv-parser-syntaxtree/src/specify_section/specify_block_terminals.rs
View File

@ -2,36 +2,36 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SpecifyInputTerminalDescriptor {
pub nodes: (InputIdentifier, Option<Bracket<ConstantRangeExpression>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SpecifyOutputTerminalDescriptor {
pub nodes: (OutputIdentifier, Option<Bracket<ConstantRangeExpression>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum InputIdentifier {
InputPortIdentifier(Box<InputPortIdentifier>),
InoutPortIdentifier(Box<InoutPortIdentifier>),
Interface(Box<InputIdentifierInterface>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InputIdentifierInterface {
pub nodes: (InterfaceIdentifier, Symbol, PortIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum OutputIdentifier {
OutputPortIdentifier(Box<OutputPortIdentifier>),
InoutPortIdentifier(Box<InoutPortIdentifier>),
Interface(Box<OutputIdentifierInterface>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OutputIdentifierInterface {
pub nodes: (InterfaceIdentifier, Symbol, PortIdentifier),
}

16
sv-parser-syntaxtree/src/specify_section/specify_path_declarations.rs
View File

@ -2,30 +2,30 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PathDeclaration {
SimplePathDeclaration(Box<(SimplePathDeclaration, Symbol)>),
EdgeSensitivePathDeclaration(Box<(EdgeSensitivePathDeclaration, Symbol)>),
StateDependentPathDeclaration(Box<(StateDependentPathDeclaration, Symbol)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SimplePathDeclaration {
Parallel(Box<SimplePathDeclarationParallel>),
Full(Box<SimplePathDeclarationFull>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SimplePathDeclarationParallel {
pub nodes: (ParallelPathDescription, Symbol, PathDelayValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SimplePathDeclarationFull {
pub nodes: (FullPathDescription, Symbol, PathDelayValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParallelPathDescription {
pub nodes: (
Paren<(
@ -37,7 +37,7 @@ pub struct ParallelPathDescription {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FullPathDescription {
pub nodes: (
Paren<(
@ -49,12 +49,12 @@ pub struct FullPathDescription {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfPathInputs {
pub nodes: (List<Symbol, SpecifyInputTerminalDescriptor>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfPathOutputs {
pub nodes: (List<Symbol, SpecifyOutputTerminalDescriptor>,),
}

34
sv-parser-syntaxtree/src/specify_section/specify_path_delays.rs
View File

@ -2,48 +2,48 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum PathDelayValue {
ListOfPathDelayExpressions(Box<ListOfPathDelayExpressions>),
Paren(Box<PathDelayValueParen>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PathDelayValueParen {
pub nodes: (Paren<ListOfPathDelayExpressions>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ListOfPathDelayExpressions {
pub nodes: (List<Symbol, TPathDelayExpression>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TPathDelayExpression {
pub nodes: (PathDelayExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PathDelayExpression {
pub nodes: (ConstantMintypmaxExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum EdgeSensitivePathDeclaration {
Parallel(Box<EdgeSensitivePathDeclarationParallel>),
Full(Box<EdgeSensitivePathDeclarationFull>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EdgeSensitivePathDeclarationParallel {
pub nodes: (ParallelEdgeSensitivePathDescription, Symbol, PathDelayValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EdgeSensitivePathDeclarationFull {
pub nodes: (FullEdgeSensitivePathDescription, Symbol, PathDelayValue),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ParallelEdgeSensitivePathDescription {
pub nodes: (
Paren<(
@ -61,7 +61,7 @@ pub struct ParallelEdgeSensitivePathDescription {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FullEdgeSensitivePathDescription {
pub nodes: (
Paren<(
@ -79,31 +79,31 @@ pub struct FullEdgeSensitivePathDescription {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DataSourceExpression {
pub nodes: (Expression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum EdgeIdentifier {
Posedge(Box<Keyword>),
Negedge(Box<Keyword>),
Edge(Box<Keyword>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum StateDependentPathDeclaration {
IfSimple(Box<StateDependentPathDeclarationIfSimple>),
IfEdgeSensitive(Box<StateDependentPathDeclarationIfEdgeSensitive>),
IfNone(Box<StateDependentPathDeclarationIfNone>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StateDependentPathDeclarationIfSimple {
pub nodes: (Keyword, Paren<ModulePathExpression>, SimplePathDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StateDependentPathDeclarationIfEdgeSensitive {
pub nodes: (
Keyword,
@ -112,12 +112,12 @@ pub struct StateDependentPathDeclarationIfEdgeSensitive {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StateDependentPathDeclarationIfNone {
pub nodes: (Keyword, SimplePathDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PolarityOperator {
pub nodes: (Symbol,),
}

32
sv-parser-syntaxtree/src/specify_section/system_timing_check_command_arguments.rs
View File

@ -2,84 +2,84 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimecheckCondition {
pub nodes: (MintypmaxExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ControlledReferenceEvent {
pub nodes: (ControlledTimingCheckEvent,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DataEvent {
pub nodes: (TimingCheckEvent,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DelayedData {
TerminalIdentifier(Box<TerminalIdentifier>),
WithMintypmax(Box<DelayedDataWithMintypmax>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DelayedDataWithMintypmax {
pub nodes: (TerminalIdentifier, Bracket<ConstantMintypmaxExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum DelayedReference {
TerminalIdentifier(Box<TerminalIdentifier>),
WithMintypmax(Box<DelayedReferenceWithMintypmax>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct DelayedReferenceWithMintypmax {
pub nodes: (TerminalIdentifier, Bracket<ConstantMintypmaxExpression>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EndEdgeOffset {
pub nodes: (MintypmaxExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EventBasedFlag {
pub nodes: (ConstantExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Notifier {
pub nodes: (VariableIdentifier,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ReferenceEvent {
pub nodes: (TimingCheckEvent,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RemainActiveFlag {
pub nodes: (ConstantMintypmaxExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimestampCondition {
pub nodes: (MintypmaxExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct StartEdgeOffset {
pub nodes: (MintypmaxExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct Threshold {
pub nodes: (ConstantExpression,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimingCheckLimit {
pub nodes: (Expression,),
}

26
sv-parser-syntaxtree/src/specify_section/system_timing_check_commands.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SystemTimingCheck {
SetupTimingCheck(Box<SetupTimingCheck>),
HoldTimingCheck(Box<HoldTimingCheck>),
@ -18,7 +18,7 @@ pub enum SystemTimingCheck {
NochangeTimingCheck(Box<NochangeTimingCheck>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SetupTimingCheck {
pub nodes: (
Keyword,
@ -34,7 +34,7 @@ pub struct SetupTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct HoldTimingCheck {
pub nodes: (
Keyword,
@ -50,7 +50,7 @@ pub struct HoldTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SetupholdTimingCheck {
pub nodes: (
Keyword,
@ -84,7 +84,7 @@ pub struct SetupholdTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RecoveryTimingCheck {
pub nodes: (
Keyword,
@ -100,7 +100,7 @@ pub struct RecoveryTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RemovalTimingCheck {
pub nodes: (
Keyword,
@ -116,7 +116,7 @@ pub struct RemovalTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct RecremTimingCheck {
pub nodes: (
Keyword,
@ -150,7 +150,7 @@ pub struct RecremTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SkewTimingCheck {
pub nodes: (
Keyword,
@ -166,7 +166,7 @@ pub struct SkewTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimeskewTimingCheck {
pub nodes: (
Keyword,
@ -190,7 +190,7 @@ pub struct TimeskewTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct FullskewTimingCheck {
pub nodes: (
Keyword,
@ -216,7 +216,7 @@ pub struct FullskewTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct PeriodTimingCheck {
pub nodes: (
Keyword,
@ -230,7 +230,7 @@ pub struct PeriodTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct WidthTimingCheck {
pub nodes: (
Keyword,
@ -246,7 +246,7 @@ pub struct WidthTimingCheck {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct NochangeTimingCheck {
pub nodes: (
Keyword,

24
sv-parser-syntaxtree/src/specify_section/system_timing_check_event_definitions.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimingCheckEvent {
pub nodes: (
Option<TimingCheckEventControl>,
@ -11,7 +11,7 @@ pub struct TimingCheckEvent {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ControlledTimingCheckEvent {
pub nodes: (
TimingCheckEventControl,
@ -20,7 +20,7 @@ pub struct ControlledTimingCheckEvent {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TimingCheckEventControl {
Posedge(Box<Keyword>),
Negedge(Box<Keyword>),
@ -28,51 +28,51 @@ pub enum TimingCheckEventControl {
EdgeControlSpecifier(Box<EdgeControlSpecifier>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SpecifyTerminalDescriptor {
SpecifyInputTerminalDescriptor(Box<SpecifyInputTerminalDescriptor>),
SpecifyOutputTerminalDescriptor(Box<SpecifyOutputTerminalDescriptor>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EdgeControlSpecifier {
pub nodes: (Keyword, Bracket<List<Symbol, EdgeDescriptor>>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EdgeDescriptor {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum TimingCheckCondition {
ScalarTimingCheckCondition(Box<ScalarTimingCheckCondition>),
Paren(Box<TimingCheckConditionParen>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct TimingCheckConditionParen {
pub nodes: (Paren<ScalarTimingCheckCondition>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum ScalarTimingCheckCondition {
Expression(Box<Expression>),
Unary(Box<ScalarTimingCheckConditionUnary>),
Binary(Box<ScalarTimingCheckConditionBinary>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ScalarTimingCheckConditionUnary {
pub nodes: (Symbol, Expression),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ScalarTimingCheckConditionBinary {
pub nodes: (Expression, Symbol, ScalarConstant),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct ScalarConstant {
pub nodes: (Keyword,),
}

34
sv-parser-syntaxtree/src/udp_declaration_and_instantiation/udp_body.rs
View File

@ -2,13 +2,13 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum UdpBody {
CombinationalBody(Box<CombinationalBody>),
SequentialBody(Box<SequentialBody>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CombinationalBody {
pub nodes: (
Keyword,
@ -18,12 +18,12 @@ pub struct CombinationalBody {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CombinationalEntry {
pub nodes: (LevelInputList, Symbol, OutputSymbol, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequentialBody {
pub nodes: (
Option<UdpInitialStatement>,
@ -34,17 +34,17 @@ pub struct SequentialBody {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpInitialStatement {
pub nodes: (Keyword, OutputPortIdentifier, Symbol, InitVal, Symbol),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct InitVal {
pub nodes: (Keyword,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct SequentialEntry {
pub nodes: (
SeqInputList,
@ -56,55 +56,55 @@ pub struct SequentialEntry {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum SeqInputList {
LevelInputList(Box<LevelInputList>),
EdgeInputList(Box<EdgeInputList>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LevelInputList {
pub nodes: (LevelSymbol, Vec<LevelSymbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EdgeInputList {
pub nodes: (Vec<LevelSymbol>, EdgeIndicator, Vec<LevelSymbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum EdgeIndicator {
Paren(Box<EdgeIndicatorParen>),
EdgeSymbol(Box<EdgeSymbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EdgeIndicatorParen {
pub nodes: (Paren<(LevelSymbol, LevelSymbol)>,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct CurrentState {
pub nodes: (LevelSymbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum NextState {
OutputSymbol(Box<OutputSymbol>),
Minus(Box<Symbol>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct OutputSymbol {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct LevelSymbol {
pub nodes: (Symbol,),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct EdgeSymbol {
pub nodes: (Symbol,),
}

16
sv-parser-syntaxtree/src/udp_declaration_and_instantiation/udp_declaration.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpNonansiDeclaration {
pub nodes: (
Vec<AttributeInstance>,
@ -13,7 +13,7 @@ pub struct UdpNonansiDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpAnsiDeclaration {
pub nodes: (
Vec<AttributeInstance>,
@ -24,7 +24,7 @@ pub struct UdpAnsiDeclaration {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum UdpDeclaration {
Nonansi(Box<UdpDeclarationNonansi>),
Ansi(Box<UdpDeclarationAnsi>),
@ -33,7 +33,7 @@ pub enum UdpDeclaration {
Wildcard(Box<UdpDeclarationWildcard>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpDeclarationNonansi {
pub nodes: (
UdpNonansiDeclaration,
@ -45,7 +45,7 @@ pub struct UdpDeclarationNonansi {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpDeclarationAnsi {
pub nodes: (
UdpAnsiDeclaration,
@ -55,17 +55,17 @@ pub struct UdpDeclarationAnsi {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpDeclarationExternNonansi {
pub nodes: (Keyword, UdpNonansiDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpDeclarationExternAnsi {
pub nodes: (Keyword, UdpAnsiDeclaration),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpDeclarationWildcard {
pub nodes: (
Vec<AttributeInstance>,

4
sv-parser-syntaxtree/src/udp_declaration_and_instantiation/udp_instantiation.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpInstantiation {
pub nodes: (
UdpIdentifier,
@ -13,7 +13,7 @@ pub struct UdpInstantiation {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpInstance {
pub nodes: (
Option<NameOfInstance>,

16
sv-parser-syntaxtree/src/udp_declaration_and_instantiation/udp_ports.rs
View File

@ -2,7 +2,7 @@ use crate::*;
// -----------------------------------------------------------------------------
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpPortList {
pub nodes: (
OutputPortIdentifier,
@ -11,7 +11,7 @@ pub struct UdpPortList {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpDeclarationPortList {
pub nodes: (
UdpOutputDeclaration,
@ -20,25 +20,25 @@ pub struct UdpDeclarationPortList {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum UdpPortDeclaration {
UdpOutputDeclaration(Box<(UdpOutputDeclaration, Symbol)>),
UdpInputDeclaration(Box<(UdpInputDeclaration, Symbol)>),
UdpRegDeclaration(Box<(UdpRegDeclaration, Symbol)>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub enum UdpOutputDeclaration {
Nonreg(Box<UdpOutputDeclarationNonreg>),
Reg(Box<UdpOutputDeclarationReg>),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpOutputDeclarationNonreg {
pub nodes: (Vec<AttributeInstance>, Keyword, PortIdentifier),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpOutputDeclarationReg {
pub nodes: (
Vec<AttributeInstance>,
@ -49,12 +49,12 @@ pub struct UdpOutputDeclarationReg {
),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpInputDeclaration {
pub nodes: (Vec<AttributeInstance>, Keyword, ListOfUdpPortIdentifiers),
}
#[derive(Clone, Debug, Node)]
#[derive(Clone, Debug, PartialEq, Node)]
pub struct UdpRegDeclaration {
pub nodes: (Vec<AttributeInstance>, Keyword, VariableIdentifier),
}