From c06ff35e87224724ac4176fb190976901467e87d Mon Sep 17 00:00:00 2001 From: dalance Date: Fri, 12 Jul 2019 15:18:56 +0900 Subject: [PATCH] Refactoring --- README.md | 10 +- .../behavioral_statements/case_statements.rs | 232 ++++++----- .../conditional_statements.rs | 83 ++-- .../looping_statements.rs | 195 +++++---- src/parser/behavioral_statements/patterns.rs | 261 ++++++++---- .../behavioral_statements/randsequence.rs | 4 +- .../timing_control_statements.rs | 372 ++++++++++++------ src/parser/declarations/delays.rs | 7 +- src/parser/declarations/task_declarations.rs | 4 +- .../expressions/expression_leftside_values.rs | 11 +- src/parser/expressions/expressions.rs | 3 +- src/parser/expressions/operators.rs | 11 +- src/parser/expressions/primaries.rs | 33 +- src/parser/expressions/strings.rs | 3 +- src/parser/general/attributes.rs | 1 - src/parser/general/identifiers.rs | 354 ++++++++++++----- .../primitive_instantiation_and_instances.rs | 3 +- .../specify_block_declaration.rs | 3 +- .../specify_block_terminals.rs | 9 +- .../specify_section/specify_path_delays.rs | 3 +- .../udp_declaration.rs | 3 +- .../udp_instantiation.rs | 3 +- 22 files changed, 1044 insertions(+), 564 deletions(-) diff --git a/README.md b/README.md index d200e8c..9950cf5 100644 --- a/README.md +++ b/README.md @@ -49,11 +49,11 @@ A parser library for System Verilog. | behavioral_statements | procedural_blocks_and_assignments | x | x | | | behavioral_statements | parallel_and_sequential_blocks | x | x | | | behavioral_statements | statements | x | x | | -| behavioral_statements | timing_control_statements | | | | -| behavioral_statements | conditional_statements | | | | -| behavioral_statements | case_statements | | | | -| behavioral_statements | patterns | | | | -| behavioral_statements | looping_statements | | | | +| behavioral_statements | timing_control_statements | x | x | | +| behavioral_statements | conditional_statements | x | x | | +| behavioral_statements | case_statements | x | x | | +| 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 | | | | diff --git a/src/parser/behavioral_statements/case_statements.rs b/src/parser/behavioral_statements/case_statements.rs index 48e20da..a03f30c 100644 --- a/src/parser/behavioral_statements/case_statements.rs +++ b/src/parser/behavioral_statements/case_statements.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; use nom::branch::*; use nom::combinator::*; @@ -17,38 +18,51 @@ pub enum CaseStatement<'a> { #[derive(Debug)] pub struct CaseStatementNormal<'a> { pub nodes: ( - Option, - CaseKeyword, - Expression<'a>, + Option>, + CaseKeyword<'a>, + Paren<'a, CaseExpression<'a>>, + CaseItem<'a>, Vec>, + Symbol<'a>, ), } #[derive(Debug)] pub struct CaseStatementMatches<'a> { pub nodes: ( - Option, - CaseKeyword, - Expression<'a>, + Option>, + CaseKeyword<'a>, + Paren<'a, CaseExpression<'a>>, + Symbol<'a>, + CasePatternItem<'a>, Vec>, + Symbol<'a>, ), } #[derive(Debug)] pub struct CaseStatementInside<'a> { pub nodes: ( - Option, - CaseKeyword, - Expression<'a>, + Option>, + Symbol<'a>, + Paren<'a, CaseExpression<'a>>, + Symbol<'a>, + CaseInsideItem<'a>, Vec>, + Symbol<'a>, ), } +#[derive(Debug, Node)] +pub enum CaseKeyword<'a> { + Case(Symbol<'a>), + Casez(Symbol<'a>), + Casex(Symbol<'a>), +} + #[derive(Debug)] -pub enum CaseKeyword { - Case, - Casez, - Casex, +pub struct CaseExpression<'a> { + pub nodes: (Expression<'a>,), } #[derive(Debug)] @@ -57,55 +71,74 @@ pub enum CaseItem<'a> { Default(CaseItemDefault<'a>), } +#[derive(Debug)] +pub struct CaseItemNondefault<'a> { + pub nodes: ( + List, CaseItemExpression<'a>>, + Symbol<'a>, + StatementOrNull<'a>, + ), +} + +#[derive(Debug)] +pub struct CaseItemDefault<'a> { + pub nodes: (Symbol<'a>, Option>, StatementOrNull<'a>), +} + #[derive(Debug)] pub enum CasePatternItem<'a> { NonDefault(CasePatternItemNondefault<'a>), Default(CaseItemDefault<'a>), } +#[derive(Debug)] +pub struct CasePatternItemNondefault<'a> { + pub nodes: ( + Pattern<'a>, + Option<(Symbol<'a>, Expression<'a>)>, + Symbol<'a>, + StatementOrNull<'a>, + ), +} + #[derive(Debug)] pub enum CaseInsideItem<'a> { NonDefault(CaseInsideItemNondefault<'a>), Default(CaseItemDefault<'a>), } -#[derive(Debug)] -pub struct CaseItemDefault<'a> { - pub nodes: (StatementOrNull<'a>,), -} - -#[derive(Debug)] -pub struct CaseItemNondefault<'a> { - pub nodes: (Vec>, StatementOrNull<'a>), -} - -#[derive(Debug)] -pub struct CasePatternItemNondefault<'a> { - pub nodes: (Pattern<'a>, Option>, StatementOrNull<'a>), -} - #[derive(Debug)] pub struct CaseInsideItemNondefault<'a> { - pub nodes: (Vec>, StatementOrNull<'a>), + pub nodes: (OpenRangeList<'a>, Symbol<'a>, StatementOrNull<'a>), +} + +#[derive(Debug)] +pub struct CaseItemExpression<'a> { + pub nodes: (Expression<'a>,), } #[derive(Debug)] pub struct RandcaseStatement<'a> { - pub nodes: (Vec>,), + pub nodes: ( + Symbol<'a>, + RandcaseItem<'a>, + Vec>, + Symbol<'a>, + ), } #[derive(Debug)] pub struct RandcaseItem<'a> { - pub nodes: (Expression<'a>, StatementOrNull<'a>), + pub nodes: (Expression<'a>, Symbol<'a>, StatementOrNull<'a>), } #[derive(Debug)] pub struct OpenRangeList<'a> { - pub nodes: (Vec>,), + pub nodes: (List, OpenValueRange<'a>>,), } #[derive(Debug)] -pub struct OpenRangeValue<'a> { +pub struct OpenValueRange<'a> { pub nodes: (ValueRange<'a>,), } @@ -120,65 +153,63 @@ pub fn case_statement(s: Span) -> IResult { } pub fn case_statement_normal(s: Span) -> IResult { - let (s, x) = opt(unique_priority)(s)?; - let (s, y) = case_keyword(s)?; - let (s, _) = symbol("(")(s)?; - let (s, z) = case_expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, v) = many1(case_item)(s)?; - let (s, _) = symbol("endcase")(s)?; + let (s, a) = opt(unique_priority)(s)?; + let (s, b) = case_keyword(s)?; + let (s, c) = paren2(case_expression)(s)?; + let (s, d) = case_item(s)?; + let (s, e) = many0(case_item)(s)?; + let (s, f) = symbol("endcase")(s)?; Ok(( s, CaseStatement::Normal(CaseStatementNormal { - nodes: (x, y, z, v), + nodes: (a, b, c, d, e, f), }), )) } pub fn case_statement_matches(s: Span) -> IResult { - let (s, x) = opt(unique_priority)(s)?; - let (s, y) = case_keyword(s)?; - let (s, _) = symbol("(")(s)?; - let (s, z) = case_expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, _) = symbol("matches")(s)?; - let (s, v) = many1(case_pattern_item)(s)?; - let (s, _) = symbol("endcase")(s)?; + let (s, a) = opt(unique_priority)(s)?; + let (s, b) = case_keyword(s)?; + let (s, c) = paren2(case_expression)(s)?; + let (s, d) = symbol("matches")(s)?; + let (s, e) = case_pattern_item(s)?; + let (s, f) = many0(case_pattern_item)(s)?; + let (s, g) = symbol("endcase")(s)?; Ok(( s, CaseStatement::Matches(CaseStatementMatches { - nodes: (x, y, z, v), + nodes: (a, b, c, d, e, f, g), }), )) } pub fn case_statement_inside(s: Span) -> IResult { - let (s, x) = opt(unique_priority)(s)?; - let (s, y) = case_keyword(s)?; - let (s, _) = symbol("(")(s)?; - let (s, z) = case_expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, _) = symbol("inside")(s)?; - let (s, v) = many1(case_inside_item)(s)?; - let (s, _) = symbol("endcase")(s)?; + let (s, a) = opt(unique_priority)(s)?; + let (s, b) = symbol("case")(s)?; + let (s, c) = paren2(case_expression)(s)?; + let (s, d) = symbol("inside")(s)?; + let (s, e) = case_inside_item(s)?; + let (s, f) = many0(case_inside_item)(s)?; + let (s, g) = symbol("endcase")(s)?; Ok(( s, CaseStatement::Inside(CaseStatementInside { - nodes: (x, y, z, v), + nodes: (a, b, c, d, e, f, g), }), )) } pub fn case_keyword(s: Span) -> IResult { alt(( - map(symbol("casez"), |_| CaseKeyword::Casez), - map(symbol("casex"), |_| CaseKeyword::Casex), - map(symbol("case"), |_| CaseKeyword::Case), + map(symbol("casez"), |x| CaseKeyword::Casez(x)), + map(symbol("casex"), |x| CaseKeyword::Casex(x)), + map(symbol("case"), |x| CaseKeyword::Case(x)), ))(s) } -pub fn case_expression(s: Span) -> IResult { - expression(s) +pub fn case_expression(s: Span) -> IResult { + let (s, a) = expression(s)?; + Ok((s, CaseExpression { nodes: (a,) })) } pub fn case_item(s: Span) -> IResult { @@ -189,20 +220,20 @@ pub fn case_item(s: Span) -> IResult { } pub fn case_item_nondefault(s: Span) -> IResult { - let (s, x) = separated_nonempty_list(symbol(","), case_item_expression)(s)?; - let (s, _) = symbol(":")(s)?; - let (s, y) = statement_or_null(s)?; + let (s, a) = list(symbol(","), case_item_expression)(s)?; + let (s, b) = symbol(":")(s)?; + let (s, c) = statement_or_null(s)?; Ok(( s, - CaseItem::NonDefault(CaseItemNondefault { nodes: (x, y) }), + CaseItem::NonDefault(CaseItemNondefault { nodes: (a, b, c) }), )) } pub fn case_item_default(s: Span) -> IResult { - let (s, _) = symbol("default")(s)?; - let (s, _) = opt(symbol(":"))(s)?; - let (s, x) = statement_or_null(s)?; - Ok((s, CaseItemDefault { nodes: (x,) })) + let (s, a) = symbol("default")(s)?; + let (s, b) = opt(symbol(":"))(s)?; + let (s, c) = statement_or_null(s)?; + Ok((s, CaseItemDefault { nodes: (a, b, c) })) } pub fn case_pattern_item(s: Span) -> IResult { @@ -213,13 +244,15 @@ pub fn case_pattern_item(s: Span) -> IResult { } pub fn case_pattern_item_nondefault(s: Span) -> IResult { - let (s, x) = pattern(s)?; - let (s, y) = opt(preceded(symbol("&&&"), expression))(s)?; - let (s, _) = symbol(":")(s)?; - let (s, z) = statement_or_null(s)?; + let (s, a) = pattern(s)?; + let (s, b) = opt(pair(symbol("&&&"), expression))(s)?; + let (s, c) = symbol(":")(s)?; + let (s, d) = statement_or_null(s)?; Ok(( s, - CasePatternItem::NonDefault(CasePatternItemNondefault { nodes: (x, y, z) }), + CasePatternItem::NonDefault(CasePatternItemNondefault { + nodes: (a, b, c, d), + }), )) } @@ -231,37 +264,46 @@ pub fn case_inside_item(s: Span) -> IResult { } pub fn case_inside_item_nondefault(s: Span) -> IResult { - let (s, x) = open_range_list(s)?; - let (s, _) = symbol(":")(s)?; - let (s, y) = statement_or_null(s)?; + let (s, a) = open_range_list(s)?; + let (s, b) = symbol(":")(s)?; + let (s, c) = statement_or_null(s)?; Ok(( s, - CaseInsideItem::NonDefault(CaseInsideItemNondefault { nodes: (x, y) }), + CaseInsideItem::NonDefault(CaseInsideItemNondefault { nodes: (a, b, c) }), )) } -pub fn case_item_expression(s: Span) -> IResult { - expression(s) +pub fn case_item_expression(s: Span) -> IResult { + let (s, a) = expression(s)?; + Ok((s, CaseItemExpression { nodes: (a,) })) } pub fn randcase_statement(s: Span) -> IResult { - let (s, _) = symbol("randcase")(s)?; - let (s, x) = many1(randcase_item)(s)?; - let (s, _) = symbol("endcase")(s)?; - Ok((s, RandcaseStatement { nodes: (x,) })) + let (s, a) = symbol("randcase")(s)?; + let (s, b) = randcase_item(s)?; + let (s, c) = many0(randcase_item)(s)?; + let (s, d) = symbol("endcase")(s)?; + Ok(( + s, + RandcaseStatement { + nodes: (a, b, c, d), + }, + )) } pub fn randcase_item(s: Span) -> IResult { - let (s, x) = expression(s)?; - let (s, _) = symbol(":")(s)?; - let (s, y) = statement_or_null(s)?; - Ok((s, RandcaseItem { nodes: (x, y) })) + let (s, a) = expression(s)?; + let (s, b) = symbol(":")(s)?; + let (s, c) = statement_or_null(s)?; + Ok((s, RandcaseItem { nodes: (a, b, c) })) } -pub fn open_range_list(s: Span) -> IResult> { - separated_nonempty_list(symbol(","), open_value_range)(s) +pub fn open_range_list(s: Span) -> IResult { + let (s, a) = list(symbol(","), open_value_range)(s)?; + Ok((s, OpenRangeList { nodes: (a,) })) } -pub fn open_value_range(s: Span) -> IResult { - value_range(s) +pub fn open_value_range(s: Span) -> IResult { + let (s, a) = value_range(s)?; + Ok((s, OpenValueRange { nodes: (a,) })) } diff --git a/src/parser/behavioral_statements/conditional_statements.rs b/src/parser/behavioral_statements/conditional_statements.rs index 69e23e1..4c66a0d 100644 --- a/src/parser/behavioral_statements/conditional_statements.rs +++ b/src/parser/behavioral_statements/conditional_statements.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; use nom::branch::*; use nom::combinator::*; @@ -10,28 +11,30 @@ use nom::IResult; #[derive(Debug)] pub struct ConditionalStatement<'a> { pub nodes: ( - Option, - ConditionalStatementBody<'a>, - Vec>, - Option>, + Option>, + Symbol<'a>, + Paren<'a, CondPredicate<'a>>, + StatementOrNull<'a>, + Vec<( + Symbol<'a>, + Symbol<'a>, + Paren<'a, CondPredicate<'a>>, + StatementOrNull<'a>, + )>, + Option<(Symbol<'a>, StatementOrNull<'a>)>, ), } -#[derive(Debug)] -pub enum UniquePriority { - Unique, - Unique0, - Priority, -} - -#[derive(Debug)] -pub struct ConditionalStatementBody<'a> { - pub nodes: (CondPredicate<'a>, StatementOrNull<'a>), +#[derive(Debug, Node)] +pub enum UniquePriority<'a> { + Unique(Symbol<'a>), + Unique0(Symbol<'a>), + Priority(Symbol<'a>), } #[derive(Debug)] pub struct CondPredicate<'a> { - pub nodes: (Vec>,), + pub nodes: (List, ExpressionOrCondPattern<'a>>,), } #[derive(Debug)] @@ -42,49 +45,43 @@ pub enum ExpressionOrCondPattern<'a> { #[derive(Debug)] pub struct CondPattern<'a> { - pub nodes: (Expression<'a>, Pattern<'a>), + pub nodes: (Expression<'a>, Symbol<'a>, Pattern<'a>), } // ----------------------------------------------------------------------------- pub fn conditional_statement(s: Span) -> IResult { - let (s, x) = opt(unique_priority)(s)?; - let (s, _) = symbol("if")(s)?; - let (s, y) = conditional_statement_body(s)?; - let (s, z) = many0(preceded( - pair(symbol("else"), symbol("if")), - conditional_statement_body, - ))(s)?; - let (s, v) = opt(preceded(symbol("else"), statement_or_null))(s)?; + let (s, a) = opt(unique_priority)(s)?; + let (s, b) = symbol("if")(s)?; + let (s, c) = paren2(cond_predicate)(s)?; + let (s, d) = statement_or_null(s)?; + let (s, e) = many0(tuple(( + symbol("else"), + symbol("if"), + paren2(cond_predicate), + statement_or_null, + )))(s)?; + let (s, f) = opt(pair(symbol("else"), statement_or_null))(s)?; Ok(( s, ConditionalStatement { - nodes: (x, y, z, v), + nodes: (a, b, c, d, e, f), }, )) } -pub fn conditional_statement_body(s: Span) -> IResult { - let (s, _) = symbol("(")(s)?; - let (s, x) = cond_predicate(s)?; - let (s, _) = symbol(")")(s)?; - let (s, y) = statement_or_null(s)?; - - Ok((s, ConditionalStatementBody { nodes: (x, y) })) -} - pub fn unique_priority(s: Span) -> IResult { alt(( - map(symbol("unique0"), |_| UniquePriority::Unique0), - map(symbol("unique"), |_| UniquePriority::Unique), - map(symbol("priority"), |_| UniquePriority::Priority), + map(symbol("unique0"), |x| UniquePriority::Unique0(x)), + map(symbol("unique"), |x| UniquePriority::Unique(x)), + map(symbol("priority"), |x| UniquePriority::Priority(x)), ))(s) } pub fn cond_predicate(s: Span) -> IResult { - let (s, x) = separated_nonempty_list(symbol("&&&"), expression_or_cond_pattern)(s)?; - Ok((s, CondPredicate { nodes: (x,) })) + let (s, a) = list(symbol("&&&"), expression_or_cond_pattern)(s)?; + Ok((s, CondPredicate { nodes: (a,) })) } pub fn expression_or_cond_pattern(s: Span) -> IResult { @@ -95,8 +92,8 @@ pub fn expression_or_cond_pattern(s: Span) -> IResult IResult { - let (s, x) = expression(s)?; - let (s, _) = symbol("matches")(s)?; - let (s, y) = pattern(s)?; - Ok((s, CondPattern { nodes: (x, y) })) + let (s, a) = expression(s)?; + let (s, b) = symbol("matches")(s)?; + let (s, c) = pattern(s)?; + Ok((s, CondPattern { nodes: (a, b, c) })) } diff --git a/src/parser/behavioral_statements/looping_statements.rs b/src/parser/behavioral_statements/looping_statements.rs index 12f9d96..45c3e24 100644 --- a/src/parser/behavioral_statements/looping_statements.rs +++ b/src/parser/behavioral_statements/looping_statements.rs @@ -1,7 +1,7 @@ +use crate::ast::*; use crate::parser::*; use nom::branch::*; use nom::combinator::*; -use nom::multi::*; use nom::sequence::*; use nom::IResult; @@ -19,60 +19,92 @@ pub enum LoopStatement<'a> { #[derive(Debug)] pub struct LoopStatementForever<'a> { - pub nodes: (StatementOrNull<'a>,), + pub nodes: (Symbol<'a>, StatementOrNull<'a>), } #[derive(Debug)] pub struct LoopStatementRepeat<'a> { - pub nodes: (Expression<'a>, StatementOrNull<'a>), + pub nodes: (Symbol<'a>, Paren<'a, Expression<'a>>, StatementOrNull<'a>), } #[derive(Debug)] pub struct LoopStatementWhile<'a> { - pub nodes: (Expression<'a>, StatementOrNull<'a>), + pub nodes: (Symbol<'a>, Paren<'a, Expression<'a>>, StatementOrNull<'a>), } #[derive(Debug)] pub struct LoopStatementFor<'a> { pub nodes: ( - Option>, - Option>, - Option>>, + Symbol<'a>, + Paren< + 'a, + ( + Option>, + Symbol<'a>, + Option>, + Symbol<'a>, + Option>, + ), + >, StatementOrNull<'a>, ), } #[derive(Debug)] pub struct LoopStatementDoWhile<'a> { - pub nodes: (StatementOrNull<'a>, Expression<'a>), + pub nodes: ( + Symbol<'a>, + StatementOrNull<'a>, + Symbol<'a>, + Paren<'a, Expression<'a>>, + Symbol<'a>, + ), } #[derive(Debug)] pub struct LoopStatementForeach<'a> { pub nodes: ( - PsOrHierarchicalArrayIdentifier<'a>, - LoopVariables<'a>, + Symbol<'a>, + Paren< + 'a, + ( + PsOrHierarchicalArrayIdentifier<'a>, + Bracket<'a, LoopVariables<'a>>, + ), + >, Statement<'a>, ), } #[derive(Debug)] pub enum ForInitialization<'a> { - Assignment(ListOfVariableAssignments<'a>), - Declaration(Vec>), + ListOfVariableAssignments(ListOfVariableAssignments<'a>), + Declaration(ForInitializationDeclaration<'a>), +} + +#[derive(Debug)] +pub struct ForInitializationDeclaration<'a> { + pub nodes: (List, ForVariableDeclaration<'a>>,), } #[derive(Debug)] pub struct ForVariableDeclaration<'a> { pub nodes: ( - Option, + Option>, DataType<'a>, - Vec<(VariableIdentifier<'a>, Expression<'a>)>, + List, (VariableIdentifier<'a>, Symbol<'a>, Expression<'a>)>, ), } +#[derive(Debug, Node)] +pub struct Var<'a> { + pub nodes: (Symbol<'a>,), +} + #[derive(Debug)] -pub struct Var {} +pub struct ForStep<'a> { + pub nodes: (List, ForStepAssignment<'a>>,), +} #[derive(Debug)] pub enum ForStepAssignment<'a> { @@ -83,7 +115,7 @@ pub enum ForStepAssignment<'a> { #[derive(Debug)] pub struct LoopVariables<'a> { - pub nodes: (Vec>>,), + pub nodes: (List, Option>>,), } // ----------------------------------------------------------------------------- @@ -100,114 +132,109 @@ pub fn loop_statement(s: Span) -> IResult { } pub fn loop_statement_forever(s: Span) -> IResult { - let (s, _) = symbol("forever")(s)?; - let (s, x) = statement_or_null(s)?; + let (s, a) = symbol("forever")(s)?; + let (s, b) = statement_or_null(s)?; Ok(( s, - LoopStatement::Forever(LoopStatementForever { nodes: (x,) }), + LoopStatement::Forever(LoopStatementForever { nodes: (a, b) }), )) } pub fn loop_statement_repeat(s: Span) -> IResult { - let (s, _) = symbol("repeat")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, y) = statement_or_null(s)?; + let (s, a) = symbol("repeat")(s)?; + let (s, b) = paren2(expression)(s)?; + let (s, c) = statement_or_null(s)?; Ok(( s, - LoopStatement::Repeat(LoopStatementRepeat { nodes: (x, y) }), + LoopStatement::Repeat(LoopStatementRepeat { nodes: (a, b, c) }), )) } pub fn loop_statement_while(s: Span) -> IResult { - let (s, _) = symbol("while")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, y) = statement_or_null(s)?; + let (s, a) = symbol("while")(s)?; + let (s, b) = paren2(expression)(s)?; + let (s, c) = statement_or_null(s)?; Ok(( s, - LoopStatement::While(LoopStatementWhile { nodes: (x, y) }), + LoopStatement::While(LoopStatementWhile { nodes: (a, b, c) }), )) } pub fn loop_statement_for(s: Span) -> IResult { - let (s, _) = symbol("for")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = opt(for_initialization)(s)?; - let (s, _) = symbol(";")(s)?; - let (s, y) = opt(expression)(s)?; - let (s, _) = symbol(";")(s)?; - let (s, z) = opt(for_step)(s)?; - let (s, _) = symbol(")")(s)?; - let (s, v) = statement_or_null(s)?; + let (s, a) = symbol("for")(s)?; + let (s, b) = paren2(tuple(( + opt(for_initialization), + symbol(":"), + opt(expression), + symbol(":"), + opt(for_step), + )))(s)?; + let (s, c) = statement_or_null(s)?; + Ok((s, LoopStatement::For(LoopStatementFor { nodes: (a, b, c) }))) +} + +pub fn loop_statement_do_while(s: Span) -> IResult { + let (s, a) = symbol("do")(s)?; + let (s, b) = statement_or_null(s)?; + let (s, c) = symbol("while")(s)?; + let (s, d) = paren2(expression)(s)?; + let (s, e) = symbol(";")(s)?; Ok(( s, - LoopStatement::For(LoopStatementFor { - nodes: (x, y, z, v), + LoopStatement::DoWhile(LoopStatementDoWhile { + nodes: (a, b, c, d, e), }), )) } -pub fn loop_statement_do_while(s: Span) -> IResult { - let (s, _) = symbol("do")(s)?; - let (s, x) = statement_or_null(s)?; - let (s, _) = symbol("while")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, y) = expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, _) = symbol(";")(s)?; - Ok(( - s, - LoopStatement::DoWhile(LoopStatementDoWhile { nodes: (x, y) }), - )) -} - pub fn loop_statement_foreach(s: Span) -> IResult { - let (s, _) = symbol("foreach")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = ps_or_hierarchical_array_identifier(s)?; - let (s, _) = symbol("[")(s)?; - let (s, y) = loop_variables(s)?; - let (s, _) = symbol("]")(s)?; - let (s, _) = symbol(")")(s)?; - let (s, z) = statement(s)?; + let (s, a) = symbol("foreach")(s)?; + let (s, b) = paren2(pair( + ps_or_hierarchical_array_identifier, + bracket2(loop_variables), + ))(s)?; + let (s, c) = statement(s)?; Ok(( s, - LoopStatement::Foreach(LoopStatementForeach { nodes: (x, y, z) }), + LoopStatement::Foreach(LoopStatementForeach { nodes: (a, b, c) }), )) } pub fn for_initialization(s: Span) -> IResult { alt(( map(list_of_variable_assignments, |x| { - ForInitialization::Assignment(x) + ForInitialization::ListOfVariableAssignments(x) }), - map( - separated_nonempty_list(symbol(","), for_variable_declaration), - |x| ForInitialization::Declaration(x), - ), + for_initialization_declaration, ))(s) } -pub fn for_variable_declaration(s: Span) -> IResult { - let (s, x) = opt(symbol("var"))(s)?; - let (s, y) = data_type(s)?; - let (s, z) = separated_nonempty_list( - symbol(","), - pair(variable_identifier, preceded(symbol("="), expression)), - )(s)?; +pub fn for_initialization_declaration(s: Span) -> IResult { + let (s, a) = list(symbol(","), for_variable_declaration)(s)?; Ok(( s, - ForVariableDeclaration { - nodes: (x.map(|_| Var {}), y, z), - }, + ForInitialization::Declaration(ForInitializationDeclaration { nodes: (a,) }), )) } -pub fn for_step(s: Span) -> IResult> { - separated_nonempty_list(symbol(","), for_step_assignment)(s) +pub fn for_variable_declaration(s: Span) -> IResult { + let (s, a) = opt(var)(s)?; + let (s, b) = data_type(s)?; + let (s, c) = list( + symbol(","), + triple(variable_identifier, symbol("="), expression), + )(s)?; + Ok((s, ForVariableDeclaration { nodes: (a, b, c) })) +} + +pub fn var(s: Span) -> IResult { + let (s, a) = symbol("var")(s)?; + Ok((s, Var { nodes: (a,) })) +} + +pub fn for_step(s: Span) -> IResult { + let (s, a) = list(symbol(","), for_step_assignment)(s)?; + Ok((s, ForStep { nodes: (a,) })) } pub fn for_step_assignment(s: Span) -> IResult { @@ -225,8 +252,8 @@ pub fn for_step_assignment(s: Span) -> IResult { } pub fn loop_variables(s: Span) -> IResult { - let (s, x) = separated_nonempty_list(symbol(","), opt(index_variable_identifier))(s)?; - Ok((s, LoopVariables { nodes: (x,) })) + let (s, a) = list(symbol(","), opt(index_variable_identifier))(s)?; + Ok((s, LoopVariables { nodes: (a,) })) } // ----------------------------------------------------------------------------- diff --git a/src/parser/behavioral_statements/patterns.rs b/src/parser/behavioral_statements/patterns.rs index 1b93b10..e6310bf 100644 --- a/src/parser/behavioral_statements/patterns.rs +++ b/src/parser/behavioral_statements/patterns.rs @@ -1,7 +1,7 @@ +use crate::ast::*; use crate::parser::*; use nom::branch::*; use nom::combinator::*; -use nom::multi::*; use nom::sequence::*; use nom::IResult; @@ -9,38 +9,94 @@ use nom::IResult; #[derive(Debug)] pub enum Pattern<'a> { - VariableIdentifier(Box>), - Asterisk, + Variable(Box>), + Asterisk(Symbol<'a>), ConstantExpression(Box>), - Tagged(Box<(MemberIdentifier<'a>, Option>)>), - Pattern(Box>>), - MemberPattern(Box, Pattern<'a>)>>), + Tagged(Box>), + List(Box>), + IdentifierList(Box>), +} + +#[derive(Debug, Node)] +pub struct PatternVariable<'a> { + pub nodes: (Symbol<'a>, VariableIdentifier<'a>), +} + +#[derive(Debug)] +pub struct PatternTagged<'a> { + pub nodes: (Symbol<'a>, MemberIdentifier<'a>, Option>), +} + +#[derive(Debug)] +pub struct PatternList<'a> { + pub nodes: (ApostropheBrace<'a, List, Pattern<'a>>>,), +} + +#[derive(Debug)] +pub struct PatternIdentifierList<'a> { + pub nodes: + (ApostropheBrace<'a, List, (MemberIdentifier<'a>, Symbol<'a>, Pattern<'a>)>>,), } #[derive(Debug)] pub enum AssignmentPattern<'a> { - Expression(Vec>), - StructurePatternKey(Vec<(StructurePatternKey<'a>, Expression<'a>)>), - ArrayPatternKey(Vec<(ArrayPatternKey<'a>, Expression<'a>)>), - ConstantExpression((ConstantExpression<'a>, Vec>)), + List(AssignmentPatternList<'a>), + Structure(AssignmentPatternStructure<'a>), + Array(AssignmentPatternArray<'a>), + Repeat(AssignmentPatternRepeat<'a>), +} + +#[derive(Debug)] +pub struct AssignmentPatternList<'a> { + pub nodes: (ApostropheBrace<'a, List, Expression<'a>>>,), +} + +#[derive(Debug)] +pub struct AssignmentPatternStructure<'a> { + pub nodes: ( + ApostropheBrace< + 'a, + List, (StructurePatternKey<'a>, Symbol<'a>, Expression<'a>)>, + >, + ), +} + +#[derive(Debug)] +pub struct AssignmentPatternArray<'a> { + pub nodes: ( + ApostropheBrace<'a, List, (ArrayPatternKey<'a>, Symbol<'a>, Expression<'a>)>>, + ), +} + +#[derive(Debug)] +pub struct AssignmentPatternRepeat<'a> { + pub nodes: ( + ApostropheBrace< + 'a, + ( + ConstantExpression<'a>, + Brace<'a, List, Expression<'a>>>, + ), + >, + ), } #[derive(Debug)] pub enum StructurePatternKey<'a> { - Identifier(MemberIdentifier<'a>), - PatternKey(AssignmentPatternKey<'a>), + MemberIdentifier(MemberIdentifier<'a>), + AssignmentPatternKey(AssignmentPatternKey<'a>), } #[derive(Debug)] pub enum ArrayPatternKey<'a> { - Expression(ConstantExpression<'a>), - PatternKey(AssignmentPatternKey<'a>), + ConstantExpression(ConstantExpression<'a>), + AssignmentPatternKey(AssignmentPatternKey<'a>), } #[derive(Debug)] pub enum AssignmentPatternKey<'a> { SimpleType(SimpleType<'a>), - Default, + Default(Symbol<'a>), } #[derive(Debug)] @@ -53,9 +109,9 @@ pub struct AssignmentPatternExpression<'a> { #[derive(Debug)] pub enum AssignmentPatternExpressionType<'a> { - Type(PsTypeIdentifier<'a>), - Parameter(PsParameterIdentifier<'a>), - IntegerAtom(IntegerAtomType), + PsTypeIdentifier(PsTypeIdentifier<'a>), + PsParameterIdentifier(PsParameterIdentifier<'a>), + IntegerAtomType(IntegerAtomType), TypeReference(TypeReference<'a>), } @@ -66,100 +122,147 @@ pub struct ConstantAssignmentPatternExpression<'a> { #[derive(Debug)] pub struct AssignmentPatternNetLvalue<'a> { - pub nodes: (Vec>,), + pub nodes: (ApostropheBrace<'a, List, NetLvalue<'a>>>,), } #[derive(Debug)] pub struct AssignmentPatternVariableLvalue<'a> { - pub nodes: (Vec>,), + pub nodes: (ApostropheBrace<'a, List, VariableLvalue<'a>>>,), } // ----------------------------------------------------------------------------- pub fn pattern(s: Span) -> IResult { alt(( - map(preceded(symbol("."), variable_identifier), |x| { - Pattern::VariableIdentifier(Box::new(x)) - }), - map(symbol(".*"), |_| Pattern::Asterisk), + pattern_variable, + map(symbol(".*"), |x| Pattern::Asterisk(x)), map(constant_expression, |x| { Pattern::ConstantExpression(Box::new(x)) }), - map( - preceded(symbol("tagged"), pair(member_identifier, opt(pattern))), - |x| Pattern::Tagged(Box::new(x)), - ), - map( - apostrophe_brace(separated_nonempty_list(symbol(","), pattern)), - |x| Pattern::Pattern(Box::new(x)), - ), - map( - apostrophe_brace(separated_nonempty_list( - symbol(","), - pair(member_identifier, preceded(symbol(":"), pattern)), - )), - |x| Pattern::MemberPattern(Box::new(x)), - ), + pattern_tagged, + pattern_list, + pattern_identifier_list, ))(s) } +pub fn pattern_variable(s: Span) -> IResult { + let (s, a) = symbol(".")(s)?; + let (s, b) = variable_identifier(s)?; + Ok(( + s, + Pattern::Variable(Box::new(PatternVariable { nodes: (a, b) })), + )) +} + +pub fn pattern_tagged(s: Span) -> IResult { + let (s, a) = symbol("tagged")(s)?; + let (s, b) = member_identifier(s)?; + let (s, c) = opt(pattern)(s)?; + Ok(( + s, + Pattern::Tagged(Box::new(PatternTagged { nodes: (a, b, c) })), + )) +} + +pub fn pattern_list(s: Span) -> IResult { + let (s, a) = apostrophe_brace2(list(symbol(","), pattern))(s)?; + Ok((s, Pattern::List(Box::new(PatternList { nodes: (a,) })))) +} + +pub fn pattern_identifier_list(s: Span) -> IResult { + let (s, a) = apostrophe_brace2(list( + symbol(","), + triple(member_identifier, symbol(":"), pattern), + ))(s)?; + Ok(( + s, + Pattern::IdentifierList(Box::new(PatternIdentifierList { nodes: (a,) })), + )) +} + pub fn assignment_pattern(s: Span) -> IResult { alt(( - map( - apostrophe_brace(separated_nonempty_list(symbol(","), expression)), - |x| AssignmentPattern::Expression(x), - ), - map( - apostrophe_brace(separated_nonempty_list( - symbol(","), - pair(structure_pattern_key, preceded(symbol(":"), expression)), - )), - |x| AssignmentPattern::StructurePatternKey(x), - ), - map( - apostrophe_brace(separated_nonempty_list( - symbol(","), - pair(array_pattern_key, preceded(symbol(":"), expression)), - )), - |x| AssignmentPattern::ArrayPatternKey(x), - ), - map( - apostrophe_brace(pair( - constant_expression, - brace(separated_nonempty_list(symbol(","), expression)), - )), - |x| AssignmentPattern::ConstantExpression(x), - ), + assignment_pattern_list, + assignment_pattern_structure, + assignment_pattern_array, + assignment_pattern_repeat, ))(s) } +pub fn assignment_pattern_list(s: Span) -> IResult { + let (s, a) = apostrophe_brace2(list(symbol(","), expression))(s)?; + Ok(( + s, + AssignmentPattern::List(AssignmentPatternList { nodes: (a,) }), + )) +} + +pub fn assignment_pattern_structure(s: Span) -> IResult { + let (s, a) = apostrophe_brace2(list( + symbol(","), + triple(structure_pattern_key, symbol(":"), expression), + ))(s)?; + Ok(( + s, + AssignmentPattern::Structure(AssignmentPatternStructure { nodes: (a,) }), + )) +} + +pub fn assignment_pattern_array(s: Span) -> IResult { + let (s, a) = apostrophe_brace2(list( + symbol(","), + triple(array_pattern_key, symbol(":"), expression), + ))(s)?; + Ok(( + s, + AssignmentPattern::Array(AssignmentPatternArray { nodes: (a,) }), + )) +} + +pub fn assignment_pattern_repeat(s: Span) -> IResult { + let (s, a) = apostrophe_brace2(pair( + constant_expression, + brace2(list(symbol(","), expression)), + ))(s)?; + Ok(( + s, + AssignmentPattern::Repeat(AssignmentPatternRepeat { nodes: (a,) }), + )) +} + pub fn structure_pattern_key(s: Span) -> IResult { alt(( - map(member_identifier, |x| StructurePatternKey::Identifier(x)), + map(member_identifier, |x| { + StructurePatternKey::MemberIdentifier(x) + }), map(assignment_pattern_key, |x| { - StructurePatternKey::PatternKey(x) + StructurePatternKey::AssignmentPatternKey(x) }), ))(s) } pub fn array_pattern_key(s: Span) -> IResult { alt(( - map(constant_expression, |x| ArrayPatternKey::Expression(x)), - map(assignment_pattern_key, |x| ArrayPatternKey::PatternKey(x)), + map(constant_expression, |x| { + ArrayPatternKey::ConstantExpression(x) + }), + map(assignment_pattern_key, |x| { + ArrayPatternKey::AssignmentPatternKey(x) + }), ))(s) } pub fn assignment_pattern_key(s: Span) -> IResult { alt(( map(simple_type, |x| AssignmentPatternKey::SimpleType(x)), - map(symbol("default"), |_| AssignmentPatternKey::Default), + map(symbol("default"), |x| AssignmentPatternKey::Default(x)), ))(s) } pub fn assignment_pattern_expression(s: Span) -> IResult { - let (s, x) = opt(assignment_pattern_expression_type)(s)?; - let (s, y) = assignment_pattern(s)?; - Ok((s, AssignmentPatternExpression { nodes: (x, y) })) + let (s, a) = opt(assignment_pattern_expression_type)(s)?; + let (s, b) = assignment_pattern(s)?; + Ok((s, AssignmentPatternExpression { nodes: (a, b) })) } pub fn assignment_pattern_expression_type( @@ -167,13 +270,13 @@ pub fn assignment_pattern_expression_type( ) -> IResult { alt(( map(ps_type_identifier, |x| { - AssignmentPatternExpressionType::Type(x) + AssignmentPatternExpressionType::PsTypeIdentifier(x) }), map(ps_parameter_identifier, |x| { - AssignmentPatternExpressionType::Parameter(x) + AssignmentPatternExpressionType::PsParameterIdentifier(x) }), map(integer_atom_type, |x| { - AssignmentPatternExpressionType::IntegerAtom(x) + AssignmentPatternExpressionType::IntegerAtomType(x) }), map(type_reference, |x| { AssignmentPatternExpressionType::TypeReference(x) @@ -189,15 +292,15 @@ pub fn constant_assignment_pattern_expression( } pub fn assignment_pattern_net_lvalue(s: Span) -> IResult { - let (s, x) = apostrophe_brace(separated_nonempty_list(symbol(","), net_lvalue))(s)?; - Ok((s, AssignmentPatternNetLvalue { nodes: (x,) })) + let (s, a) = apostrophe_brace2(list(symbol(","), net_lvalue))(s)?; + Ok((s, AssignmentPatternNetLvalue { nodes: (a,) })) } pub fn assignment_pattern_variable_lvalue( s: Span, ) -> IResult { - let (s, x) = apostrophe_brace(separated_nonempty_list(symbol(","), variable_lvalue))(s)?; - Ok((s, AssignmentPatternVariableLvalue { nodes: (x,) })) + let (s, a) = apostrophe_brace2(list(symbol(","), variable_lvalue))(s)?; + Ok((s, AssignmentPatternVariableLvalue { nodes: (a,) })) } // ----------------------------------------------------------------------------- diff --git a/src/parser/behavioral_statements/randsequence.rs b/src/parser/behavioral_statements/randsequence.rs index 700bf47..ff5ca5f 100644 --- a/src/parser/behavioral_statements/randsequence.rs +++ b/src/parser/behavioral_statements/randsequence.rs @@ -79,7 +79,7 @@ pub struct RsRepeat<'a> { #[derive(Debug)] pub struct RsCase<'a> { - pub nodes: (Expression<'a>, Vec>), + pub nodes: (CaseExpression<'a>, Vec>), } #[derive(Debug)] @@ -95,7 +95,7 @@ pub struct RsCaseItemDefault<'a> { #[derive(Debug)] pub struct RsCaseItemNondefault<'a> { - pub nodes: (Vec>, ProductionItem<'a>), + pub nodes: (Vec>, ProductionItem<'a>), } // ----------------------------------------------------------------------------- diff --git a/src/parser/behavioral_statements/timing_control_statements.rs b/src/parser/behavioral_statements/timing_control_statements.rs index cf68ed8..f3e60a6 100644 --- a/src/parser/behavioral_statements/timing_control_statements.rs +++ b/src/parser/behavioral_statements/timing_control_statements.rs @@ -1,7 +1,7 @@ +use crate::ast::*; use crate::parser::*; use nom::branch::*; use nom::combinator::*; -use nom::multi::*; use nom::sequence::*; use nom::IResult; @@ -21,30 +21,66 @@ pub enum DelayOrEventControl<'a> { #[derive(Debug)] pub struct DelayOrEventControlRepeat<'a> { - pub nodes: (Expression<'a>, EventControl<'a>), + pub nodes: (Symbol<'a>, Paren<'a, Expression<'a>>, EventControl<'a>), } #[derive(Debug)] pub enum DelayControl<'a> { - Delay(DelayValue<'a>), - Mintypmax(MintypmaxExpression<'a>), + Delay(DelayControlDelay<'a>), + Mintypmax(DelayControlMintypmax<'a>), +} + +#[derive(Debug, Node)] +pub struct DelayControlDelay<'a> { + pub nodes: (Symbol<'a>, DelayValue<'a>), +} + +#[derive(Debug)] +pub struct DelayControlMintypmax<'a> { + pub nodes: (Symbol<'a>, Paren<'a, MintypmaxExpression<'a>>), } #[derive(Debug)] pub enum EventControl<'a> { - EventIdentifier(HierarchicalEventIdentifier<'a>), - EventExpression(EventExpression<'a>), - Asterisk, - SequenceIdentifier(PsOrHierarchicalSequenceIdentifier<'a>), + EventIdentifier(EventControlEventIdentifier<'a>), + EventExpression(EventControlEventExpression<'a>), + Asterisk(EventControlAsterisk<'a>), + ParenAsterisk(EventControlParenAsterisk<'a>), + SequenceIdentifier(EventControlSequenceIdentifier<'a>), +} + +#[derive(Debug)] +pub struct EventControlEventIdentifier<'a> { + pub nodes: (Symbol<'a>, HierarchicalEventIdentifier<'a>), +} + +#[derive(Debug)] +pub struct EventControlEventExpression<'a> { + pub nodes: (Symbol<'a>, Paren<'a, EventExpression<'a>>), +} + +#[derive(Debug, Node)] +pub struct EventControlAsterisk<'a> { + pub nodes: (Symbol<'a>,), +} + +#[derive(Debug, Node)] +pub struct EventControlParenAsterisk<'a> { + pub nodes: (Symbol<'a>, Paren<'a, Symbol<'a>>), +} + +#[derive(Debug)] +pub struct EventControlSequenceIdentifier<'a> { + pub nodes: (Symbol<'a>, PsOrHierarchicalSequenceIdentifier<'a>), } #[derive(Debug)] pub enum EventExpression<'a> { Expression(Box>), Sequence(Box>), - Or(Box<(EventExpression<'a>, EventExpression<'a>)>), - Comma(Box<(EventExpression<'a>, EventExpression<'a>)>), - Paren(Box>), + Or(Box>), + Comma(Box>), + Paren(Box>), } #[derive(Debug)] @@ -52,13 +88,28 @@ pub struct EventExpressionExpression<'a> { pub nodes: ( Option>, Expression<'a>, - Option>, + Option<(Symbol<'a>, Expression<'a>)>, ), } #[derive(Debug)] pub struct EventExpressionSequence<'a> { - pub nodes: (SequenceInstance<'a>, Option>), + pub nodes: (SequenceInstance<'a>, Option<(Symbol<'a>, Expression<'a>)>), +} + +#[derive(Debug)] +pub struct EventExpressionOr<'a> { + pub nodes: (EventExpression<'a>, Symbol<'a>, EventExpression<'a>), +} + +#[derive(Debug)] +pub struct EventExpressionComma<'a> { + pub nodes: (EventExpression<'a>, Symbol<'a>, EventExpression<'a>), +} + +#[derive(Debug)] +pub struct EventExpressionParen<'a> { + pub nodes: (Paren<'a, EventExpression<'a>>,), } #[derive(Debug)] @@ -71,30 +122,49 @@ pub enum ProceduralTimingControl<'a> { #[derive(Debug)] pub enum JumpStatement<'a> { Return(JumpStatementReturn<'a>), - Break, - Continue, + Break(JumpStatementBreak<'a>), + Continue(JumpStatementContinue<'a>), } #[derive(Debug)] pub struct JumpStatementReturn<'a> { - pub nodes: (Option>,), + pub nodes: (Symbol<'a>, Option>, Symbol<'a>), +} + +#[derive(Debug, Node)] +pub struct JumpStatementBreak<'a> { + pub nodes: (Symbol<'a>, Symbol<'a>), +} + +#[derive(Debug, Node)] +pub struct JumpStatementContinue<'a> { + pub nodes: (Symbol<'a>, Symbol<'a>), } #[derive(Debug)] pub enum WaitStatement<'a> { Wait(WaitStatementWait<'a>), - Fork, + Fork(WaitStatementFork<'a>), Order(WaitStatementOrder<'a>), } #[derive(Debug)] pub struct WaitStatementWait<'a> { - pub nodes: (Expression<'a>, StatementOrNull<'a>), + pub nodes: (Symbol<'a>, Paren<'a, Expression<'a>>, StatementOrNull<'a>), +} + +#[derive(Debug, Node)] +pub struct WaitStatementFork<'a> { + pub nodes: (Symbol<'a>, Symbol<'a>, Symbol<'a>), } #[derive(Debug)] pub struct WaitStatementOrder<'a> { - pub nodes: (Vec>, ActionBlock<'a>), + pub nodes: ( + Symbol<'a>, + Paren<'a, List, HierarchicalIdentifier<'a>>>, + ActionBlock<'a>, + ), } #[derive(Debug)] @@ -105,22 +175,39 @@ pub enum EventTrigger<'a> { #[derive(Debug)] pub struct EventTriggerNamed<'a> { - pub nodes: (HierarchicalEventIdentifier<'a>,), + pub nodes: (Symbol<'a>, HierarchicalEventIdentifier<'a>, Symbol<'a>), } #[derive(Debug)] pub struct EventTriggerNonblocking<'a> { pub nodes: ( + Symbol<'a>, Option>, HierarchicalEventIdentifier<'a>, + Symbol<'a>, ), } #[derive(Debug)] pub enum DisableStatement<'a> { - Task(HierarchicalTaskIdentifier<'a>), - Block(HierarchicalBlockIdentifier<'a>), - Fork, + Task(DisableStatementTask<'a>), + Block(DisableStatementBlock<'a>), + Fork(DisableStatementFork<'a>), +} + +#[derive(Debug)] +pub struct DisableStatementTask<'a> { + pub nodes: (Symbol<'a>, HierarchicalTaskIdentifier<'a>, Symbol<'a>), +} + +#[derive(Debug)] +pub struct DisableStatementBlock<'a> { + pub nodes: (Symbol<'a>, HierarchicalBlockIdentifier<'a>, Symbol<'a>), +} + +#[derive(Debug, Node)] +pub struct DisableStatementFork<'a> { + pub nodes: (Symbol<'a>, Symbol<'a>, Symbol<'a>), } // ----------------------------------------------------------------------------- @@ -128,9 +215,9 @@ pub enum DisableStatement<'a> { pub fn procedural_timing_control_statement( s: Span, ) -> IResult { - let (s, x) = procedural_timing_control(s)?; - let (s, y) = statement_or_null(s)?; - Ok((s, ProceduralTimingControlStatement { nodes: (x, y) })) + let (s, a) = procedural_timing_control(s)?; + let (s, b) = statement_or_null(s)?; + Ok((s, ProceduralTimingControlStatement { nodes: (a, b) })) } pub fn delay_or_event_control(s: Span) -> IResult { @@ -142,14 +229,12 @@ pub fn delay_or_event_control(s: Span) -> IResult { } pub fn delay_or_event_control_repeat(s: Span) -> IResult { - let (s, _) = symbol("repeat")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = expression(s)?; - let (s, _) = symbol(")")(s)?; - let (s, y) = event_control(s)?; + let (s, a) = symbol("repeat")(s)?; + let (s, b) = paren2(expression)(s)?; + let (s, c) = event_control(s)?; Ok(( s, - DelayOrEventControl::Repeat(DelayOrEventControlRepeat { nodes: (x, y) }), + DelayOrEventControl::Repeat(DelayOrEventControlRepeat { nodes: (a, b, c) }), )) } @@ -158,17 +243,18 @@ pub fn delay_control(s: Span) -> IResult { } pub fn delay_control_delay(s: Span) -> IResult { - let (s, _) = symbol("#")(s)?; - let (s, x) = delay_value(s)?; - Ok((s, DelayControl::Delay(x))) + let (s, a) = symbol("#")(s)?; + let (s, b) = delay_value(s)?; + Ok((s, DelayControl::Delay(DelayControlDelay { nodes: (a, b) }))) } pub fn delay_control_mintypmax(s: Span) -> IResult { - let (s, _) = symbol("#")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = mintypmax_expression(s)?; - let (s, _) = symbol(")")(s)?; - Ok((s, DelayControl::Mintypmax(x))) + let (s, a) = symbol("#")(s)?; + let (s, b) = paren2(mintypmax_expression)(s)?; + Ok(( + s, + DelayControl::Mintypmax(DelayControlMintypmax { nodes: (a, b) }), + )) } pub fn event_control(s: Span) -> IResult { @@ -176,33 +262,53 @@ pub fn event_control(s: Span) -> IResult { event_control_event_identifier, event_control_event_expression, event_control_asterisk, + event_control_paren_asterisk, event_control_sequence_identifier, ))(s) } pub fn event_control_event_identifier(s: Span) -> IResult { - let (s, _) = symbol("@")(s)?; - let (s, x) = hierarchical_event_identifier(s)?; - Ok((s, EventControl::EventIdentifier(x))) + let (s, a) = symbol("@")(s)?; + let (s, b) = hierarchical_event_identifier(s)?; + Ok(( + s, + EventControl::EventIdentifier(EventControlEventIdentifier { nodes: (a, b) }), + )) } pub fn event_control_event_expression(s: Span) -> IResult { - let (s, _) = symbol("@")(s)?; - let (s, _) = symbol("(")(s)?; - let (s, x) = event_expression(s)?; - let (s, _) = symbol(")")(s)?; - Ok((s, EventControl::EventExpression(x))) + let (s, a) = symbol("@")(s)?; + let (s, b) = paren2(event_expression)(s)?; + Ok(( + s, + EventControl::EventExpression(EventControlEventExpression { nodes: (a, b) }), + )) } pub fn event_control_asterisk(s: Span) -> IResult { - let (s, _) = alt((symbol("@*"), preceded(symbol("@"), symbol("(*)"))))(s)?; - Ok((s, EventControl::Asterisk)) + let (s, a) = symbol("@*")(s)?; + Ok(( + s, + EventControl::Asterisk(EventControlAsterisk { nodes: (a,) }), + )) +} + +pub fn event_control_paren_asterisk(s: Span) -> IResult { + let (s, a) = symbol("@")(s)?; + let (s, b) = paren2(symbol("*"))(s)?; + Ok(( + s, + EventControl::ParenAsterisk(EventControlParenAsterisk { nodes: (a, b) }), + )) } pub fn event_control_sequence_identifier(s: Span) -> IResult { - let (s, _) = symbol("@")(s)?; - let (s, x) = ps_or_hierarchical_sequence_identifier(s)?; - Ok((s, EventControl::SequenceIdentifier(x))) + let (s, a) = symbol("@")(s)?; + let (s, b) = ps_or_hierarchical_sequence_identifier(s)?; + Ok(( + s, + EventControl::SequenceIdentifier(EventControlSequenceIdentifier { nodes: (a, b) }), + )) } pub fn event_expression(s: Span) -> IResult { @@ -216,43 +322,50 @@ pub fn event_expression(s: Span) -> IResult { } pub fn event_expression_expression(s: Span) -> IResult { - let (s, x) = opt(edge_identifier)(s)?; - let (s, y) = expression(s)?; - let (s, z) = opt(preceded(symbol("iff"), expression))(s)?; + let (s, a) = opt(edge_identifier)(s)?; + let (s, b) = expression(s)?; + let (s, c) = opt(pair(symbol("iff"), expression))(s)?; Ok(( s, - EventExpression::Expression(Box::new(EventExpressionExpression { nodes: (x, y, z) })), + EventExpression::Expression(Box::new(EventExpressionExpression { nodes: (a, b, c) })), )) } pub fn event_expression_sequence(s: Span) -> IResult { - let (s, x) = sequence_instance(s)?; - let (s, y) = opt(preceded(symbol("iff"), expression))(s)?; + let (s, a) = sequence_instance(s)?; + let (s, b) = opt(pair(symbol("iff"), expression))(s)?; Ok(( s, - EventExpression::Sequence(Box::new(EventExpressionSequence { nodes: (x, y) })), + EventExpression::Sequence(Box::new(EventExpressionSequence { nodes: (a, b) })), )) } pub fn event_expression_or(s: Span) -> IResult { - let (s, x) = event_expression(s)?; - let (s, _) = symbol("or")(s)?; - let (s, y) = event_expression(s)?; - Ok((s, EventExpression::Or(Box::new((x, y))))) + let (s, a) = event_expression(s)?; + let (s, b) = symbol("or")(s)?; + let (s, c) = event_expression(s)?; + Ok(( + s, + EventExpression::Or(Box::new(EventExpressionOr { nodes: (a, b, c) })), + )) } pub fn event_expression_comma(s: Span) -> IResult { - let (s, x) = event_expression(s)?; - let (s, _) = symbol(",")(s)?; - let (s, y) = event_expression(s)?; - Ok((s, EventExpression::Comma(Box::new((x, y))))) + let (s, a) = event_expression(s)?; + let (s, b) = symbol(",")(s)?; + let (s, c) = event_expression(s)?; + Ok(( + s, + EventExpression::Comma(Box::new(EventExpressionComma { nodes: (a, b, c) })), + )) } pub fn event_expression_paren(s: Span) -> IResult { - let (s, _) = symbol("(")(s)?; - let (s, x) = event_expression(s)?; - let (s, _) = symbol(")")(s)?; - Ok((s, EventExpression::Paren(Box::new(x)))) + let (s, a) = paren2(event_expression)(s)?; + Ok(( + s, + EventExpression::Paren(Box::new(EventExpressionParen { nodes: (a,) })), + )) } pub fn procedural_timing_control(s: Span) -> IResult { @@ -272,25 +385,31 @@ pub fn jump_statement(s: Span) -> IResult { } pub fn jump_statement_return(s: Span) -> IResult { - let (s, _) = symbol("return")(s)?; - let (s, x) = opt(expression)(s)?; - let (s, _) = symbol(";")(s)?; + let (s, a) = symbol("return")(s)?; + let (s, b) = opt(expression)(s)?; + let (s, c) = symbol(";")(s)?; Ok(( s, - JumpStatement::Return(JumpStatementReturn { nodes: (x,) }), + JumpStatement::Return(JumpStatementReturn { nodes: (a, b, c) }), )) } pub fn jump_statement_break(s: Span) -> IResult { - let (s, _) = symbol("break")(s)?; - let (s, _) = symbol(";")(s)?; - Ok((s, JumpStatement::Break)) + let (s, a) = symbol("break")(s)?; + let (s, b) = symbol(";")(s)?; + Ok(( + s, + JumpStatement::Break(JumpStatementBreak { nodes: (a, b) }), + )) } pub fn jump_statement_continue(s: Span) -> IResult { - let (s, _) = symbol("continue")(s)?; - let (s, _) = symbol(";")(s)?; - Ok((s, JumpStatement::Continue)) + let (s, a) = symbol("continue")(s)?; + let (s, b) = symbol(";")(s)?; + Ok(( + s, + JumpStatement::Continue(JumpStatementContinue { nodes: (a, b) }), + )) } pub fn wait_statement(s: Span) -> IResult { @@ -302,29 +421,32 @@ pub fn wait_statement(s: Span) -> IResult { } pub fn wait_statement_wait(s: Span) -> IResult { - let (s, _) = symbol("wait")(s)?; - let (s, x) = paren(expression)(s)?; - let (s, y) = statement_or_null(s)?; - Ok((s, WaitStatement::Wait(WaitStatementWait { nodes: (x, y) }))) + let (s, a) = symbol("wait")(s)?; + let (s, b) = paren2(expression)(s)?; + let (s, c) = statement_or_null(s)?; + Ok(( + s, + WaitStatement::Wait(WaitStatementWait { nodes: (a, b, c) }), + )) } pub fn wait_statement_fork(s: Span) -> IResult { - let (s, _) = symbol("wait")(s)?; - let (s, _) = symbol("fork")(s)?; - let (s, _) = symbol(";")(s)?; - Ok((s, WaitStatement::Fork)) + let (s, a) = symbol("wait")(s)?; + let (s, b) = symbol("fork")(s)?; + let (s, c) = symbol(";")(s)?; + Ok(( + s, + WaitStatement::Fork(WaitStatementFork { nodes: (a, b, c) }), + )) } pub fn wait_statement_order(s: Span) -> IResult { - let (s, _) = symbol("wait_order")(s)?; - let (s, x) = paren(separated_nonempty_list( - symbol(","), - hierarchical_identifier, - ))(s)?; - let (s, y) = action_block(s)?; + let (s, a) = symbol("wait_order")(s)?; + let (s, b) = paren2(list(symbol(","), hierarchical_identifier))(s)?; + let (s, c) = action_block(s)?; Ok(( s, - WaitStatement::Order(WaitStatementOrder { nodes: (x, y) }), + WaitStatement::Order(WaitStatementOrder { nodes: (a, b, c) }), )) } @@ -333,20 +455,25 @@ pub fn event_trigger(s: Span) -> IResult { } pub fn event_trigger_named(s: Span) -> IResult { - let (s, _) = symbol("->")(s)?; - let (s, x) = hierarchical_event_identifier(s)?; - let (s, _) = symbol(";")(s)?; - Ok((s, EventTrigger::Named(EventTriggerNamed { nodes: (x,) }))) + let (s, a) = symbol("->")(s)?; + let (s, b) = hierarchical_event_identifier(s)?; + let (s, c) = symbol(";")(s)?; + Ok(( + s, + EventTrigger::Named(EventTriggerNamed { nodes: (a, b, c) }), + )) } pub fn event_trigger_nonblocking(s: Span) -> IResult { - let (s, _) = symbol("->>")(s)?; - let (s, x) = opt(delay_or_event_control)(s)?; - let (s, y) = hierarchical_event_identifier(s)?; - let (s, _) = symbol(";")(s)?; + let (s, a) = symbol("->>")(s)?; + let (s, b) = opt(delay_or_event_control)(s)?; + let (s, c) = hierarchical_event_identifier(s)?; + let (s, d) = symbol(";")(s)?; Ok(( s, - EventTrigger::Nonblocking(EventTriggerNonblocking { nodes: (x, y) }), + EventTrigger::Nonblocking(EventTriggerNonblocking { + nodes: (a, b, c, d), + }), )) } @@ -359,22 +486,31 @@ pub fn disable_statement(s: Span) -> IResult { } pub fn disable_statement_task(s: Span) -> IResult { - let (s, _) = symbol("disable")(s)?; - let (s, x) = hierarchical_task_identifier(s)?; - let (s, _) = symbol(";")(s)?; - Ok((s, DisableStatement::Task(x))) + let (s, a) = symbol("disable")(s)?; + let (s, b) = hierarchical_task_identifier(s)?; + let (s, c) = symbol(";")(s)?; + Ok(( + s, + DisableStatement::Task(DisableStatementTask { nodes: (a, b, c) }), + )) } pub fn disable_statement_block(s: Span) -> IResult { - let (s, _) = symbol("disable")(s)?; - let (s, x) = hierarchical_block_identifier(s)?; - let (s, _) = symbol(";")(s)?; - Ok((s, DisableStatement::Block(x))) + let (s, a) = symbol("disable")(s)?; + let (s, b) = hierarchical_block_identifier(s)?; + let (s, c) = symbol(";")(s)?; + Ok(( + s, + DisableStatement::Block(DisableStatementBlock { nodes: (a, b, c) }), + )) } pub fn disable_statement_fork(s: Span) -> IResult { - let (s, _) = symbol("disable")(s)?; - let (s, _) = symbol("fork")(s)?; - let (s, _) = symbol(";")(s)?; - Ok((s, DisableStatement::Fork)) + let (s, a) = symbol("disable")(s)?; + let (s, b) = symbol("fork")(s)?; + let (s, c) = symbol(";")(s)?; + Ok(( + s, + DisableStatement::Fork(DisableStatementFork { nodes: (a, b, c) }), + )) } diff --git a/src/parser/declarations/delays.rs b/src/parser/declarations/delays.rs index 48216e6..6287849 100644 --- a/src/parser/declarations/delays.rs +++ b/src/parser/declarations/delays.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; //use nom::branch::*; //use nom::combinator::*; @@ -12,7 +13,7 @@ pub enum Delay3<'a> { Mintypmax(Delay3Mintypmax<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct Delay3Single<'a> { pub nodes: (Symbol<'a>, DelayValue<'a>), } @@ -37,7 +38,7 @@ pub enum Delay2<'a> { Mintypmax(Delay2Mintypmax<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct Delay2Single<'a> { pub nodes: (Symbol<'a>, DelayValue<'a>), } @@ -50,7 +51,7 @@ pub struct Delay2Mintypmax<'a> { ), } -#[derive(Debug)] +#[derive(Debug, Node)] pub enum DelayValue<'a> { UnsignedNumber(UnsignedNumber<'a>), RealNumber(RealNumber<'a>), diff --git a/src/parser/declarations/task_declarations.rs b/src/parser/declarations/task_declarations.rs index db66f0c..b2d9c63 100644 --- a/src/parser/declarations/task_declarations.rs +++ b/src/parser/declarations/task_declarations.rs @@ -62,7 +62,7 @@ pub struct TfPortItem<'a> { pub nodes: ( Vec>, Option, - Option, + Option>, DataTypeOrImplicit<'a>, Option<( Identifier<'a>, @@ -83,7 +83,7 @@ pub struct TfPortDeclaration<'a> { pub nodes: ( Vec>, TfPortDirection, - Option, + Option>, DataTypeOrImplicit<'a>, ListOfTfVariableIdentifiers<'a>, ), diff --git a/src/parser/expressions/expression_leftside_values.rs b/src/parser/expressions/expression_leftside_values.rs index 721f1a8..dfd323e 100644 --- a/src/parser/expressions/expression_leftside_values.rs +++ b/src/parser/expressions/expression_leftside_values.rs @@ -9,7 +9,7 @@ use nom::IResult; pub enum NetLvalue<'a> { Identifier(NetLvalueIdentifier<'a>), Lvalue(Box>), - Pattern(NetLvaluePattern<'a>), + Pattern(Box>), } #[derive(Debug)] @@ -34,7 +34,7 @@ pub struct NetLvaluePattern<'a> { pub enum VariableLvalue<'a> { Identifier(VariableLvalueIdentifier<'a>), Lvalue(Box>), - Pattern(VariableLvaluePattern<'a>), + Pattern(Box>), StreamingConcatenation(StreamingConcatenation<'a>), } @@ -87,7 +87,10 @@ pub fn net_lvalue_identifier(s: Span) -> IResult { pub fn net_lvalue_pattern(s: Span) -> IResult { let (s, a) = opt(assignment_pattern_expression_type)(s)?; let (s, b) = assignment_pattern_net_lvalue(s)?; - Ok((s, NetLvalue::Pattern(NetLvaluePattern { nodes: (a, b) }))) + Ok(( + s, + NetLvalue::Pattern(Box::new(NetLvaluePattern { nodes: (a, b) })), + )) } pub fn net_lvalue_lvalue(s: Span) -> IResult { @@ -124,7 +127,7 @@ pub fn variable_lvalue_pattern(s: Span) -> IResult { let (s, b) = assignment_pattern_variable_lvalue(s)?; Ok(( s, - VariableLvalue::Pattern(VariableLvaluePattern { nodes: (a, b) }), + VariableLvalue::Pattern(Box::new(VariableLvaluePattern { nodes: (a, b) })), )) } diff --git a/src/parser/expressions/expressions.rs b/src/parser/expressions/expressions.rs index 00c14ba..55bd19a 100644 --- a/src/parser/expressions/expressions.rs +++ b/src/parser/expressions/expressions.rs @@ -1,4 +1,3 @@ -use crate::ast::*; use crate::parser::*; use nom::branch::*; use nom::combinator::*; @@ -174,7 +173,7 @@ pub struct TaggedUnionExpression<'a> { #[derive(Debug)] pub struct InsideExpression<'a> { - pub nodes: (Expression<'a>, Symbol<'a>, Brace<'a, Vec>>), + pub nodes: (Expression<'a>, Symbol<'a>, Brace<'a, OpenRangeList<'a>>), } #[derive(Debug)] diff --git a/src/parser/expressions/operators.rs b/src/parser/expressions/operators.rs index 6415488..ea6dd85 100644 --- a/src/parser/expressions/operators.rs +++ b/src/parser/expressions/operators.rs @@ -1,30 +1,31 @@ +use crate::ast::*; use crate::parser::*; use nom::branch::*; use nom::IResult; // ----------------------------------------------------------------------------- -#[derive(Debug)] +#[derive(Debug, Node)] pub struct UnaryOperator<'a> { pub nodes: (Symbol<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct BinaryOperator<'a> { pub nodes: (Symbol<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct IncOrDecOperator<'a> { pub nodes: (Symbol<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct UnaryModulePathOperator<'a> { pub nodes: (Symbol<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct BinaryModulePathOperator<'a> { pub nodes: (Symbol<'a>,), } diff --git a/src/parser/expressions/primaries.rs b/src/parser/expressions/primaries.rs index 9e888fb..c046a7b 100644 --- a/src/parser/expressions/primaries.rs +++ b/src/parser/expressions/primaries.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; use nom::branch::*; use nom::combinator::*; @@ -144,11 +145,6 @@ pub struct ClassQualifier<'a> { ), } -#[derive(Debug)] -pub struct Local<'a> { - pub nodes: (Symbol<'a>,), -} - #[derive(Debug)] pub enum RangeExpression<'a> { Expression(Expression<'a>), @@ -163,23 +159,23 @@ pub enum PrimaryLiteral<'a> { StringLiteral(StringLiteral<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub enum TimeLiteral<'a> { Unsigned(TimeLiteralUnsigned<'a>), FixedPoint(TimeLiteralFixedPoint<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct TimeLiteralUnsigned<'a> { pub nodes: (UnsignedNumber<'a>, TimeUnit<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct TimeLiteralFixedPoint<'a> { pub nodes: (FixedPointNumber<'a>, TimeUnit<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub enum TimeUnit<'a> { S(Symbol<'a>), MS(Symbol<'a>), @@ -189,7 +185,7 @@ pub enum TimeUnit<'a> { FS(Symbol<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub enum ImplicitClassHandle<'a> { This(Symbol<'a>), Super(Symbol<'a>), @@ -267,6 +263,7 @@ pub struct Cast<'a> { pub fn constant_primary(s: Span) -> IResult { alt(( + map(symbol("null"), |x| ConstantPrimary::Null(x)), map(primary_literal, |x| ConstantPrimary::PrimaryLiteral(x)), constant_primary_ps_parameter, constant_primary_specparam, @@ -287,7 +284,6 @@ pub fn constant_primary(s: Span) -> IResult { ConstantPrimary::ConstantAssignmentPatternExpression(x) }), map(type_reference, |x| ConstantPrimary::TypeReference(x)), - map(symbol("null"), |x| ConstantPrimary::Null(x)), ))(s) } @@ -382,6 +378,9 @@ pub fn module_path_primary_mintypmax_expression(s: Span) -> IResult IResult { alt(( + map(symbol("this"), |x| Primary::This(x)), + map(symbol("$"), |x| Primary::Dollar(x)), + map(symbol("null"), |x| Primary::Null(x)), map(primary_literal, |x| Primary::PrimaryLiteral(x)), primary_hierarchical, map(empty_unpacked_array_concatenation, |x| { @@ -401,9 +400,6 @@ pub fn primary(s: Span) -> IResult { Primary::StreamingConcatenation(x) }), map(sequence_method_call, |x| Primary::SequenceMethodCall(x)), - map(symbol("this"), |x| Primary::This(x)), - map(symbol("$"), |x| Primary::Dollar(x)), - map(symbol("null"), |x| Primary::Null(x)), ))(s) } @@ -455,14 +451,9 @@ pub fn class_qualifier_or_package_scope(s: Span) -> IResult IResult { - let (s, a) = opt(symbol("local::"))(s)?; + let (s, a) = opt(local)(s)?; let (s, b) = opt(implicit_class_handle_or_class_scope)(s)?; - Ok(( - s, - ClassQualifier { - nodes: (a.map(|x| Local { nodes: (x,) }), b), - }, - )) + Ok((s, ClassQualifier { nodes: (a, b) })) } pub fn range_expression(s: Span) -> IResult { diff --git a/src/parser/expressions/strings.rs b/src/parser/expressions/strings.rs index 723525c..ff461e3 100644 --- a/src/parser/expressions/strings.rs +++ b/src/parser/expressions/strings.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; use nom::bytes::complete::*; use nom::combinator::*; @@ -7,7 +8,7 @@ use nom::IResult; // ----------------------------------------------------------------------------- -#[derive(Debug)] +#[derive(Debug, Node)] pub struct StringLiteral<'a> { pub nodes: (Span<'a>, Vec>), } diff --git a/src/parser/general/attributes.rs b/src/parser/general/attributes.rs index 1a5cd65..a9e65cf 100644 --- a/src/parser/general/attributes.rs +++ b/src/parser/general/attributes.rs @@ -1,4 +1,3 @@ -use crate::ast::*; use crate::parser::*; use nom::combinator::*; use nom::sequence::*; diff --git a/src/parser/general/identifiers.rs b/src/parser/general/identifiers.rs index 26803d3..67fdb3a 100644 --- a/src/parser/general/identifiers.rs +++ b/src/parser/general/identifiers.rs @@ -3,9 +3,9 @@ use crate::parser::*; use nom::branch::*; use nom::bytes::complete::*; use nom::combinator::*; -use nom::error::*; +use nom::multi::*; use nom::sequence::*; -use nom::{Err, IResult}; +use nom::IResult; // ----------------------------------------------------------------------------- @@ -13,122 +13,122 @@ const AZ_: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"; const AZ09_: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"; const AZ09_DOLLAR: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$"; -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ArrayIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct BlockIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct BinIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct CIdentifier<'a> { pub nodes: (Span<'a>, Vec>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct CellIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct CheckerIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ClassIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ClassVariableIdentifier<'a> { pub nodes: (VariableIdentifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ClockingIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ConfigIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ConstIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ConstraintIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct CovergroupIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct CovergroupVariableIdentifier<'a> { pub nodes: (VariableIdentifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct CoverPointIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct CrossIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct DynamicArrayVariableIdentifier<'a> { pub nodes: (VariableIdentifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct EnumIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct EscapedIdentifier<'a> { pub nodes: (Span<'a>, Vec>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct FormalIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct FormalPortIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct FunctionIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct GenerateBlockIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct GenvarIdentifier<'a> { pub nodes: (Identifier<'a>,), } @@ -151,14 +151,16 @@ pub struct HierarchicalEventIdentifier<'a> { #[derive(Debug)] pub struct HierarchicalIdentifier<'a> { pub nodes: ( - Option, - Vec<(Identifier<'a>, ConstantBitSelect<'a>)>, + Option>, + Vec<(Identifier<'a>, ConstantBitSelect<'a>, Symbol<'a>)>, Identifier<'a>, ), } -#[derive(Debug)] -pub struct Root {} +#[derive(Debug, Node)] +pub struct Root<'a> { + pub nodes: (Symbol<'a>, Symbol<'a>), +} #[derive(Debug)] pub struct HierarchicalNetIdentifier<'a> { @@ -195,134 +197,144 @@ pub struct HierarchicalVariableIdentifier<'a> { pub nodes: (HierarchicalIdentifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub enum Identifier<'a> { SimpleIdentifier(SimpleIdentifier<'a>), EscapedIdentifier(EscapedIdentifier<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct IndexVariableIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct InterfaceIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct InterfaceInstanceIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct InoutPortIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct InputPortIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct InstanceIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct LibraryIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct MemberIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct MethodIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ModportIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ModuleIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct NetIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct NetTypeIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct OutputPortIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct PackageIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub enum PackageScope<'a> { - PackageIdentifier(PackageIdentifier<'a>), - Unit, + Package(PackageScopePackage<'a>), + Unit(Unit<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] +pub struct PackageScopePackage<'a> { + pub nodes: (PackageIdentifier<'a>, Symbol<'a>), +} + +#[derive(Debug, Node)] +pub struct Unit<'a> { + pub nodes: (Symbol<'a>, Symbol<'a>), +} + +#[derive(Debug, Node)] pub struct ParameterIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct PortIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ProductionIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct ProgramIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct PropertyIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct PsClassIdentifier<'a> { pub nodes: (Option>, ClassIdentifier<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct PsCovergroupIdentifier<'a> { pub nodes: (Option>, CovergroupIdentifier<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct PsCheckerIdentifier<'a> { pub nodes: (Option>, CheckerIdentifier<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct PsIdentifier<'a> { pub nodes: (Option>, Identifier<'a>), } @@ -338,10 +350,10 @@ pub struct PsOrHierarchicalArrayIdentifier<'a> { #[derive(Debug)] pub enum PsOrHierarchicalNetIdentifier<'a> { PackageScope(PsOrHierarchicalNetIdentifierPackageScope<'a>), - Hierarchical(PsOrHierarchicalNetIdentifierHierarchical<'a>), + HierarchicalNetIdentifier(HierarchicalNetIdentifier<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct PsOrHierarchicalNetIdentifierPackageScope<'a> { pub nodes: (Option>, NetIdentifier<'a>), } @@ -354,7 +366,7 @@ pub struct PsOrHierarchicalNetIdentifierHierarchical<'a> { #[derive(Debug)] pub enum PsOrHierarchicalPropertyIdentifier<'a> { PackageScope(PsOrHierarchicalPropertyIdentifierPackageScope<'a>), - Hierarchical(PsOrHierarchicalPropertyIdentifierHierarchical<'a>), + HierarchicalPropertyIdentifier(HierarchicalPropertyIdentifier<'a>), } #[derive(Debug)] @@ -370,7 +382,7 @@ pub struct PsOrHierarchicalPropertyIdentifierHierarchical<'a> { #[derive(Debug)] pub enum PsOrHierarchicalSequenceIdentifier<'a> { PackageScope(PsOrHierarchicalSequenceIdentifierPackageScope<'a>), - Hierarchical(PsOrHierarchicalSequenceIdentifierHierarchical<'a>), + HierarchicalSequenceIdentifier(HierarchicalSequenceIdentifier<'a>), } #[derive(Debug)] @@ -386,7 +398,7 @@ pub struct PsOrHierarchicalSequenceIdentifierHierarchical<'a> { #[derive(Debug)] pub enum PsOrHierarchicalTfIdentifier<'a> { PackageScope(PsOrHierarchicalTfIdentifierPackageScope<'a>), - Hierarchical(PsOrHierarchicalTfIdentifierHierarchical<'a>), + HierarchicalTfIdentifier(HierarchicalTfIdentifier<'a>), } #[derive(Debug)] @@ -416,7 +428,11 @@ pub struct PsParameterIdentifierScope<'a> { #[derive(Debug)] pub struct PsParameterIdentifierGenerate<'a> { pub nodes: ( - Vec<(GenerateBlockIdentifier<'a>, Option>)>, + Vec<( + GenerateBlockIdentifier<'a>, + Option>>, + Symbol<'a>, + )>, ParameterIdentifier<'a>, ), } @@ -431,67 +447,72 @@ pub struct PsTypeIdentifier<'a> { #[derive(Debug)] pub enum LocalOrPackageScopeOrClassScope<'a> { - Local, + Local(Local<'a>), PackageScope(PackageScope<'a>), ClassScope(ClassScope<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] +pub struct Local<'a> { + pub nodes: (Symbol<'a>, Symbol<'a>), +} + +#[derive(Debug, Node)] pub struct SequenceIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct SignalIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct SimpleIdentifier<'a> { pub nodes: (Span<'a>, Vec>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct SpecparamIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct SystemTfIdentifier<'a> { pub nodes: (Span<'a>, Vec>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct TaskIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct TfIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct TerminalIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct TopmoduleIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct TypeIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct UdpIdentifier<'a> { pub nodes: (Identifier<'a>,), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct VariableIdentifier<'a> { pub nodes: (Identifier<'a>,), } @@ -677,7 +698,16 @@ pub fn hierarchical_event_identifier(s: Span) -> IResult IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + let (s, a) = opt(root)(s)?; + let (s, b) = many0(triple(identifier, constant_bit_select, symbol(".")))(s)?; + let (s, c) = identifier(s)?; + Ok((s, HierarchicalIdentifier { nodes: (a, b, c) })) +} + +pub fn root(s: Span) -> IResult { + let (s, a) = symbol("$root")(s)?; + let (s, b) = symbol(".")(s)?; + Ok((s, Root { nodes: (a, b) })) } pub fn hierarchical_net_identifier(s: Span) -> IResult { @@ -800,7 +830,22 @@ pub fn package_identifier(s: Span) -> IResult { } pub fn package_scope(s: Span) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + alt((package_scope_package, map(unit, |x| PackageScope::Unit(x))))(s) +} + +pub fn package_scope_package(s: Span) -> IResult { + let (s, a) = package_identifier(s)?; + let (s, b) = symbol("::")(s)?; + Ok(( + s, + PackageScope::Package(PackageScopePackage { nodes: (a, b) }), + )) +} + +pub fn unit(s: Span) -> IResult { + let (s, a) = symbol("$unit")(s)?; + let (s, b) = symbol("::")(s)?; + Ok((s, Unit { nodes: (a, b) })) } pub fn parameter_identifier(s: Span) -> IResult { @@ -829,53 +874,162 @@ pub fn property_identifier(s: Span) -> IResult { } pub fn ps_class_identifier(s: Span) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + let (s, a) = opt(package_scope)(s)?; + let (s, b) = class_identifier(s)?; + Ok((s, PsClassIdentifier { nodes: (a, b) })) } pub fn ps_covergroup_identifier(s: Span) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + let (s, a) = opt(package_scope)(s)?; + let (s, b) = covergroup_identifier(s)?; + Ok((s, PsCovergroupIdentifier { nodes: (a, b) })) } pub fn ps_checker_identifier(s: Span) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + let (s, a) = opt(package_scope)(s)?; + let (s, b) = checker_identifier(s)?; + Ok((s, PsCheckerIdentifier { nodes: (a, b) })) } pub fn ps_identifier(s: Span) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + let (s, a) = opt(package_scope)(s)?; + let (s, b) = identifier(s)?; + Ok((s, PsIdentifier { nodes: (a, b) })) } pub fn ps_or_hierarchical_array_identifier( s: Span, ) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + let (s, a) = opt(implicit_class_handle_or_class_scope_or_package_scope)(s)?; + let (s, b) = hierarchical_array_identifier(s)?; + Ok((s, PsOrHierarchicalArrayIdentifier { nodes: (a, b) })) } pub fn ps_or_hierarchical_net_identifier(s: Span) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + alt(( + ps_or_hierarchical_net_identifier_package_scope, + map(hierarchical_net_identifier, |x| { + PsOrHierarchicalNetIdentifier::HierarchicalNetIdentifier(x) + }), + ))(s) +} + +pub fn ps_or_hierarchical_net_identifier_package_scope( + s: Span, +) -> IResult { + let (s, a) = opt(package_scope)(s)?; + let (s, b) = net_identifier(s)?; + Ok(( + s, + PsOrHierarchicalNetIdentifier::PackageScope(PsOrHierarchicalNetIdentifierPackageScope { + nodes: (a, b), + }), + )) } pub fn ps_or_hierarchical_property_identifier( s: Span, ) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + alt(( + ps_or_hierarchical_property_identifier_package_scope, + map(hierarchical_property_identifier, |x| { + PsOrHierarchicalPropertyIdentifier::HierarchicalPropertyIdentifier(x) + }), + ))(s) +} + +pub fn ps_or_hierarchical_property_identifier_package_scope( + s: Span, +) -> IResult { + let (s, a) = opt(package_scope)(s)?; + let (s, b) = property_identifier(s)?; + Ok(( + s, + PsOrHierarchicalPropertyIdentifier::PackageScope( + PsOrHierarchicalPropertyIdentifierPackageScope { nodes: (a, b) }, + ), + )) } pub fn ps_or_hierarchical_sequence_identifier( s: Span, ) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + alt(( + ps_or_hierarchical_sequence_identifier_package_scope, + map(hierarchical_sequence_identifier, |x| { + PsOrHierarchicalSequenceIdentifier::HierarchicalSequenceIdentifier(x) + }), + ))(s) +} + +pub fn ps_or_hierarchical_sequence_identifier_package_scope( + s: Span, +) -> IResult { + let (s, a) = opt(package_scope)(s)?; + let (s, b) = sequence_identifier(s)?; + Ok(( + s, + PsOrHierarchicalSequenceIdentifier::PackageScope( + PsOrHierarchicalSequenceIdentifierPackageScope { nodes: (a, b) }, + ), + )) } pub fn ps_or_hierarchical_tf_identifier(s: Span) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + alt(( + ps_or_hierarchical_tf_identifier_package_scope, + map(hierarchical_tf_identifier, |x| { + PsOrHierarchicalTfIdentifier::HierarchicalTfIdentifier(x) + }), + ))(s) +} + +pub fn ps_or_hierarchical_tf_identifier_package_scope( + s: Span, +) -> IResult { + let (s, a) = opt(package_scope)(s)?; + let (s, b) = tf_identifier(s)?; + Ok(( + s, + PsOrHierarchicalTfIdentifier::PackageScope(PsOrHierarchicalTfIdentifierPackageScope { + nodes: (a, b), + }), + )) } pub fn ps_parameter_identifier(s: Span) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + alt(( + ps_parameter_identifier_scope, + ps_parameter_identifier_generate, + ))(s) +} + +pub fn ps_parameter_identifier_scope(s: Span) -> IResult { + let (s, a) = opt(package_scope_or_class_scope)(s)?; + let (s, b) = parameter_identifier(s)?; + Ok(( + s, + PsParameterIdentifier::Scope(PsParameterIdentifierScope { nodes: (a, b) }), + )) +} + +pub fn ps_parameter_identifier_generate(s: Span) -> IResult { + let (s, a) = many0(triple( + generate_block_identifier, + opt(bracket2(constant_expression)), + symbol("."), + ))(s)?; + let (s, b) = parameter_identifier(s)?; + Ok(( + s, + PsParameterIdentifier::Generate(PsParameterIdentifierGenerate { nodes: (a, b) }), + )) } pub fn ps_type_identifier(s: Span) -> IResult { - Err(Err::Error(make_error(s, ErrorKind::Fix))) + let (s, a) = opt(local_or_package_scope_or_class_scope)(s)?; + let (s, b) = type_identifier(s)?; + Ok((s, PsTypeIdentifier { nodes: (a, b) })) } pub fn sequence_identifier(s: Span) -> IResult { @@ -1005,6 +1159,26 @@ pub fn package_scope_or_class_scope(s: Span) -> IResult IResult { + alt(( + map(local, |x| LocalOrPackageScopeOrClassScope::Local(x)), + map(package_scope, |x| { + LocalOrPackageScopeOrClassScope::PackageScope(x) + }), + map(class_scope, |x| { + LocalOrPackageScopeOrClassScope::ClassScope(x) + }), + ))(s) +} + +pub fn local(s: Span) -> IResult { + let (s, a) = symbol("local")(s)?; + let (s, b) = symbol("::")(s)?; + Ok((s, Local { nodes: (a, b) })) +} + // ----------------------------------------------------------------------------- #[cfg(test)] diff --git a/src/parser/primitive_instances/primitive_instantiation_and_instances.rs b/src/parser/primitive_instances/primitive_instantiation_and_instances.rs index 68ea947..ec22f45 100644 --- a/src/parser/primitive_instances/primitive_instantiation_and_instances.rs +++ b/src/parser/primitive_instances/primitive_instantiation_and_instances.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; //use nom::branch::*; //use nom::combinator::*; @@ -6,7 +7,7 @@ use nom::{Err, IResult}; // ----------------------------------------------------------------------------- -#[derive(Debug)] +#[derive(Debug, Node)] pub struct GateInstantiation<'a> { pub nodes: (Identifier<'a>,), } diff --git a/src/parser/specify_section/specify_block_declaration.rs b/src/parser/specify_section/specify_block_declaration.rs index 6fda319..e860c8a 100644 --- a/src/parser/specify_section/specify_block_declaration.rs +++ b/src/parser/specify_section/specify_block_declaration.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; //use nom::branch::*; //use nom::combinator::*; @@ -6,7 +7,7 @@ use nom::{Err, IResult}; // ----------------------------------------------------------------------------- -#[derive(Debug)] +#[derive(Debug, Node)] pub struct SpecifyBlock<'a> { pub nodes: (Identifier<'a>,), } diff --git a/src/parser/specify_section/specify_block_terminals.rs b/src/parser/specify_section/specify_block_terminals.rs index 58f7267..4ba8149 100644 --- a/src/parser/specify_section/specify_block_terminals.rs +++ b/src/parser/specify_section/specify_block_terminals.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; //use nom::branch::*; //use nom::combinator::*; @@ -16,26 +17,26 @@ pub struct SpecifyOutputTerminalDescriptor<'a> { pub nodes: (OutputIdentifier<'a>, Option>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub enum InputIdentifier<'a> { InputPortIdentifier(InputPortIdentifier<'a>), InoutPortIdentifier(InoutPortIdentifier<'a>), Interface(InputIdentifierInterface<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct InputIdentifierInterface<'a> { pub nodes: (InterfaceIdentifier<'a>, PortIdentifier<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub enum OutputIdentifier<'a> { OutputPortIdentifier(OutputPortIdentifier<'a>), InoutPortIdentifier(InoutPortIdentifier<'a>), Interface(OutputIdentifierInterface<'a>), } -#[derive(Debug)] +#[derive(Debug, Node)] pub struct OutputIdentifierInterface<'a> { pub nodes: (InterfaceIdentifier<'a>, PortIdentifier<'a>), } diff --git a/src/parser/specify_section/specify_path_delays.rs b/src/parser/specify_section/specify_path_delays.rs index 322c70a..b3aff1d 100644 --- a/src/parser/specify_section/specify_path_delays.rs +++ b/src/parser/specify_section/specify_path_delays.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; //use nom::branch::*; //use nom::combinator::*; @@ -6,7 +7,7 @@ use nom::{Err, IResult}; // ----------------------------------------------------------------------------- -#[derive(Debug)] +#[derive(Debug, Node)] pub struct EdgeIdentifier<'a> { pub nodes: (Identifier<'a>,), } diff --git a/src/parser/udp_declaration_and_instantiation/udp_declaration.rs b/src/parser/udp_declaration_and_instantiation/udp_declaration.rs index 32f3c8a..a7175a4 100644 --- a/src/parser/udp_declaration_and_instantiation/udp_declaration.rs +++ b/src/parser/udp_declaration_and_instantiation/udp_declaration.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; //use nom::branch::*; //use nom::combinator::*; @@ -6,7 +7,7 @@ use nom::{Err, IResult}; // ----------------------------------------------------------------------------- -#[derive(Debug)] +#[derive(Debug, Node)] pub struct UdpDeclaration<'a> { pub nodes: (Identifier<'a>,), } diff --git a/src/parser/udp_declaration_and_instantiation/udp_instantiation.rs b/src/parser/udp_declaration_and_instantiation/udp_instantiation.rs index b9c272a..dfaab3b 100644 --- a/src/parser/udp_declaration_and_instantiation/udp_instantiation.rs +++ b/src/parser/udp_declaration_and_instantiation/udp_instantiation.rs @@ -1,3 +1,4 @@ +use crate::ast::*; use crate::parser::*; //use nom::branch::*; //use nom::combinator::*; @@ -6,7 +7,7 @@ use nom::{Err, IResult}; // ----------------------------------------------------------------------------- -#[derive(Debug)] +#[derive(Debug, Node)] pub struct UdpInstantiation<'a> { pub nodes: (Identifier<'a>,), }