From 8dda1ab3de97af88fca82c2e5a82c0e5bfcf4308 Mon Sep 17 00:00:00 2001 From: dalance Date: Fri, 12 Jul 2019 16:14:36 +0900 Subject: [PATCH] Refactoring --- README.md | 6 +- .../assertion_statements.rs | 129 +++--- .../behavioral_statements/clocking_block.rs | 397 +++++++++++++----- .../behavioral_statements/randsequence.rs | 271 +++++++----- 4 files changed, 532 insertions(+), 271 deletions(-) diff --git a/README.md b/README.md index 9950cf5..963360d 100644 --- a/README.md +++ b/README.md @@ -55,9 +55,9 @@ A parser library for System Verilog. | behavioral_statements | patterns | x | x | | | behavioral_statements | looping_statements | x | x | | | behavioral_statements | subroutine_call_statements | x | x | | -| behavioral_statements | assertion_statements | | | | -| behavioral_statements | clocking_block | | | | -| behavioral_statements | randsequence | | | | +| behavioral_statements | assertion_statements | x | x | | +| behavioral_statements | clocking_block | x | x | | +| behavioral_statements | randsequence | x | x | | | specify_section | specify_block_declaration | | | | | specify_section | specify_path_declarations | | | | | specify_section | specify_block_terminals | | | | diff --git a/src/parser/behavioral_statements/assertion_statements.rs b/src/parser/behavioral_statements/assertion_statements.rs index b0c9901..33baa59 100644 --- a/src/parser/behavioral_statements/assertion_statements.rs +++ b/src/parser/behavioral_statements/assertion_statements.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; use nom::branch::*; use nom::combinator::*; @@ -15,7 +16,7 @@ pub enum AssertionItem<'a> { #[derive(Debug)] pub struct DeferredImmediateAssetionItem<'a> { pub nodes: ( - Option>, + Option<(BlockIdentifier<'a>, Symbol<'a>)>, DeferredImmediateAssertionStatement<'a>, ), } @@ -42,17 +43,17 @@ pub enum SimpleImmediateAssertionStatement<'a> { #[derive(Debug)] pub struct SimpleImmediateAssertStatement<'a> { - pub nodes: (Expression<'a>, ActionBlock<'a>), + pub nodes: (Symbol<'a>, Paren<'a, Expression<'a>>, ActionBlock<'a>), } #[derive(Debug)] pub struct SimpleImmediateAssumeStatement<'a> { - pub nodes: (Expression<'a>, ActionBlock<'a>), + pub nodes: (Symbol<'a>, Paren<'a, Expression<'a>>, ActionBlock<'a>), } #[derive(Debug)] pub struct SimpleImmediateCoverStatement<'a> { - pub nodes: (Expression<'a>, StatementOrNull<'a>), + pub nodes: (Symbol<'a>, Paren<'a, Expression<'a>>, StatementOrNull<'a>), } #[derive(Debug)] @@ -64,23 +65,38 @@ pub enum DeferredImmediateAssertionStatement<'a> { #[derive(Debug)] pub struct DeferredImmediateAssertStatement<'a> { - pub nodes: (AssertTiming, Expression<'a>, ActionBlock<'a>), + pub nodes: ( + Symbol<'a>, + AssertTiming<'a>, + Paren<'a, Expression<'a>>, + ActionBlock<'a>, + ), } #[derive(Debug)] pub struct DeferredImmediateAssumeStatement<'a> { - pub nodes: (AssertTiming, Expression<'a>, ActionBlock<'a>), + pub nodes: ( + Symbol<'a>, + AssertTiming<'a>, + Paren<'a, Expression<'a>>, + ActionBlock<'a>, + ), } #[derive(Debug)] pub struct DeferredImmediateCoverStatement<'a> { - pub nodes: (AssertTiming, Expression<'a>, StatementOrNull<'a>), + pub nodes: ( + Symbol<'a>, + AssertTiming<'a>, + Paren<'a, Expression<'a>>, + StatementOrNull<'a>, + ), } -#[derive(Debug)] -pub enum AssertTiming { - Zero, - Final, +#[derive(Debug, Node)] +pub enum AssertTiming<'a> { + Zero(Symbol<'a>), + Final(Symbol<'a>), } // ----------------------------------------------------------------------------- @@ -95,9 +111,9 @@ pub fn assertion_item(s: Span) -> IResult { } pub fn deferred_immediate_assertion_item(s: Span) -> IResult { - let (s, x) = opt(terminated(block_identifier, symbol(":")))(s)?; - let (s, y) = deferred_immediate_assertion_statement(s)?; - Ok((s, DeferredImmediateAssetionItem { nodes: (x, y) })) + let (s, a) = opt(pair(block_identifier, symbol(":")))(s)?; + let (s, b) = deferred_immediate_assertion_statement(s)?; + Ok((s, DeferredImmediateAssetionItem { nodes: (a, b) })) } pub fn procedural_assertion_statement(s: Span) -> IResult { @@ -142,30 +158,24 @@ pub fn simple_immediate_assertion_statement( } pub fn simple_immediate_assert_statement(s: Span) -> IResult { - let (s, _) = symbol("assert")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, y) = action_block(s)?; - Ok((s, SimpleImmediateAssertStatement { nodes: (x, y) })) + let (s, a) = symbol("assert")(s)?; + let (s, b) = paren2(expression)(s)?; + let (s, c) = action_block(s)?; + Ok((s, SimpleImmediateAssertStatement { nodes: (a, b, c) })) } pub fn simple_immediate_assume_statement(s: Span) -> IResult { - let (s, _) = symbol("assume")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, y) = action_block(s)?; - Ok((s, SimpleImmediateAssumeStatement { nodes: (x, y) })) + let (s, a) = symbol("assume")(s)?; + let (s, b) = paren2(expression)(s)?; + let (s, c) = action_block(s)?; + Ok((s, SimpleImmediateAssumeStatement { nodes: (a, b, c) })) } pub fn simple_immediate_cover_statement(s: Span) -> IResult { - let (s, _) = symbol("cover")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, y) = statement_or_null(s)?; - Ok((s, SimpleImmediateCoverStatement { nodes: (x, y) })) + let (s, a) = symbol("cover")(s)?; + let (s, b) = paren2(expression)(s)?; + let (s, c) = statement_or_null(s)?; + Ok((s, SimpleImmediateCoverStatement { nodes: (a, b, c) })) } pub fn deferred_immediate_assertion_statement( @@ -187,43 +197,52 @@ pub fn deferred_immediate_assertion_statement( pub fn deferred_immediate_assert_statement( s: Span, ) -> IResult { - let (s, _) = symbol("assert")(s)?; - let (s, x) = assert_timing(s)?; - let (s, _) = symbol("(")(s)?; - let (s, y) = expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, z) = action_block(s)?; - Ok((s, DeferredImmediateAssertStatement { nodes: (x, y, z) })) + let (s, a) = symbol("assert")(s)?; + let (s, b) = assert_timing(s)?; + let (s, c) = paren2(expression)(s)?; + let (s, d) = action_block(s)?; + Ok(( + s, + DeferredImmediateAssertStatement { + nodes: (a, b, c, d), + }, + )) } pub fn deferred_immediate_assume_statement( s: Span, ) -> IResult { - let (s, _) = symbol("assume")(s)?; - let (s, x) = assert_timing(s)?; - let (s, _) = symbol("(")(s)?; - let (s, y) = expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, z) = action_block(s)?; - Ok((s, DeferredImmediateAssumeStatement { nodes: (x, y, z) })) + let (s, a) = symbol("assume")(s)?; + let (s, b) = assert_timing(s)?; + let (s, c) = paren2(expression)(s)?; + let (s, d) = action_block(s)?; + Ok(( + s, + DeferredImmediateAssumeStatement { + nodes: (a, b, c, d), + }, + )) } pub fn deferred_immediate_cover_statement( s: Span, ) -> IResult { - let (s, _) = symbol("cover")(s)?; - let (s, x) = assert_timing(s)?; - let (s, _) = symbol("(")(s)?; - let (s, y) = expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, z) = statement_or_null(s)?; - Ok((s, DeferredImmediateCoverStatement { nodes: (x, y, z) })) + let (s, a) = symbol("cover")(s)?; + let (s, b) = assert_timing(s)?; + let (s, c) = paren2(expression)(s)?; + let (s, d) = statement_or_null(s)?; + Ok(( + s, + DeferredImmediateCoverStatement { + nodes: (a, b, c, d), + }, + )) } pub fn assert_timing(s: Span) -> IResult { alt(( - map(symbol("#0"), |_| AssertTiming::Zero), - map(symbol("final"), |_| AssertTiming::Final), + map(symbol("#0"), |x| AssertTiming::Zero(x)), + map(symbol("final"), |x| AssertTiming::Final(x)), ))(s) } diff --git a/src/parser/behavioral_statements/clocking_block.rs b/src/parser/behavioral_statements/clocking_block.rs index b6f6f1e..8bf82d1 100644 --- a/src/parser/behavioral_statements/clocking_block.rs +++ b/src/parser/behavioral_statements/clocking_block.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; use nom::branch::*; use nom::combinator::*; @@ -16,42 +17,70 @@ pub enum ClockingDeclaration<'a> { #[derive(Debug)] pub struct ClockingDeclarationLocal<'a> { pub nodes: ( - Option, + Option>, + Symbol<'a>, Option>, ClockingEvent<'a>, + Symbol<'a>, Vec>, - Option>, + Symbol<'a>, + Option<(Symbol<'a>, ClockingIdentifier<'a>)>, ), } -#[derive(Debug)] -pub struct Default {} +#[derive(Debug, Node)] +pub struct Default<'a> { + pub nodes: (Symbol<'a>,), +} #[derive(Debug)] pub struct ClockingDeclarationGlobal<'a> { pub nodes: ( + Symbol<'a>, + Symbol<'a>, Option>, ClockingEvent<'a>, - Option>, + Symbol<'a>, + Symbol<'a>, + Option<(Symbol<'a>, ClockingIdentifier<'a>)>, ), } #[derive(Debug)] pub enum ClockingEvent<'a> { - Identifier(Identifier<'a>), - Expression(EventExpression<'a>), + Identifier(ClockingEventIdentifier<'a>), + Expression(ClockingEventExpression<'a>), +} + +#[derive(Debug, Node)] +pub struct ClockingEventIdentifier<'a> { + pub nodes: (Symbol<'a>, Identifier<'a>), +} + +#[derive(Debug)] +pub struct ClockingEventExpression<'a> { + pub nodes: (Symbol<'a>, Paren<'a, EventExpression<'a>>), } #[derive(Debug)] pub enum ClockingItem<'a> { - DefaultSkew(DefaultSkew<'a>), + Default(ClockingItemDefault<'a>), Direction(ClockingItemDirection<'a>), Assertion(ClockingItemAssertion<'a>), } +#[derive(Debug)] +pub struct ClockingItemDefault<'a> { + pub nodes: (Symbol<'a>, DefaultSkew<'a>, Symbol<'a>), +} + #[derive(Debug)] pub struct ClockingItemDirection<'a> { - pub nodes: (ClockingDirection<'a>, Vec>), + pub nodes: ( + ClockingDirection<'a>, + ListOfClockingDeclAssign<'a>, + Symbol<'a>, + ), } #[derive(Debug)] @@ -61,34 +90,80 @@ pub struct ClockingItemAssertion<'a> { #[derive(Debug)] pub enum DefaultSkew<'a> { - Input(ClockingSkew<'a>), - Output(ClockingSkew<'a>), - InputOutput((ClockingSkew<'a>, ClockingSkew<'a>)), + Input(DefaultSkewInput<'a>), + Output(DefaultSkewOutput<'a>), + InputOutput(DefaultSkewInputOutput<'a>), +} + +#[derive(Debug)] +pub struct DefaultSkewInput<'a> { + pub nodes: (Symbol<'a>, ClockingSkew<'a>), +} + +#[derive(Debug)] +pub struct DefaultSkewOutput<'a> { + pub nodes: (Symbol<'a>, ClockingSkew<'a>), +} + +#[derive(Debug)] +pub struct DefaultSkewInputOutput<'a> { + pub nodes: (Symbol<'a>, ClockingSkew<'a>, Symbol<'a>, ClockingSkew<'a>), } #[derive(Debug)] pub enum ClockingDirection<'a> { - Input(Option>), - Output(Option>), - InputOutput((Option>, Option>)), - Inout, + Input(ClockingDirectionInput<'a>), + Output(ClockingDirectionOutput<'a>), + InputOutput(ClockingDirectionInputOutput<'a>), + Inout(Symbol<'a>), +} + +#[derive(Debug)] +pub struct ClockingDirectionInput<'a> { + pub nodes: (Symbol<'a>, Option>), +} + +#[derive(Debug)] +pub struct ClockingDirectionOutput<'a> { + pub nodes: (Symbol<'a>, Option>), +} + +#[derive(Debug)] +pub struct ClockingDirectionInputOutput<'a> { + pub nodes: ( + Symbol<'a>, + Option>, + Symbol<'a>, + Option>, + ), +} + +#[derive(Debug)] +pub struct ListOfClockingDeclAssign<'a> { + pub nodes: (List, ClockingDeclAssign<'a>>,), } #[derive(Debug)] pub struct ClockingDeclAssign<'a> { - pub nodes: (SignalIdentifier<'a>, Option>), + pub nodes: (SignalIdentifier<'a>, Option<(Symbol<'a>, Expression<'a>)>), } #[derive(Debug)] pub enum ClockingSkew<'a> { - Edge((EdgeIdentifier<'a>, Option>)), - Delay(DelayControl<'a>), + Edge(ClockingSkewEdge<'a>), + DelayControl(DelayControl<'a>), +} + +#[derive(Debug)] +pub struct ClockingSkewEdge<'a> { + pub nodes: (EdgeIdentifier<'a>, Option>), } #[derive(Debug)] pub struct ClockingDrive<'a> { pub nodes: ( - (HierarchicalIdentifier<'a>, Select<'a>), + ClockvarExpression<'a>, + Symbol<'a>, Option>, Expression<'a>, ), @@ -96,11 +171,35 @@ pub struct ClockingDrive<'a> { #[derive(Debug)] pub enum CycleDelay<'a> { - IntegralNumber(IntegralNumber<'a>), - Identifier(Identifier<'a>), - Expression(Expression<'a>), + Integral(CycleDelayIntegral<'a>), + Identifier(CycleDelayIdentifier<'a>), + Expression(CycleDelayExpression<'a>), } +#[derive(Debug, Node)] +pub struct CycleDelayIntegral<'a> { + pub nodes: (Symbol<'a>, IntegralNumber<'a>), +} + +#[derive(Debug, Node)] +pub struct CycleDelayIdentifier<'a> { + pub nodes: (Symbol<'a>, Identifier<'a>), +} + +#[derive(Debug)] +pub struct CycleDelayExpression<'a> { + pub nodes: (Symbol<'a>, Paren<'a, Expression<'a>>), +} + +#[derive(Debug)] +pub struct Clockvar<'a> { + pub nodes: (HierarchicalIdentifier<'a>,), +} + +#[derive(Debug)] +pub struct ClockvarExpression<'a> { + pub nodes: (Clockvar<'a>, Select<'a>), +} // ----------------------------------------------------------------------------- pub fn clocking_declaration(s: Span) -> IResult { @@ -108,77 +207,99 @@ pub fn clocking_declaration(s: Span) -> IResult { } pub fn clocking_declaration_local(s: Span) -> IResult { - let (s, x) = opt(symbol("default"))(s)?; - let (s, _) = symbol("clocking")(s)?; - let (s, y) = opt(clocking_identifier)(s)?; - let (s, z) = clocking_event(s)?; - let (s, _) = symbol(";")(s)?; - let (s, v) = many0(clocking_item)(s)?; - let (s, _) = symbol("endclocking")(s)?; - let (s, w) = opt(preceded(symbol(":"), clocking_identifier))(s)?; + let (s, a) = opt(default)(s)?; + let (s, b) = symbol("clocking")(s)?; + let (s, c) = opt(clocking_identifier)(s)?; + let (s, d) = clocking_event(s)?; + let (s, e) = symbol(";")(s)?; + let (s, f) = many0(clocking_item)(s)?; + let (s, g) = symbol("endclocking")(s)?; + let (s, h) = opt(pair(symbol(":"), clocking_identifier))(s)?; Ok(( s, ClockingDeclaration::Local(ClockingDeclarationLocal { - nodes: (x.map(|_| Default {}), y, z, v, w), + nodes: (a, b, c, d, e, f, g, h), }), )) } +pub fn default(s: Span) -> IResult { + let (s, a) = symbol("default")(s)?; + Ok((s, Default { nodes: (a,) })) +} + pub fn clocking_declaration_global(s: Span) -> IResult { - let (s, _) = opt(symbol("global"))(s)?; - let (s, _) = symbol("clocking")(s)?; - let (s, x) = opt(clocking_identifier)(s)?; - let (s, y) = clocking_event(s)?; - let (s, _) = symbol(";")(s)?; - let (s, _) = symbol("endclocking")(s)?; - let (s, z) = opt(preceded(symbol(":"), clocking_identifier))(s)?; + let (s, a) = symbol("global")(s)?; + let (s, b) = symbol("clocking")(s)?; + let (s, c) = opt(clocking_identifier)(s)?; + let (s, d) = clocking_event(s)?; + let (s, e) = symbol(";")(s)?; + let (s, f) = symbol("endclocking")(s)?; + let (s, g) = opt(pair(symbol(":"), clocking_identifier))(s)?; Ok(( s, - ClockingDeclaration::Global(ClockingDeclarationGlobal { nodes: (x, y, z) }), + ClockingDeclaration::Global(ClockingDeclarationGlobal { + nodes: (a, b, c, d, e, f, g), + }), )) } pub fn clocking_event(s: Span) -> IResult { - alt(( - map(preceded(symbol("@"), identifier), |x| { - ClockingEvent::Identifier(x) - }), - map(preceded(symbol("@"), paren(event_expression)), |x| { - ClockingEvent::Expression(x) - }), - ))(s) + alt((clocking_event_identifier, clocking_event_expression))(s) +} + +pub fn clocking_event_identifier(s: Span) -> IResult { + let (s, a) = symbol("@")(s)?; + let (s, b) = identifier(s)?; + Ok(( + s, + ClockingEvent::Identifier(ClockingEventIdentifier { nodes: (a, b) }), + )) +} + +pub fn clocking_event_expression(s: Span) -> IResult { + let (s, a) = symbol("@")(s)?; + let (s, b) = paren2(event_expression)(s)?; + Ok(( + s, + ClockingEvent::Expression(ClockingEventExpression { nodes: (a, b) }), + )) } pub fn clocking_item(s: Span) -> IResult { alt(( - clocking_item_default_skew, + clocking_item_default, clocking_item_direction, clocking_item_assertion, ))(s) } -pub fn clocking_item_default_skew(s: Span) -> IResult { - let (s, _) = symbol("default")(s)?; - let (s, x) = default_skew(s)?; - let (s, _) = symbol(";")(s)?; - Ok((s, ClockingItem::DefaultSkew(x))) +pub fn clocking_item_default(s: Span) -> IResult { + let (s, a) = symbol("default")(s)?; + let (s, b) = default_skew(s)?; + let (s, c) = symbol(";")(s)?; + Ok(( + s, + ClockingItem::Default(ClockingItemDefault { nodes: (a, b, c) }), + )) } pub fn clocking_item_direction(s: Span) -> IResult { - let (s, x) = clocking_direction(s)?; - let (s, y) = list_of_clocking_decl_assign(s)?; + let (s, a) = clocking_direction(s)?; + let (s, b) = list_of_clocking_decl_assign(s)?; + let (s, c) = symbol(";")(s)?; Ok(( s, - ClockingItem::Direction(ClockingItemDirection { nodes: (x, y) }), + ClockingItem::Direction(ClockingItemDirection { nodes: (a, b, c) }), )) } pub fn clocking_item_assertion(s: Span) -> IResult { - let (s, x) = many0(attribute_instance)(s)?; - let (s, y) = assertion_item_declaration(s)?; + let (s, a) = many0(attribute_instance)(s)?; + let (s, b) = assertion_item_declaration(s)?; Ok(( s, - ClockingItem::Assertion(ClockingItemAssertion { nodes: (x, y) }), + ClockingItem::Assertion(ClockingItemAssertion { nodes: (a, b) }), )) } @@ -191,23 +312,28 @@ pub fn default_skew(s: Span) -> IResult { } pub fn default_skew_input(s: Span) -> IResult { - let (s, _) = symbol("input")(s)?; - let (s, x) = clocking_skew(s)?; - Ok((s, DefaultSkew::Input(x))) + let (s, a) = symbol("input")(s)?; + let (s, b) = clocking_skew(s)?; + Ok((s, DefaultSkew::Input(DefaultSkewInput { nodes: (a, b) }))) } pub fn default_skew_output(s: Span) -> IResult { - let (s, _) = symbol("output")(s)?; - let (s, x) = clocking_skew(s)?; - Ok((s, DefaultSkew::Output(x))) + let (s, a) = symbol("output")(s)?; + let (s, b) = clocking_skew(s)?; + Ok((s, DefaultSkew::Output(DefaultSkewOutput { nodes: (a, b) }))) } pub fn default_skew_input_output(s: Span) -> IResult { - let (s, _) = symbol("input")(s)?; - let (s, x) = clocking_skew(s)?; - let (s, _) = symbol("output")(s)?; - let (s, y) = clocking_skew(s)?; - Ok((s, DefaultSkew::InputOutput((x, y)))) + let (s, a) = symbol("input")(s)?; + let (s, b) = clocking_skew(s)?; + let (s, c) = symbol("output")(s)?; + let (s, d) = clocking_skew(s)?; + Ok(( + s, + DefaultSkew::InputOutput(DefaultSkewInputOutput { + nodes: (a, b, c, d), + }), + )) } pub fn clocking_direction(s: Span) -> IResult { @@ -220,83 +346,122 @@ pub fn clocking_direction(s: Span) -> IResult { } pub fn clocking_direction_input(s: Span) -> IResult { - let (s, _) = symbol("input")(s)?; - let (s, x) = opt(clocking_skew)(s)?; - Ok((s, ClockingDirection::Input(x))) + let (s, a) = symbol("input")(s)?; + let (s, b) = opt(clocking_skew)(s)?; + Ok(( + s, + ClockingDirection::Input(ClockingDirectionInput { nodes: (a, b) }), + )) } pub fn clocking_direction_output(s: Span) -> IResult { - let (s, _) = symbol("output")(s)?; - let (s, x) = opt(clocking_skew)(s)?; - Ok((s, ClockingDirection::Output(x))) + let (s, a) = symbol("output")(s)?; + let (s, b) = opt(clocking_skew)(s)?; + Ok(( + s, + ClockingDirection::Output(ClockingDirectionOutput { nodes: (a, b) }), + )) } pub fn clocking_direction_input_output(s: Span) -> IResult { - let (s, _) = symbol("input")(s)?; - let (s, x) = opt(clocking_skew)(s)?; - let (s, _) = symbol("output")(s)?; - let (s, y) = opt(clocking_skew)(s)?; - Ok((s, ClockingDirection::InputOutput((x, y)))) + let (s, a) = symbol("input")(s)?; + let (s, b) = opt(clocking_skew)(s)?; + let (s, c) = symbol("output")(s)?; + let (s, d) = opt(clocking_skew)(s)?; + Ok(( + s, + ClockingDirection::InputOutput(ClockingDirectionInputOutput { + nodes: (a, b, c, d), + }), + )) } pub fn clocking_direction_inout(s: Span) -> IResult { - let (s, _) = symbol("inout")(s)?; - Ok((s, ClockingDirection::Inout)) + let (s, a) = symbol("inout")(s)?; + Ok((s, ClockingDirection::Inout(a))) } -pub fn list_of_clocking_decl_assign(s: Span) -> IResult> { - many1(clocking_decl_assign)(s) +pub fn list_of_clocking_decl_assign(s: Span) -> IResult { + let (s, a) = list(symbol(","), clocking_decl_assign)(s)?; + Ok((s, ListOfClockingDeclAssign { nodes: (a,) })) } pub fn clocking_decl_assign(s: Span) -> IResult { - let (s, x) = signal_identifier(s)?; - let (s, y) = opt(preceded(symbol("="), expression))(s)?; - Ok((s, ClockingDeclAssign { nodes: (x, y) })) + let (s, a) = signal_identifier(s)?; + let (s, b) = opt(pair(symbol("="), expression))(s)?; + Ok((s, ClockingDeclAssign { nodes: (a, b) })) } pub fn clocking_skew(s: Span) -> IResult { - alt((clocking_skew_edge, clocking_skew_delay))(s) + alt(( + clocking_skew_edge, + map(delay_control, |x| ClockingSkew::DelayControl(x)), + ))(s) } pub fn clocking_skew_edge(s: Span) -> IResult { - let (s, x) = edge_identifier(s)?; - let (s, y) = opt(delay_control)(s)?; - Ok((s, ClockingSkew::Edge((x, y)))) -} - -pub fn clocking_skew_delay(s: Span) -> IResult { - let (s, x) = delay_control(s)?; - Ok((s, ClockingSkew::Delay(x))) + let (s, a) = edge_identifier(s)?; + let (s, b) = opt(delay_control)(s)?; + Ok((s, ClockingSkew::Edge(ClockingSkewEdge { nodes: (a, b) }))) } pub fn clocking_drive(s: Span) -> IResult { - let (s, x) = clockvar_expression(s)?; - let (s, _) = symbol("=")(s)?; - let (s, y) = opt(cycle_delay)(s)?; - let (s, z) = expression(s)?; - Ok((s, ClockingDrive { nodes: (x, y, z) })) + let (s, a) = clockvar_expression(s)?; + let (s, b) = symbol("<=")(s)?; + let (s, c) = opt(cycle_delay)(s)?; + let (s, d) = expression(s)?; + Ok(( + s, + ClockingDrive { + nodes: (a, b, c, d), + }, + )) } pub fn cycle_delay(s: Span) -> IResult { alt(( - map(preceded(symbol("##"), integral_number), |x| { - CycleDelay::IntegralNumber(x) - }), - map(preceded(symbol("##"), identifier), |x| { - CycleDelay::Identifier(x) - }), - map(preceded(symbol("##"), paren(expression)), |x| { - CycleDelay::Expression(x) - }), + cycle_delay_integral, + cycle_delay_identifier, + cycle_delay_expression, ))(s) } -pub fn clockvar(s: Span) -> IResult { - hierarchical_identifier(s) +pub fn cycle_delay_integral(s: Span) -> IResult { + let (s, a) = symbol("##")(s)?; + let (s, b) = integral_number(s)?; + Ok(( + s, + CycleDelay::Integral(CycleDelayIntegral { nodes: (a, b) }), + )) } -pub fn clockvar_expression(s: Span) -> IResult { - pair(clockvar, select)(s) +pub fn cycle_delay_identifier(s: Span) -> IResult { + let (s, a) = symbol("##")(s)?; + let (s, b) = identifier(s)?; + Ok(( + s, + CycleDelay::Identifier(CycleDelayIdentifier { nodes: (a, b) }), + )) +} + +pub fn cycle_delay_expression(s: Span) -> IResult { + let (s, a) = symbol("##")(s)?; + let (s, b) = paren2(expression)(s)?; + Ok(( + s, + CycleDelay::Expression(CycleDelayExpression { nodes: (a, b) }), + )) +} + +pub fn clockvar(s: Span) -> IResult { + let (s, a) = hierarchical_identifier(s)?; + Ok((s, Clockvar { nodes: (a,) })) +} + +pub fn clockvar_expression(s: Span) -> IResult { + let (s, a) = clockvar(s)?; + let (s, b) = select(s)?; + Ok((s, ClockvarExpression { nodes: (a, b) })) } // ----------------------------------------------------------------------------- diff --git a/src/parser/behavioral_statements/randsequence.rs b/src/parser/behavioral_statements/randsequence.rs index ff5ca5f..76b2780 100644 --- a/src/parser/behavioral_statements/randsequence.rs +++ b/src/parser/behavioral_statements/randsequence.rs @@ -9,7 +9,13 @@ use nom::IResult; #[derive(Debug)] pub struct RandsequenceStatement<'a> { - pub nodes: (Option>, Vec>), + pub nodes: ( + Symbol<'a>, + Paren<'a, Option>>, + Production<'a>, + Vec>, + Symbol<'a>, + ), } #[derive(Debug)] @@ -17,8 +23,10 @@ pub struct Production<'a> { pub nodes: ( Option>, ProductionIdentifier<'a>, - Option>, - Vec>, + Option>>, + Symbol<'a>, + List, RsRule<'a>>, + Symbol<'a>, ), } @@ -26,60 +34,91 @@ pub struct Production<'a> { pub struct RsRule<'a> { pub nodes: ( RsProductionList<'a>, - Option>, - Option>, + Option<(Symbol<'a>, WeightSpecification<'a>, Option>)>, ), } #[derive(Debug)] pub enum RsProductionList<'a> { - Prod(Vec>), - Join((Option>, Vec>)), + Prod(RsProductionListProd<'a>), + Join(RsProductionListJoin<'a>), +} + +#[derive(Debug)] +pub struct RsProductionListProd<'a> { + pub nodes: (RsProd<'a>, Vec>), +} + +#[derive(Debug)] +pub struct RsProductionListJoin<'a> { + pub nodes: ( + Symbol<'a>, + Symbol<'a>, + Option>>, + ProductionItem<'a>, + ProductionItem<'a>, + Vec>, + ), } #[derive(Debug)] pub enum WeightSpecification<'a> { IntegralNumber(IntegralNumber<'a>), PsIdentifier(PsIdentifier<'a>), - Expression(Expression<'a>), + Expression(WeightSpecificationExpression<'a>), +} + +#[derive(Debug)] +pub struct WeightSpecificationExpression<'a> { + pub nodes: (Paren<'a, Expression<'a>>,), } #[derive(Debug)] pub struct RsCodeBlock<'a> { - pub nodes: (Vec>, Vec>), + pub nodes: (Brace<'a, (Vec>, Vec>)>,), } #[derive(Debug)] pub enum RsProd<'a> { - Item(ProductionItem<'a>), - CodeBlock(RsCodeBlock<'a>), - IfElse(RsIfElse<'a>), - Repeat(RsRepeat<'a>), - Case(RsCase<'a>), + ProductionItem(ProductionItem<'a>), + RsCodeBlock(RsCodeBlock<'a>), + RsIfElse(RsIfElse<'a>), + RsRepeat(RsRepeat<'a>), + RsCase(RsCase<'a>), } #[derive(Debug)] pub struct ProductionItem<'a> { - pub nodes: (ProductionIdentifier<'a>, Option>), + pub nodes: ( + ProductionIdentifier<'a>, + Option>>, + ), } #[derive(Debug)] pub struct RsIfElse<'a> { pub nodes: ( - Expression<'a>, + Symbol<'a>, + Paren<'a, Expression<'a>>, ProductionItem<'a>, - Option>, + Option<(Symbol<'a>, ProductionItem<'a>)>, ), } #[derive(Debug)] pub struct RsRepeat<'a> { - pub nodes: (Expression<'a>, ProductionItem<'a>), + pub nodes: (Symbol<'a>, Paren<'a, Expression<'a>>, ProductionItem<'a>), } #[derive(Debug)] pub struct RsCase<'a> { - pub nodes: (CaseExpression<'a>, Vec>), + pub nodes: ( + Symbol<'a>, + Paren<'a, CaseExpression<'a>>, + RsCaseItem<'a>, + Vec>, + Symbol<'a>, + ), } #[derive(Debug)] @@ -89,55 +128,64 @@ pub enum RsCaseItem<'a> { } #[derive(Debug)] -pub struct RsCaseItemDefault<'a> { - pub nodes: (ProductionItem<'a>,), +pub struct RsCaseItemNondefault<'a> { + pub nodes: ( + List, CaseItemExpression<'a>>, + Symbol<'a>, + ProductionItem<'a>, + Symbol<'a>, + ), } #[derive(Debug)] -pub struct RsCaseItemNondefault<'a> { - pub nodes: (Vec>, ProductionItem<'a>), +pub struct RsCaseItemDefault<'a> { + pub nodes: ( + Symbol<'a>, + Option>, + ProductionItem<'a>, + Symbol<'a>, + ), } // ----------------------------------------------------------------------------- pub fn randsequence_statement(s: Span) -> IResult { - let (s, _) = symbol("randsequence")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = opt(production_identifier)(s)?; - let (s, _) = symbol(")")(s)?; - let (s, y) = many1(production)(s)?; - let (s, _) = symbol("endsequence")(s)?; - Ok((s, RandsequenceStatement { nodes: (x, y) })) + let (s, a) = symbol("randsequence")(s)?; + let (s, b) = paren2(opt(production_identifier))(s)?; + let (s, c) = production(s)?; + let (s, d) = many0(production)(s)?; + let (s, e) = symbol("endsequence")(s)?; + Ok(( + s, + RandsequenceStatement { + nodes: (a, b, c, d, e), + }, + )) } pub fn production(s: Span) -> IResult { - let (s, x) = opt(data_type_or_void)(s)?; - let (s, y) = production_identifier(s)?; - let (s, z) = opt(paren(tf_port_list))(s)?; - let (s, _) = symbol(":")(s)?; - let (s, v) = separated_nonempty_list(symbol("|"), rs_rule)(s)?; - let (s, _) = symbol(";")(s)?; + let (s, a) = opt(data_type_or_void)(s)?; + let (s, b) = production_identifier(s)?; + let (s, c) = opt(paren2(tf_port_list))(s)?; + let (s, d) = symbol(":")(s)?; + let (s, e) = list(symbol("|"), rs_rule)(s)?; + let (s, f) = symbol(";")(s)?; Ok(( s, Production { - nodes: (x, y, z, v), + nodes: (a, b, c, d, e, f), }, )) } pub fn rs_rule(s: Span) -> IResult { - let (s, x) = rs_production_list(s)?; - let (s, y) = opt(preceded( + let (s, a) = rs_production_list(s)?; + let (s, b) = opt(triple( symbol(":="), - pair(weight_specification, opt(rs_code_block)), + weight_specification, + opt(rs_code_block), ))(s)?; - - let (y, z) = if let Some((y, z)) = y { - (Some(y), z) - } else { - (None, None) - }; - Ok((s, RsRule { nodes: (x, y, z) })) + Ok((s, RsRule { nodes: (a, b) })) } pub fn rs_production_list(s: Span) -> IResult { @@ -145,76 +193,98 @@ pub fn rs_production_list(s: Span) -> IResult { } pub fn rs_production_list_prod(s: Span) -> IResult { - let (s, x) = many1(rs_prod)(s)?; - Ok((s, RsProductionList::Prod(x))) + let (s, a) = rs_prod(s)?; + let (s, b) = many0(rs_prod)(s)?; + Ok(( + s, + RsProductionList::Prod(RsProductionListProd { nodes: (a, b) }), + )) } pub fn rs_production_list_join(s: Span) -> IResult { - let (s, _) = symbol("rand")(s)?; - let (s, _) = symbol("join")(s)?; - let (s, x) = opt(paren(expression))(s)?; - let (s, y) = production_item(s)?; - let (s, z) = many1(production_item)(s)?; - - let mut y = vec![y]; - for z in z { - y.push(z); - } - Ok((s, RsProductionList::Join((x, y)))) + let (s, a) = symbol("rand")(s)?; + let (s, b) = symbol("join")(s)?; + let (s, c) = opt(paren2(expression))(s)?; + let (s, d) = production_item(s)?; + let (s, e) = production_item(s)?; + let (s, f) = many0(production_item)(s)?; + Ok(( + s, + RsProductionList::Join(RsProductionListJoin { + nodes: (a, b, c, d, e, f), + }), + )) } pub fn weight_specification(s: Span) -> IResult { alt(( map(integral_number, |x| WeightSpecification::IntegralNumber(x)), map(ps_identifier, |x| WeightSpecification::PsIdentifier(x)), - map(paren(expression), |x| WeightSpecification::Expression(x)), + weight_specification_expression, ))(s) } +pub fn weight_specification_expression(s: Span) -> IResult { + let (s, a) = paren2(expression)(s)?; + Ok(( + s, + WeightSpecification::Expression(WeightSpecificationExpression { nodes: (a,) }), + )) +} + pub fn rs_code_block(s: Span) -> IResult { - let (s, _) = symbol("{")(s)?; - let (s, x) = many0(data_declaration)(s)?; - let (s, y) = many0(statement_or_null)(s)?; - let (s, _) = symbol("}")(s)?; - Ok((s, RsCodeBlock { nodes: (x, y) })) + let (s, a) = brace2(pair(many0(data_declaration), many0(statement_or_null)))(s)?; + Ok((s, RsCodeBlock { nodes: (a,) })) } pub fn rs_prod(s: Span) -> IResult { alt(( - map(production_item, |x| RsProd::Item(x)), - map(rs_code_block, |x| RsProd::CodeBlock(x)), - map(rs_if_else, |x| RsProd::IfElse(x)), - map(rs_repeat, |x| RsProd::Repeat(x)), - map(rs_case, |x| RsProd::Case(x)), + map(production_item, |x| RsProd::ProductionItem(x)), + map(rs_code_block, |x| RsProd::RsCodeBlock(x)), + map(rs_if_else, |x| RsProd::RsIfElse(x)), + map(rs_repeat, |x| RsProd::RsRepeat(x)), + map(rs_case, |x| RsProd::RsCase(x)), ))(s) } pub fn production_item(s: Span) -> IResult { - let (s, x) = production_identifier(s)?; - let (s, y) = opt(paren(list_of_arguments))(s)?; - Ok((s, ProductionItem { nodes: (x, y) })) + let (s, a) = production_identifier(s)?; + let (s, b) = opt(paren2(list_of_arguments))(s)?; + Ok((s, ProductionItem { nodes: (a, b) })) } pub fn rs_if_else(s: Span) -> IResult { - let (s, _) = symbol("if")(s)?; - let (s, x) = paren(expression)(s)?; - let (s, y) = production_item(s)?; - let (s, z) = opt(preceded(symbol("else"), production_item))(s)?; - Ok((s, RsIfElse { nodes: (x, y, z) })) + let (s, a) = symbol("if")(s)?; + let (s, b) = paren2(expression)(s)?; + let (s, c) = production_item(s)?; + let (s, d) = opt(pair(symbol("else"), production_item))(s)?; + Ok(( + s, + RsIfElse { + nodes: (a, b, c, d), + }, + )) } pub fn rs_repeat(s: Span) -> IResult { - let (s, _) = symbol("repeat")(s)?; - let (s, x) = paren(expression)(s)?; - let (s, y) = production_item(s)?; - Ok((s, RsRepeat { nodes: (x, y) })) + let (s, a) = symbol("repeat")(s)?; + let (s, b) = paren2(expression)(s)?; + let (s, c) = production_item(s)?; + Ok((s, RsRepeat { nodes: (a, b, c) })) } pub fn rs_case(s: Span) -> IResult { - let (s, _) = symbol("case")(s)?; - let (s, x) = paren(case_expression)(s)?; - let (s, y) = many1(rs_case_item)(s)?; - Ok((s, RsCase { nodes: (x, y) })) + let (s, a) = symbol("case")(s)?; + let (s, b) = paren2(case_expression)(s)?; + let (s, c) = rs_case_item(s)?; + let (s, d) = many0(rs_case_item)(s)?; + let (s, e) = symbol("endcase")(s)?; + Ok(( + s, + RsCase { + nodes: (a, b, c, d, e), + }, + )) } pub fn rs_case_item(s: Span) -> IResult { @@ -222,20 +292,27 @@ pub fn rs_case_item(s: Span) -> IResult { } pub fn rs_case_item_nondefault(s: Span) -> IResult { - let (s, x) = separated_nonempty_list(symbol(","), case_item_expression)(s)?; - let (s, _) = symbol(":")(s)?; - let (s, y) = production_item(s)?; - let (s, _) = symbol(";")(s)?; + let (s, a) = list(symbol(","), case_item_expression)(s)?; + let (s, b) = symbol(":")(s)?; + let (s, c) = production_item(s)?; + let (s, d) = symbol(";")(s)?; Ok(( s, - RsCaseItem::NonDefault(RsCaseItemNondefault { nodes: (x, y) }), + RsCaseItem::NonDefault(RsCaseItemNondefault { + nodes: (a, b, c, d), + }), )) } pub fn rs_case_item_default(s: Span) -> IResult { - let (s, _) = symbol("default")(s)?; - let (s, _) = opt(symbol(":"))(s)?; - let (s, x) = production_item(s)?; - let (s, _) = symbol(";")(s)?; - Ok((s, RsCaseItem::Default(RsCaseItemDefault { nodes: (x,) }))) + let (s, a) = symbol("default")(s)?; + let (s, b) = opt(symbol(":"))(s)?; + let (s, c) = production_item(s)?; + let (s, d) = symbol(";")(s)?; + Ok(( + s, + RsCaseItem::Default(RsCaseItemDefault { + nodes: (a, b, c, d), + }), + )) }