From 6d2f7e729a11abdf4e16d1be1166e90898c99012 Mon Sep 17 00:00:00 2001 From: dalance Date: Wed, 17 Jul 2019 10:48:15 +0900 Subject: [PATCH] Refine loop detection --- Cargo.toml | 4 + node_derive/src/lib.rs | 96 +++++++++++++++++- src/parser.rs | 65 +++++++++++- .../assertion_statements.rs | 13 +++ .../behavioral_statements/case_statements.rs | 18 ++++ .../behavioral_statements/clocking_block.rs | 31 ++++++ .../conditional_statements.rs | 5 + ...ous_assignment_and_net_alias_statements.rs | 7 ++ .../looping_statements.rs | 14 +++ .../parallel_and_sequential_blocks.rs | 5 + src/parser/behavioral_statements/patterns.rs | 18 ++++ .../procedural_blocks_and_assignments.rs | 19 ++++ .../behavioral_statements/randsequence.rs | 17 ++++ .../behavioral_statements/statements.rs | 8 ++ .../subroutine_call_statements.rs | 2 + .../timing_control_statements.rs | 34 +++++++ .../declarations/assertion_declarations.rs | 98 ++++++++++++++++++ .../declarations/block_item_declarations.rs | 5 + .../declarations/covergroup_declarations.rs | 67 +++++++++++++ .../declarations/declaration_assignments.rs | 20 ++++ src/parser/declarations/declaration_lists.rs | 13 +++ src/parser/declarations/declaration_ranges.rs | 11 +++ src/parser/declarations/delays.rs | 7 ++ .../declarations/function_declarations.rs | 17 ++++ .../declarations/interface_declarations.rs | 14 +++ src/parser/declarations/let_declarations.rs | 10 ++ .../module_parameter_declarations.rs | 7 ++ .../declarations/net_and_variable_types.rs | 38 +++++++ src/parser/declarations/port_declarations.rs | 9 ++ src/parser/declarations/strengths.rs | 13 +++ src/parser/declarations/task_declarations.rs | 10 ++ src/parser/declarations/type_declarations.rs | 26 +++++ src/parser/expressions/concatenations.rs | 16 +++ .../expressions/expression_leftside_values.rs | 9 ++ src/parser/expressions/expressions.rs | 35 +++++++ src/parser/expressions/numbers.rs | 38 +++++++ src/parser/expressions/operators.rs | 5 + src/parser/expressions/primaries.rs | 34 ++++++- src/parser/expressions/strings.rs | 2 + src/parser/expressions/subroutine_calls.rs | 21 ++++ src/parser/general/attributes.rs | 2 + src/parser/general/comments.rs | 3 + src/parser/general/identifiers.rs | 99 +++++++++++++++++++ .../instantiations/checker_instantiation.rs | 8 ++ .../instantiations/generated_instantiation.rs | 16 +++ .../instantiations/interface_instantiation.rs | 1 + .../instantiations/module_instantiation.rs | 16 +++ .../instantiations/program_instantiation.rs | 1 + .../primitive_gate_and_switch_types.rs | 7 ++ .../primitive_instantiation_and_instances.rs | 18 ++++ .../primitive_strengths.rs | 8 ++ .../primitive_terminals.rs | 6 ++ src/parser/source_text/checker_items.rs | 10 ++ src/parser/source_text/class_items.rs | 25 +++++ .../source_text/configuration_source_text.rs | 18 ++++ src/parser/source_text/constraints.rs | 26 +++++ src/parser/source_text/interface_items.rs | 8 ++ src/parser/source_text/library_source_text.rs | 5 + src/parser/source_text/module_items.rs | 27 +++++ .../module_parameters_and_ports.rs | 32 ++++++ src/parser/source_text/package_items.rs | 4 + src/parser/source_text/program_items.rs | 8 ++ .../source_text/system_verilog_source_text.rs | 42 ++++++++ .../specify_block_declaration.rs | 1 + .../specify_block_terminals.rs | 4 + .../specify_section/specify_path_delays.rs | 1 + .../udp_declaration.rs | 1 + .../udp_instantiation.rs | 2 + src/parser/utils.rs | 91 +++++++++++++---- 69 files changed, 1350 insertions(+), 21 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 511e1c2..18ad359 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,6 +11,10 @@ description = "" edition = "2018" build = "build.rs" +[features] +default = [] +trace = [] + [dependencies] nom = "5.0.0" nom_locate = { git = "https://github.com/fflorent/nom_locate" } diff --git a/node_derive/src/lib.rs b/node_derive/src/lib.rs index 99967b7..34ce38b 100644 --- a/node_derive/src/lib.rs +++ b/node_derive/src/lib.rs @@ -123,8 +123,102 @@ pub fn trace(_attr: TokenStream, item: TokenStream) -> TokenStream { fn impl_trace(item: &syn::ItemFn) -> TokenStream { let ident = &item.ident; let mut item = item.clone(); + let tracer = quote! { - println!("{}: {:?}", stringify!(#ident), s); + if cfg!(feature = "trace") { + println!("{:<48} : {:<4},{:>032x} : {}", stringify!(#ident), s.offset, s.extra, s.fragment); + } + }; + let tracer: TokenStream = tracer.into(); + let tracer = parse_macro_input!(tracer as syn::Stmt); + + let checker = quote! { + if thread_context::TABLE.with(|t| { + if let Some(i) = t.borrow_mut().get_or_allocate(stringify!(#ident)) { + return check_bit(s, i); + } else { + return false + } + }) { + if cfg!(feature = "trace") { + println!("{:<48} : loop detect", stringify!(#ident)); + } + return Err(nom::Err::Error(nom::error::make_error(s, nom::error::ErrorKind::Fix))); + } + }; + let checker: TokenStream = checker.into(); + let checker = parse_macro_input!(checker as syn::Stmt); + + let before = quote! { + let s = thread_context::TABLE.with(|t| { + if let Some(i) = t.borrow_mut().get_or_allocate(stringify!(#ident)) { + //println!("{}:{} set", stringify!(#ident), i); + set_bit(s, i, true) + } else { + if cfg!(feature = "trace") { + println!("{:<48} : allocate failed", stringify!(#ident)); + } + s + } + }); + }; + let before: TokenStream = before.into(); + let before = parse_macro_input!(before as syn::Stmt); + + let mut body = quote! {}; + for s in &item.block.stmts { + body = quote! { + #body + #s + }; + } + let body = quote! { + let (s, ret) = { #body }?; + }; + let body: TokenStream = body.into(); + let body = parse_macro_input!(body as syn::Stmt); + + let after = quote! { + Ok((clear_bit(s), ret)) + }; + let after: TokenStream = after.into(); + let after = parse_macro_input!(after as syn::Expr); + let after = syn::Stmt::Expr(after); + + item.block.stmts.clear(); + item.block.stmts.push(tracer); + item.block.stmts.push(checker); + item.block.stmts.push(before); + item.block.stmts.push(body); + item.block.stmts.push(after); + + let gen = quote! { + #item + }; + gen.into() +} + +#[proc_macro_attribute] +pub fn rec(_attr: TokenStream, item: TokenStream) -> TokenStream { + let item = parse_macro_input!(item as ItemFn); + impl_rec(&item) +} + +fn impl_rec(item: &syn::ItemFn) -> TokenStream { + let ident = &item.ident; + let mut item = item.clone(); + let tracer = quote! { + if thread_context::MAP_MUT.with(|m| { + if let Some(x) = m.borrow().get(stringify!(#ident)) { + if *x == s.offset { + return true; + } + } + m.borrow_mut().insert(stringify!(#ident), s.offset); + false + }) { + return Err(nom::Err::Error(nom::error::make_error(s, nom::error::ErrorKind::Fix))); + } }; let tracer: TokenStream = tracer.into(); let tracer = parse_macro_input!(tracer as syn::Stmt); diff --git a/src/parser.rs b/src/parser.rs index 1159379..51ef869 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -21,7 +21,68 @@ pub use source_text::*; pub use specify_section::*; pub use udp_declaration_and_instantiation::*; -pub type Span<'a> = nom_locate::LocatedSpanEx<&'a str, u64>; +pub type Span<'a> = nom_locate::LocatedSpanEx<&'a str, u128>; // IDs for left recursion detection -static REC_PRIMARY: u32 = 0; +//static REC_PRIMARY: u32 = 0; + +mod thread_context { + + use std::cell::RefCell; + use std::collections::HashMap; + + thread_local!( + pub static MAP_MUT: RefCell> = { + RefCell::new(HashMap::new()) + } + ); + + #[derive(Debug)] + pub struct Table { + index: HashMap<&'static str, u32>, + offset: HashMap<&'static str, usize>, + allocated: u128, + } + + impl Table { + pub fn get(&self, key: &'static str) -> Option { + if let Some(x) = self.index.get(key) { + Some(*x) + } else { + None + } + } + + pub fn get_or_allocate(&mut self, key: &'static str) -> Option { + if let Some(x) = self.index.get(key) { + Some(*x) + } else { + let allocated = self.allocated; + for i in 0..128 { + if ((allocated >> i) & 1) == 0 { + let val = 1u128 << i; + let mask = !(1u128 << i); + self.allocated = (allocated & mask) | val; + self.index.insert(key, i); + return Some(i); + } + } + None + } + } + + pub fn release(&mut self, key: &'static str) { + if let Some(x) = self.index.get(key) { + let mask = !(1u128 << *x); + self.allocated = self.allocated & mask; + self.index.remove(key); + } + } + } + + thread_local!( + pub static TABLE: RefCell = { + RefCell::new(Table{index: HashMap::new(), offset: HashMap::new(), allocated: 0}) + } + ); +} diff --git a/src/parser/behavioral_statements/assertion_statements.rs b/src/parser/behavioral_statements/assertion_statements.rs index 4df1b2d..640b916 100644 --- a/src/parser/behavioral_statements/assertion_statements.rs +++ b/src/parser/behavioral_statements/assertion_statements.rs @@ -101,6 +101,7 @@ pub enum AssertTiming<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn assertion_item(s: Span) -> IResult { alt(( map(concurrent_assertion_item, |x| AssertionItem::Concurrent(x)), @@ -110,12 +111,14 @@ pub fn assertion_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn deferred_immediate_assertion_item(s: Span) -> IResult { let (s, a) = opt(pair(block_identifier, symbol(":")))(s)?; let (s, b) = deferred_immediate_assertion_statement(s)?; Ok((s, DeferredImmediateAssetionItem { nodes: (a, b) })) } +#[trace] pub fn procedural_assertion_statement(s: Span) -> IResult { alt(( map(concurrent_assertion_statement, |x| { @@ -130,6 +133,7 @@ pub fn procedural_assertion_statement(s: Span) -> IResult IResult { alt(( map(simple_immediate_assertion_statement, |x| { @@ -141,6 +145,7 @@ pub fn immediate_assertion_statement(s: Span) -> IResult IResult { @@ -157,6 +162,7 @@ pub fn simple_immediate_assertion_statement( ))(s) } +#[trace] pub fn simple_immediate_assert_statement(s: Span) -> IResult { let (s, a) = symbol("assert")(s)?; let (s, b) = paren(expression)(s)?; @@ -164,6 +170,7 @@ pub fn simple_immediate_assert_statement(s: Span) -> IResult IResult { let (s, a) = symbol("assume")(s)?; let (s, b) = paren(expression)(s)?; @@ -171,6 +178,7 @@ pub fn simple_immediate_assume_statement(s: Span) -> IResult IResult { let (s, a) = symbol("cover")(s)?; let (s, b) = paren(expression)(s)?; @@ -178,6 +186,7 @@ pub fn simple_immediate_cover_statement(s: Span) -> IResult IResult { @@ -194,6 +203,7 @@ pub fn deferred_immediate_assertion_statement( ))(s) } +#[trace] pub fn deferred_immediate_assert_statement( s: Span, ) -> IResult { @@ -209,6 +219,7 @@ pub fn deferred_immediate_assert_statement( )) } +#[trace] pub fn deferred_immediate_assume_statement( s: Span, ) -> IResult { @@ -224,6 +235,7 @@ pub fn deferred_immediate_assume_statement( )) } +#[trace] pub fn deferred_immediate_cover_statement( s: Span, ) -> IResult { @@ -239,6 +251,7 @@ pub fn deferred_immediate_cover_statement( )) } +#[trace] pub fn assert_timing(s: Span) -> IResult { alt(( map(symbol("#0"), |x| AssertTiming::Zero(x)), diff --git a/src/parser/behavioral_statements/case_statements.rs b/src/parser/behavioral_statements/case_statements.rs index 161591a..5748354 100644 --- a/src/parser/behavioral_statements/case_statements.rs +++ b/src/parser/behavioral_statements/case_statements.rs @@ -144,6 +144,7 @@ pub struct OpenValueRange<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn case_statement(s: Span) -> IResult { alt(( case_statement_normal, @@ -152,6 +153,7 @@ pub fn case_statement(s: Span) -> IResult { ))(s) } +#[trace] pub fn case_statement_normal(s: Span) -> IResult { let (s, a) = opt(unique_priority)(s)?; let (s, b) = case_keyword(s)?; @@ -167,6 +169,7 @@ pub fn case_statement_normal(s: Span) -> IResult { )) } +#[trace] pub fn case_statement_matches(s: Span) -> IResult { let (s, a) = opt(unique_priority)(s)?; let (s, b) = case_keyword(s)?; @@ -183,6 +186,7 @@ pub fn case_statement_matches(s: Span) -> IResult { )) } +#[trace] pub fn case_statement_inside(s: Span) -> IResult { let (s, a) = opt(unique_priority)(s)?; let (s, b) = symbol("case")(s)?; @@ -199,6 +203,7 @@ pub fn case_statement_inside(s: Span) -> IResult { )) } +#[trace] pub fn case_keyword(s: Span) -> IResult { alt(( map(symbol("casez"), |x| CaseKeyword::Casez(x)), @@ -207,11 +212,13 @@ pub fn case_keyword(s: Span) -> IResult { ))(s) } +#[trace] pub fn case_expression(s: Span) -> IResult { let (s, a) = expression(s)?; Ok((s, CaseExpression { nodes: (a,) })) } +#[trace] pub fn case_item(s: Span) -> IResult { alt(( case_item_nondefault, @@ -219,6 +226,7 @@ pub fn case_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn case_item_nondefault(s: Span) -> IResult { let (s, a) = list(symbol(","), case_item_expression)(s)?; let (s, b) = symbol(":")(s)?; @@ -229,6 +237,7 @@ pub fn case_item_nondefault(s: Span) -> IResult { )) } +#[trace] pub fn case_item_default(s: Span) -> IResult { let (s, a) = symbol("default")(s)?; let (s, b) = opt(symbol(":"))(s)?; @@ -236,6 +245,7 @@ pub fn case_item_default(s: Span) -> IResult { Ok((s, CaseItemDefault { nodes: (a, b, c) })) } +#[trace] pub fn case_pattern_item(s: Span) -> IResult { alt(( case_pattern_item_nondefault, @@ -243,6 +253,7 @@ pub fn case_pattern_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn case_pattern_item_nondefault(s: Span) -> IResult { let (s, a) = pattern(s)?; let (s, b) = opt(pair(symbol("&&&"), expression))(s)?; @@ -256,6 +267,7 @@ pub fn case_pattern_item_nondefault(s: Span) -> IResult { )) } +#[trace] pub fn case_inside_item(s: Span) -> IResult { alt(( case_inside_item_nondefault, @@ -263,6 +275,7 @@ pub fn case_inside_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn case_inside_item_nondefault(s: Span) -> IResult { let (s, a) = open_range_list(s)?; let (s, b) = symbol(":")(s)?; @@ -273,11 +286,13 @@ pub fn case_inside_item_nondefault(s: Span) -> IResult { )) } +#[trace] pub fn case_item_expression(s: Span) -> IResult { let (s, a) = expression(s)?; Ok((s, CaseItemExpression { nodes: (a,) })) } +#[trace] pub fn randcase_statement(s: Span) -> IResult { let (s, a) = symbol("randcase")(s)?; let (s, b) = randcase_item(s)?; @@ -291,6 +306,7 @@ pub fn randcase_statement(s: Span) -> IResult { )) } +#[trace] pub fn randcase_item(s: Span) -> IResult { let (s, a) = expression(s)?; let (s, b) = symbol(":")(s)?; @@ -298,11 +314,13 @@ pub fn randcase_item(s: Span) -> IResult { Ok((s, RandcaseItem { nodes: (a, b, c) })) } +#[trace] pub fn open_range_list(s: Span) -> IResult { let (s, a) = list(symbol(","), open_value_range)(s)?; Ok((s, OpenRangeList { nodes: (a,) })) } +#[trace] 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/clocking_block.rs b/src/parser/behavioral_statements/clocking_block.rs index 5a9162c..d3132ea 100644 --- a/src/parser/behavioral_statements/clocking_block.rs +++ b/src/parser/behavioral_statements/clocking_block.rs @@ -202,10 +202,12 @@ pub struct ClockvarExpression<'a> { } // ----------------------------------------------------------------------------- +#[trace] pub fn clocking_declaration(s: Span) -> IResult { alt((clocking_declaration_local, clocking_declaration_global))(s) } +#[trace] pub fn clocking_declaration_local(s: Span) -> IResult { let (s, a) = opt(default)(s)?; let (s, b) = symbol("clocking")(s)?; @@ -223,11 +225,13 @@ pub fn clocking_declaration_local(s: Span) -> IResult )) } +#[trace] pub fn default(s: Span) -> IResult { let (s, a) = symbol("default")(s)?; Ok((s, Default { nodes: (a,) })) } +#[trace] pub fn clocking_declaration_global(s: Span) -> IResult { let (s, a) = symbol("global")(s)?; let (s, b) = symbol("clocking")(s)?; @@ -244,10 +248,12 @@ pub fn clocking_declaration_global(s: Span) -> IResult IResult { alt((clocking_event_identifier, clocking_event_expression))(s) } +#[trace] pub fn clocking_event_identifier(s: Span) -> IResult { let (s, a) = symbol("@")(s)?; let (s, b) = identifier(s)?; @@ -257,6 +263,7 @@ pub fn clocking_event_identifier(s: Span) -> IResult { )) } +#[trace] pub fn clocking_event_expression(s: Span) -> IResult { let (s, a) = symbol("@")(s)?; let (s, b) = paren(event_expression)(s)?; @@ -266,6 +273,7 @@ pub fn clocking_event_expression(s: Span) -> IResult { )) } +#[trace] pub fn clocking_item(s: Span) -> IResult { alt(( clocking_item_default, @@ -274,6 +282,7 @@ pub fn clocking_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn clocking_item_default(s: Span) -> IResult { let (s, a) = symbol("default")(s)?; let (s, b) = default_skew(s)?; @@ -284,6 +293,7 @@ pub fn clocking_item_default(s: Span) -> IResult { )) } +#[trace] pub fn clocking_item_direction(s: Span) -> IResult { let (s, a) = clocking_direction(s)?; let (s, b) = list_of_clocking_decl_assign(s)?; @@ -294,6 +304,7 @@ pub fn clocking_item_direction(s: Span) -> IResult { )) } +#[trace] pub fn clocking_item_assertion(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = assertion_item_declaration(s)?; @@ -303,6 +314,7 @@ pub fn clocking_item_assertion(s: Span) -> IResult { )) } +#[trace] pub fn default_skew(s: Span) -> IResult { alt(( default_skew_input, @@ -311,18 +323,21 @@ pub fn default_skew(s: Span) -> IResult { ))(s) } +#[trace] pub fn default_skew_input(s: Span) -> IResult { let (s, a) = symbol("input")(s)?; let (s, b) = clocking_skew(s)?; Ok((s, DefaultSkew::Input(DefaultSkewInput { nodes: (a, b) }))) } +#[trace] pub fn default_skew_output(s: Span) -> IResult { let (s, a) = symbol("output")(s)?; let (s, b) = clocking_skew(s)?; Ok((s, DefaultSkew::Output(DefaultSkewOutput { nodes: (a, b) }))) } +#[trace] pub fn default_skew_input_output(s: Span) -> IResult { let (s, a) = symbol("input")(s)?; let (s, b) = clocking_skew(s)?; @@ -336,6 +351,7 @@ pub fn default_skew_input_output(s: Span) -> IResult { )) } +#[trace] pub fn clocking_direction(s: Span) -> IResult { alt(( clocking_direction_input, @@ -345,6 +361,7 @@ pub fn clocking_direction(s: Span) -> IResult { ))(s) } +#[trace] pub fn clocking_direction_input(s: Span) -> IResult { let (s, a) = symbol("input")(s)?; let (s, b) = opt(clocking_skew)(s)?; @@ -354,6 +371,7 @@ pub fn clocking_direction_input(s: Span) -> IResult { )) } +#[trace] pub fn clocking_direction_output(s: Span) -> IResult { let (s, a) = symbol("output")(s)?; let (s, b) = opt(clocking_skew)(s)?; @@ -363,6 +381,7 @@ pub fn clocking_direction_output(s: Span) -> IResult { )) } +#[trace] pub fn clocking_direction_input_output(s: Span) -> IResult { let (s, a) = symbol("input")(s)?; let (s, b) = opt(clocking_skew)(s)?; @@ -376,22 +395,26 @@ pub fn clocking_direction_input_output(s: Span) -> IResult IResult { let (s, a) = symbol("inout")(s)?; Ok((s, ClockingDirection::Inout(a))) } +#[trace] pub fn list_of_clocking_decl_assign(s: Span) -> IResult { let (s, a) = list(symbol(","), clocking_decl_assign)(s)?; Ok((s, ListOfClockingDeclAssign { nodes: (a,) })) } +#[trace] pub fn clocking_decl_assign(s: Span) -> IResult { let (s, a) = signal_identifier(s)?; let (s, b) = opt(pair(symbol("="), expression))(s)?; Ok((s, ClockingDeclAssign { nodes: (a, b) })) } +#[trace] pub fn clocking_skew(s: Span) -> IResult { alt(( clocking_skew_edge, @@ -399,12 +422,14 @@ pub fn clocking_skew(s: Span) -> IResult { ))(s) } +#[trace] pub fn clocking_skew_edge(s: Span) -> IResult { let (s, a) = edge_identifier(s)?; let (s, b) = opt(delay_control)(s)?; Ok((s, ClockingSkew::Edge(ClockingSkewEdge { nodes: (a, b) }))) } +#[trace] pub fn clocking_drive(s: Span) -> IResult { let (s, a) = clockvar_expression(s)?; let (s, b) = symbol("<=")(s)?; @@ -418,6 +443,7 @@ pub fn clocking_drive(s: Span) -> IResult { )) } +#[trace] pub fn cycle_delay(s: Span) -> IResult { alt(( cycle_delay_integral, @@ -426,6 +452,7 @@ pub fn cycle_delay(s: Span) -> IResult { ))(s) } +#[trace] pub fn cycle_delay_integral(s: Span) -> IResult { let (s, a) = symbol("##")(s)?; let (s, b) = integral_number(s)?; @@ -435,6 +462,7 @@ pub fn cycle_delay_integral(s: Span) -> IResult { )) } +#[trace] pub fn cycle_delay_identifier(s: Span) -> IResult { let (s, a) = symbol("##")(s)?; let (s, b) = identifier(s)?; @@ -444,6 +472,7 @@ pub fn cycle_delay_identifier(s: Span) -> IResult { )) } +#[trace] pub fn cycle_delay_expression(s: Span) -> IResult { let (s, a) = symbol("##")(s)?; let (s, b) = paren(expression)(s)?; @@ -453,11 +482,13 @@ pub fn cycle_delay_expression(s: Span) -> IResult { )) } +#[trace] pub fn clockvar(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; Ok((s, Clockvar { nodes: (a,) })) } +#[trace] pub fn clockvar_expression(s: Span) -> IResult { let (s, a) = clockvar(s)?; let (s, b) = select(s)?; diff --git a/src/parser/behavioral_statements/conditional_statements.rs b/src/parser/behavioral_statements/conditional_statements.rs index 48edf8c..0434b7c 100644 --- a/src/parser/behavioral_statements/conditional_statements.rs +++ b/src/parser/behavioral_statements/conditional_statements.rs @@ -50,6 +50,7 @@ pub struct CondPattern<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn conditional_statement(s: Span) -> IResult { let (s, a) = opt(unique_priority)(s)?; let (s, b) = symbol("if")(s)?; @@ -71,6 +72,7 @@ pub fn conditional_statement(s: Span) -> IResult { )) } +#[trace] pub fn unique_priority(s: Span) -> IResult { alt(( map(symbol("unique0"), |x| UniquePriority::Unique0(x)), @@ -79,11 +81,13 @@ pub fn unique_priority(s: Span) -> IResult { ))(s) } +#[trace] pub fn cond_predicate(s: Span) -> IResult { let (s, a) = list(symbol("&&&"), expression_or_cond_pattern)(s)?; Ok((s, CondPredicate { nodes: (a,) })) } +#[trace] pub fn expression_or_cond_pattern(s: Span) -> IResult { alt(( map(expression, |x| ExpressionOrCondPattern::Expression(x)), @@ -91,6 +95,7 @@ pub fn expression_or_cond_pattern(s: Span) -> IResult IResult { let (s, a) = expression(s)?; let (s, b) = symbol("matches")(s)?; diff --git a/src/parser/behavioral_statements/continuous_assignment_and_net_alias_statements.rs b/src/parser/behavioral_statements/continuous_assignment_and_net_alias_statements.rs index 15d8c42..131027d 100644 --- a/src/parser/behavioral_statements/continuous_assignment_and_net_alias_statements.rs +++ b/src/parser/behavioral_statements/continuous_assignment_and_net_alias_statements.rs @@ -61,10 +61,12 @@ pub struct NetAssignment<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn continuous_assign(s: Span) -> IResult { alt((continuous_assign_net, continuous_assign_variable))(s) } +#[trace] pub fn continuous_assign_net(s: Span) -> IResult { let (s, a) = symbol("assign")(s)?; let (s, b) = opt(drive_strength)(s)?; @@ -80,6 +82,7 @@ pub fn continuous_assign_net(s: Span) -> IResult { )) } +#[trace] pub fn continuous_assign_variable(s: Span) -> IResult { let (s, a) = symbol("assign")(s)?; let (s, b) = opt(delay_control)(s)?; @@ -94,16 +97,19 @@ pub fn continuous_assign_variable(s: Span) -> IResult { )) } +#[trace] pub fn list_of_net_assignments(s: Span) -> IResult { let (s, a) = list(symbol(","), net_assignment)(s)?; Ok((s, ListOfNetAssignments { nodes: (a,) })) } +#[trace] pub fn list_of_variable_assignments(s: Span) -> IResult { let (s, a) = list(symbol(","), variable_assignment)(s)?; Ok((s, ListOfVariableAssignments { nodes: (a,) })) } +#[trace] pub fn net_alias(s: Span) -> IResult { let (s, a) = symbol("alias")(s)?; let (s, b) = net_lvalue(s)?; @@ -119,6 +125,7 @@ pub fn net_alias(s: Span) -> IResult { )) } +#[trace] pub fn net_assignment(s: Span) -> IResult { let (s, a) = net_lvalue(s)?; let (s, b) = symbol("=")(s)?; diff --git a/src/parser/behavioral_statements/looping_statements.rs b/src/parser/behavioral_statements/looping_statements.rs index 0ed7e8a..cadaa91 100644 --- a/src/parser/behavioral_statements/looping_statements.rs +++ b/src/parser/behavioral_statements/looping_statements.rs @@ -120,6 +120,7 @@ pub struct LoopVariables<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn loop_statement(s: Span) -> IResult { alt(( loop_statement_forever, @@ -131,6 +132,7 @@ pub fn loop_statement(s: Span) -> IResult { ))(s) } +#[trace] pub fn loop_statement_forever(s: Span) -> IResult { let (s, a) = symbol("forever")(s)?; let (s, b) = statement_or_null(s)?; @@ -140,6 +142,7 @@ pub fn loop_statement_forever(s: Span) -> IResult { )) } +#[trace] pub fn loop_statement_repeat(s: Span) -> IResult { let (s, a) = symbol("repeat")(s)?; let (s, b) = paren(expression)(s)?; @@ -150,6 +153,7 @@ pub fn loop_statement_repeat(s: Span) -> IResult { )) } +#[trace] pub fn loop_statement_while(s: Span) -> IResult { let (s, a) = symbol("while")(s)?; let (s, b) = paren(expression)(s)?; @@ -160,6 +164,7 @@ pub fn loop_statement_while(s: Span) -> IResult { )) } +#[trace] pub fn loop_statement_for(s: Span) -> IResult { let (s, a) = symbol("for")(s)?; let (s, b) = paren(tuple(( @@ -173,6 +178,7 @@ pub fn loop_statement_for(s: Span) -> IResult { Ok((s, LoopStatement::For(LoopStatementFor { nodes: (a, b, c) }))) } +#[trace] pub fn loop_statement_do_while(s: Span) -> IResult { let (s, a) = symbol("do")(s)?; let (s, b) = statement_or_null(s)?; @@ -187,6 +193,7 @@ pub fn loop_statement_do_while(s: Span) -> IResult { )) } +#[trace] pub fn loop_statement_foreach(s: Span) -> IResult { let (s, a) = symbol("foreach")(s)?; let (s, b) = paren(pair( @@ -200,6 +207,7 @@ pub fn loop_statement_foreach(s: Span) -> IResult { )) } +#[trace] pub fn for_initialization(s: Span) -> IResult { alt(( map(list_of_variable_assignments, |x| { @@ -209,6 +217,7 @@ pub fn for_initialization(s: Span) -> IResult { ))(s) } +#[trace] pub fn for_initialization_declaration(s: Span) -> IResult { let (s, a) = list(symbol(","), for_variable_declaration)(s)?; Ok(( @@ -217,6 +226,7 @@ pub fn for_initialization_declaration(s: Span) -> IResult IResult { let (s, a) = opt(var)(s)?; let (s, b) = data_type(s)?; @@ -227,16 +237,19 @@ pub fn for_variable_declaration(s: Span) -> IResult IResult { let (s, a) = symbol("var")(s)?; Ok((s, Var { nodes: (a,) })) } +#[trace] pub fn for_step(s: Span) -> IResult { let (s, a) = list(symbol(","), for_step_assignment)(s)?; Ok((s, ForStep { nodes: (a,) })) } +#[trace] pub fn for_step_assignment(s: Span) -> IResult { alt(( map(operator_assignment, |x| { @@ -251,6 +264,7 @@ pub fn for_step_assignment(s: Span) -> IResult { ))(s) } +#[trace] pub fn loop_variables(s: Span) -> IResult { let (s, a) = list(symbol(","), opt(index_variable_identifier))(s)?; Ok((s, LoopVariables { nodes: (a,) })) diff --git a/src/parser/behavioral_statements/parallel_and_sequential_blocks.rs b/src/parser/behavioral_statements/parallel_and_sequential_blocks.rs index d0a79f2..4345398 100644 --- a/src/parser/behavioral_statements/parallel_and_sequential_blocks.rs +++ b/src/parser/behavioral_statements/parallel_and_sequential_blocks.rs @@ -52,6 +52,7 @@ pub enum JoinKeyword<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn action_block(s: Span) -> IResult { alt(( map(statement_or_null, |x| ActionBlock::StatementOrNull(x)), @@ -59,6 +60,7 @@ pub fn action_block(s: Span) -> IResult { ))(s) } +#[trace] pub fn action_block_else(s: Span) -> IResult { let (s, a) = opt(statement)(s)?; let (s, b) = symbol("else")(s)?; @@ -66,6 +68,7 @@ pub fn action_block_else(s: Span) -> IResult { Ok((s, ActionBlock::Else(ActionBlockElse { nodes: (a, b, c) }))) } +#[trace] pub fn seq_block(s: Span) -> IResult { let (s, a) = symbol("begin")(s)?; let (s, b) = opt(pair(symbol(":"), block_identifier))(s)?; @@ -81,6 +84,7 @@ pub fn seq_block(s: Span) -> IResult { )) } +#[trace] pub fn par_block(s: Span) -> IResult { let (s, a) = symbol("fork")(s)?; let (s, b) = opt(pair(symbol(":"), block_identifier))(s)?; @@ -96,6 +100,7 @@ pub fn par_block(s: Span) -> IResult { )) } +#[trace] pub fn join_keyword(s: Span) -> IResult { alt(( map(symbol("join_any"), |x| JoinKeyword::JoinAny(x)), diff --git a/src/parser/behavioral_statements/patterns.rs b/src/parser/behavioral_statements/patterns.rs index 9a609ab..2d4e2ae 100644 --- a/src/parser/behavioral_statements/patterns.rs +++ b/src/parser/behavioral_statements/patterns.rs @@ -132,6 +132,7 @@ pub struct AssignmentPatternVariableLvalue<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn pattern(s: Span) -> IResult { alt(( pattern_variable, @@ -145,6 +146,7 @@ pub fn pattern(s: Span) -> IResult { ))(s) } +#[trace] pub fn pattern_variable(s: Span) -> IResult { let (s, a) = symbol(".")(s)?; let (s, b) = variable_identifier(s)?; @@ -154,6 +156,7 @@ pub fn pattern_variable(s: Span) -> IResult { )) } +#[trace] pub fn pattern_tagged(s: Span) -> IResult { let (s, a) = symbol("tagged")(s)?; let (s, b) = member_identifier(s)?; @@ -164,11 +167,13 @@ pub fn pattern_tagged(s: Span) -> IResult { )) } +#[trace] pub fn pattern_list(s: Span) -> IResult { let (s, a) = apostrophe_brace(list(symbol(","), pattern))(s)?; Ok((s, Pattern::List(Box::new(PatternList { nodes: (a,) })))) } +#[trace] pub fn pattern_identifier_list(s: Span) -> IResult { let (s, a) = apostrophe_brace(list( symbol(","), @@ -180,6 +185,7 @@ pub fn pattern_identifier_list(s: Span) -> IResult { )) } +#[trace] pub fn assignment_pattern(s: Span) -> IResult { alt(( assignment_pattern_list, @@ -189,6 +195,7 @@ pub fn assignment_pattern(s: Span) -> IResult { ))(s) } +#[trace] pub fn assignment_pattern_list(s: Span) -> IResult { let (s, a) = apostrophe_brace(list(symbol(","), expression))(s)?; Ok(( @@ -197,6 +204,7 @@ pub fn assignment_pattern_list(s: Span) -> IResult { )) } +#[trace] pub fn assignment_pattern_structure(s: Span) -> IResult { let (s, a) = apostrophe_brace(list( symbol(","), @@ -208,6 +216,7 @@ pub fn assignment_pattern_structure(s: Span) -> IResult )) } +#[trace] pub fn assignment_pattern_array(s: Span) -> IResult { let (s, a) = apostrophe_brace(list( symbol(","), @@ -219,6 +228,7 @@ pub fn assignment_pattern_array(s: Span) -> IResult { )) } +#[trace] pub fn assignment_pattern_repeat(s: Span) -> IResult { let (s, a) = apostrophe_brace(pair( constant_expression, @@ -230,6 +240,7 @@ pub fn assignment_pattern_repeat(s: Span) -> IResult { )) } +#[trace] pub fn structure_pattern_key(s: Span) -> IResult { alt(( map(member_identifier, |x| { @@ -241,6 +252,7 @@ pub fn structure_pattern_key(s: Span) -> IResult { ))(s) } +#[trace] pub fn array_pattern_key(s: Span) -> IResult { alt(( map(constant_expression, |x| { @@ -252,6 +264,7 @@ pub fn array_pattern_key(s: Span) -> IResult { ))(s) } +#[trace] pub fn assignment_pattern_key(s: Span) -> IResult { alt(( map(simple_type, |x| AssignmentPatternKey::SimpleType(x)), @@ -259,12 +272,14 @@ pub fn assignment_pattern_key(s: Span) -> IResult { ))(s) } +#[trace] pub fn assignment_pattern_expression(s: Span) -> IResult { let (s, a) = opt(assignment_pattern_expression_type)(s)?; let (s, b) = assignment_pattern(s)?; Ok((s, AssignmentPatternExpression { nodes: (a, b) })) } +#[trace] pub fn assignment_pattern_expression_type( s: Span, ) -> IResult { @@ -284,6 +299,7 @@ pub fn assignment_pattern_expression_type( ))(s) } +#[trace] pub fn constant_assignment_pattern_expression( s: Span, ) -> IResult { @@ -291,11 +307,13 @@ pub fn constant_assignment_pattern_expression( Ok((s, ConstantAssignmentPatternExpression { nodes: (a,) })) } +#[trace] pub fn assignment_pattern_net_lvalue(s: Span) -> IResult { let (s, a) = apostrophe_brace(list(symbol(","), net_lvalue))(s)?; Ok((s, AssignmentPatternNetLvalue { nodes: (a,) })) } +#[trace] pub fn assignment_pattern_variable_lvalue( s: Span, ) -> IResult { diff --git a/src/parser/behavioral_statements/procedural_blocks_and_assignments.rs b/src/parser/behavioral_statements/procedural_blocks_and_assignments.rs index 7f708fe..81e7f2c 100644 --- a/src/parser/behavioral_statements/procedural_blocks_and_assignments.rs +++ b/src/parser/behavioral_statements/procedural_blocks_and_assignments.rs @@ -130,18 +130,21 @@ pub struct VariableAssignment<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn initial_construct(s: Span) -> IResult { let (s, a) = symbol("initial")(s)?; let (s, b) = statement_or_null(s)?; Ok((s, InitialConstruct { nodes: (a, b) })) } +#[trace] pub fn always_construct(s: Span) -> IResult { let (s, a) = always_keyword(s)?; let (s, b) = statement(s)?; Ok((s, AlwaysConstruct { nodes: (a, b) })) } +#[trace] pub fn always_keyword(s: Span) -> IResult { alt(( map(symbol("always_comb"), |x| AlwaysKeyword::AlwaysComb(x)), @@ -151,12 +154,14 @@ pub fn always_keyword(s: Span) -> IResult { ))(s) } +#[trace] pub fn final_construct(s: Span) -> IResult { let (s, a) = symbol("final")(s)?; let (s, b) = function_statement(s)?; Ok((s, FinalConstruct { nodes: (a, b) })) } +#[trace] pub fn blocking_assignment(s: Span) -> IResult { alt(( blocking_assignment_variable, @@ -168,6 +173,7 @@ pub fn blocking_assignment(s: Span) -> IResult { ))(s) } +#[trace] pub fn blocking_assignment_variable(s: Span) -> IResult { let (s, a) = variable_lvalue(s)?; let (s, b) = symbol("=")(s)?; @@ -181,6 +187,7 @@ pub fn blocking_assignment_variable(s: Span) -> IResult IResult { let (s, a) = nonrange_variable_lvalue(s)?; let (s, b) = symbol("=")(s)?; @@ -193,6 +200,7 @@ pub fn blocking_assignment_nonrange_variable(s: Span) -> IResult IResult { let (s, a) = opt(implicit_class_handle_or_class_scope_or_package_scope)(s)?; let (s, b) = hierarchical_variable_identifier(s)?; @@ -207,6 +215,7 @@ pub fn blocking_assignment_hierarchical_variable(s: Span) -> IResult IResult { let (s, a) = variable_lvalue(s)?; let (s, b) = assignment_operator(s)?; @@ -214,6 +223,7 @@ pub fn operator_assignment(s: Span) -> IResult { Ok((s, OperatorAssignment { nodes: (a, b, c) })) } +#[trace] pub fn assignment_operator(s: Span) -> IResult { alt(( map(symbol("="), |x| AssignmentOperator { nodes: (x,) }), @@ -232,6 +242,7 @@ pub fn assignment_operator(s: Span) -> IResult { ))(s) } +#[trace] pub fn nonblocking_assignment(s: Span) -> IResult { let (s, a) = variable_lvalue(s)?; let (s, b) = symbol("<=")(s)?; @@ -245,6 +256,7 @@ pub fn nonblocking_assignment(s: Span) -> IResult { )) } +#[trace] pub fn procedural_continuous_assignment(s: Span) -> IResult { alt(( procedural_continuous_assignment_assign, @@ -256,6 +268,7 @@ pub fn procedural_continuous_assignment(s: Span) -> IResult IResult { @@ -269,6 +282,7 @@ pub fn procedural_continuous_assignment_assign( )) } +#[trace] pub fn procedural_continuous_assignment_deassign( s: Span, ) -> IResult { @@ -282,6 +296,7 @@ pub fn procedural_continuous_assignment_deassign( )) } +#[trace] pub fn procedural_continuous_assignment_force_variable( s: Span, ) -> IResult { @@ -295,6 +310,7 @@ pub fn procedural_continuous_assignment_force_variable( )) } +#[trace] pub fn procedural_continuous_assignment_force_net( s: Span, ) -> IResult { @@ -308,6 +324,7 @@ pub fn procedural_continuous_assignment_force_net( )) } +#[trace] pub fn procedural_continuous_assignment_release_variable( s: Span, ) -> IResult { @@ -321,6 +338,7 @@ pub fn procedural_continuous_assignment_release_variable( )) } +#[trace] pub fn procedural_continuous_assignment_release_net( s: Span, ) -> IResult { @@ -334,6 +352,7 @@ pub fn procedural_continuous_assignment_release_net( )) } +#[trace] pub fn variable_assignment(s: Span) -> IResult { let (s, a) = variable_lvalue(s)?; let (s, b) = symbol("=")(s)?; diff --git a/src/parser/behavioral_statements/randsequence.rs b/src/parser/behavioral_statements/randsequence.rs index 6e5e906..42e9ece 100644 --- a/src/parser/behavioral_statements/randsequence.rs +++ b/src/parser/behavioral_statements/randsequence.rs @@ -150,6 +150,7 @@ pub struct RsCaseItemDefault<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn randsequence_statement(s: Span) -> IResult { let (s, a) = symbol("randsequence")(s)?; let (s, b) = paren(opt(production_identifier))(s)?; @@ -164,6 +165,7 @@ pub fn randsequence_statement(s: Span) -> IResult { )) } +#[trace] pub fn production(s: Span) -> IResult { let (s, a) = opt(data_type_or_void)(s)?; let (s, b) = production_identifier(s)?; @@ -179,6 +181,7 @@ pub fn production(s: Span) -> IResult { )) } +#[trace] pub fn rs_rule(s: Span) -> IResult { let (s, a) = rs_production_list(s)?; let (s, b) = opt(triple( @@ -189,10 +192,12 @@ pub fn rs_rule(s: Span) -> IResult { Ok((s, RsRule { nodes: (a, b) })) } +#[trace] pub fn rs_production_list(s: Span) -> IResult { alt((rs_production_list_prod, rs_production_list_join))(s) } +#[trace] pub fn rs_production_list_prod(s: Span) -> IResult { let (s, a) = rs_prod(s)?; let (s, b) = many0(rs_prod)(s)?; @@ -202,6 +207,7 @@ pub fn rs_production_list_prod(s: Span) -> IResult { )) } +#[trace] pub fn rs_production_list_join(s: Span) -> IResult { let (s, a) = symbol("rand")(s)?; let (s, b) = symbol("join")(s)?; @@ -217,6 +223,7 @@ pub fn rs_production_list_join(s: Span) -> IResult { )) } +#[trace] pub fn weight_specification(s: Span) -> IResult { alt(( map(integral_number, |x| WeightSpecification::IntegralNumber(x)), @@ -225,6 +232,7 @@ pub fn weight_specification(s: Span) -> IResult { ))(s) } +#[trace] pub fn weight_specification_expression(s: Span) -> IResult { let (s, a) = paren(expression)(s)?; Ok(( @@ -233,11 +241,13 @@ pub fn weight_specification_expression(s: Span) -> IResult IResult { let (s, a) = brace(pair(many0(data_declaration), many0(statement_or_null)))(s)?; Ok((s, RsCodeBlock { nodes: (a,) })) } +#[trace] pub fn rs_prod(s: Span) -> IResult { alt(( map(production_item, |x| RsProd::ProductionItem(x)), @@ -248,12 +258,14 @@ pub fn rs_prod(s: Span) -> IResult { ))(s) } +#[trace] pub fn production_item(s: Span) -> IResult { let (s, a) = production_identifier(s)?; let (s, b) = opt(paren(list_of_arguments))(s)?; Ok((s, ProductionItem { nodes: (a, b) })) } +#[trace] pub fn rs_if_else(s: Span) -> IResult { let (s, a) = symbol("if")(s)?; let (s, b) = paren(expression)(s)?; @@ -267,6 +279,7 @@ pub fn rs_if_else(s: Span) -> IResult { )) } +#[trace] pub fn rs_repeat(s: Span) -> IResult { let (s, a) = symbol("repeat")(s)?; let (s, b) = paren(expression)(s)?; @@ -274,6 +287,7 @@ pub fn rs_repeat(s: Span) -> IResult { Ok((s, RsRepeat { nodes: (a, b, c) })) } +#[trace] pub fn rs_case(s: Span) -> IResult { let (s, a) = symbol("case")(s)?; let (s, b) = paren(case_expression)(s)?; @@ -288,10 +302,12 @@ pub fn rs_case(s: Span) -> IResult { )) } +#[trace] pub fn rs_case_item(s: Span) -> IResult { alt((rs_case_item_nondefault, rs_case_item_default))(s) } +#[trace] pub fn rs_case_item_nondefault(s: Span) -> IResult { let (s, a) = list(symbol(","), case_item_expression)(s)?; let (s, b) = symbol(":")(s)?; @@ -305,6 +321,7 @@ pub fn rs_case_item_nondefault(s: Span) -> IResult { )) } +#[trace] pub fn rs_case_item_default(s: Span) -> IResult { let (s, a) = symbol("default")(s)?; let (s, b) = opt(symbol(":"))(s)?; diff --git a/src/parser/behavioral_statements/statements.rs b/src/parser/behavioral_statements/statements.rs index 002fe3a..015e5e6 100644 --- a/src/parser/behavioral_statements/statements.rs +++ b/src/parser/behavioral_statements/statements.rs @@ -75,6 +75,7 @@ pub struct VariableIdentifierList<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn statement_or_null(s: Span) -> IResult { alt(( map(statement, |x| StatementOrNull::Statement(x)), @@ -82,6 +83,7 @@ pub fn statement_or_null(s: Span) -> IResult { ))(s) } +#[trace] pub fn statement_or_null_attribute(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol(";")(s)?; @@ -91,6 +93,7 @@ pub fn statement_or_null_attribute(s: Span) -> IResult { )) } +#[trace] pub fn statement(s: Span) -> IResult { let (s, a) = opt(pair(block_identifier, symbol(":")))(s)?; let (s, b) = many0(attribute_instance)(s)?; @@ -98,6 +101,7 @@ pub fn statement(s: Span) -> IResult { Ok((s, Statement { nodes: (a, b, c) })) } +#[trace] pub fn statement_item(s: Span) -> IResult { alt(( map(pair(blocking_assignment, symbol(";")), |x| { @@ -157,11 +161,13 @@ pub fn statement_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn function_statement(s: Span) -> IResult { let (s, a) = statement(s)?; Ok((s, FunctionStatement { nodes: (a,) })) } +#[trace] pub fn function_statement_or_null(s: Span) -> IResult { alt(( map(function_statement, |x| { @@ -171,6 +177,7 @@ pub fn function_statement_or_null(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol(";")(s)?; @@ -180,6 +187,7 @@ pub fn function_statement_or_null_attribute(s: Span) -> IResult IResult { let (s, a) = list(symbol(","), variable_identifier)(s)?; Ok((s, VariableIdentifierList { nodes: (a,) })) diff --git a/src/parser/behavioral_statements/subroutine_call_statements.rs b/src/parser/behavioral_statements/subroutine_call_statements.rs index c5d9fa3..9588242 100644 --- a/src/parser/behavioral_statements/subroutine_call_statements.rs +++ b/src/parser/behavioral_statements/subroutine_call_statements.rs @@ -25,6 +25,7 @@ pub struct SubroutineCallStatementFunction<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn subroutine_call_statement(s: Span) -> IResult { alt(( map(pair(subroutine_call, symbol(";")), |x| { @@ -34,6 +35,7 @@ pub fn subroutine_call_statement(s: Span) -> IResult IResult { let (s, a) = symbol("void")(s)?; let (s, b) = symbol("'")(s)?; diff --git a/src/parser/behavioral_statements/timing_control_statements.rs b/src/parser/behavioral_statements/timing_control_statements.rs index 1ca94ff..4d98d9b 100644 --- a/src/parser/behavioral_statements/timing_control_statements.rs +++ b/src/parser/behavioral_statements/timing_control_statements.rs @@ -212,6 +212,7 @@ pub struct DisableStatementFork<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn procedural_timing_control_statement( s: Span, ) -> IResult { @@ -220,6 +221,7 @@ pub fn procedural_timing_control_statement( Ok((s, ProceduralTimingControlStatement { nodes: (a, b) })) } +#[trace] pub fn delay_or_event_control(s: Span) -> IResult { alt(( map(delay_control, |x| DelayOrEventControl::Delay(x)), @@ -228,6 +230,7 @@ pub fn delay_or_event_control(s: Span) -> IResult { ))(s) } +#[trace] pub fn delay_or_event_control_repeat(s: Span) -> IResult { let (s, a) = symbol("repeat")(s)?; let (s, b) = paren(expression)(s)?; @@ -238,16 +241,19 @@ pub fn delay_or_event_control_repeat(s: Span) -> IResult IResult { alt((delay_control_delay, delay_control_mintypmax))(s) } +#[trace] pub fn delay_control_delay(s: Span) -> IResult { let (s, a) = symbol("#")(s)?; let (s, b) = delay_value(s)?; Ok((s, DelayControl::Delay(DelayControlDelay { nodes: (a, b) }))) } +#[trace] pub fn delay_control_mintypmax(s: Span) -> IResult { let (s, a) = symbol("#")(s)?; let (s, b) = paren(mintypmax_expression)(s)?; @@ -257,6 +263,7 @@ pub fn delay_control_mintypmax(s: Span) -> IResult { )) } +#[trace] pub fn event_control(s: Span) -> IResult { alt(( event_control_event_identifier, @@ -267,6 +274,7 @@ pub fn event_control(s: Span) -> IResult { ))(s) } +#[trace] pub fn event_control_event_identifier(s: Span) -> IResult { let (s, a) = symbol("@")(s)?; let (s, b) = hierarchical_event_identifier(s)?; @@ -276,6 +284,7 @@ pub fn event_control_event_identifier(s: Span) -> IResult { )) } +#[trace] pub fn event_control_event_expression(s: Span) -> IResult { let (s, a) = symbol("@")(s)?; let (s, b) = paren(event_expression)(s)?; @@ -285,6 +294,7 @@ pub fn event_control_event_expression(s: Span) -> IResult { )) } +#[trace] pub fn event_control_asterisk(s: Span) -> IResult { let (s, a) = symbol("@*")(s)?; Ok(( @@ -293,6 +303,7 @@ pub fn event_control_asterisk(s: Span) -> IResult { )) } +#[trace] pub fn event_control_paren_asterisk(s: Span) -> IResult { let (s, a) = symbol("@")(s)?; let (s, b) = paren(symbol("*"))(s)?; @@ -302,6 +313,7 @@ pub fn event_control_paren_asterisk(s: Span) -> IResult { )) } +#[trace] pub fn event_control_sequence_identifier(s: Span) -> IResult { let (s, a) = symbol("@")(s)?; let (s, b) = ps_or_hierarchical_sequence_identifier(s)?; @@ -311,6 +323,7 @@ pub fn event_control_sequence_identifier(s: Span) -> IResult )) } +#[trace] pub fn event_expression(s: Span) -> IResult { alt(( event_expression_expression, @@ -321,6 +334,7 @@ pub fn event_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn event_expression_expression(s: Span) -> IResult { let (s, a) = opt(edge_identifier)(s)?; let (s, b) = expression(s)?; @@ -331,6 +345,7 @@ pub fn event_expression_expression(s: Span) -> IResult { )) } +#[trace] pub fn event_expression_sequence(s: Span) -> IResult { let (s, a) = sequence_instance(s)?; let (s, b) = opt(pair(symbol("iff"), expression))(s)?; @@ -340,6 +355,7 @@ pub fn event_expression_sequence(s: Span) -> IResult { )) } +#[trace] pub fn event_expression_or(s: Span) -> IResult { let (s, a) = event_expression(s)?; let (s, b) = symbol("or")(s)?; @@ -350,6 +366,7 @@ pub fn event_expression_or(s: Span) -> IResult { )) } +#[trace] pub fn event_expression_comma(s: Span) -> IResult { let (s, a) = event_expression(s)?; let (s, b) = symbol(",")(s)?; @@ -360,6 +377,7 @@ pub fn event_expression_comma(s: Span) -> IResult { )) } +#[trace] pub fn event_expression_paren(s: Span) -> IResult { let (s, a) = paren(event_expression)(s)?; Ok(( @@ -368,6 +386,7 @@ pub fn event_expression_paren(s: Span) -> IResult { )) } +#[trace] pub fn procedural_timing_control(s: Span) -> IResult { alt(( map(delay_control, |x| ProceduralTimingControl::DelayControl(x)), @@ -376,6 +395,7 @@ pub fn procedural_timing_control(s: Span) -> IResult IResult { alt(( jump_statement_return, @@ -384,6 +404,7 @@ pub fn jump_statement(s: Span) -> IResult { ))(s) } +#[trace] pub fn jump_statement_return(s: Span) -> IResult { let (s, a) = symbol("return")(s)?; let (s, b) = opt(expression)(s)?; @@ -394,6 +415,7 @@ pub fn jump_statement_return(s: Span) -> IResult { )) } +#[trace] pub fn jump_statement_break(s: Span) -> IResult { let (s, a) = symbol("break")(s)?; let (s, b) = symbol(";")(s)?; @@ -403,6 +425,7 @@ pub fn jump_statement_break(s: Span) -> IResult { )) } +#[trace] pub fn jump_statement_continue(s: Span) -> IResult { let (s, a) = symbol("continue")(s)?; let (s, b) = symbol(";")(s)?; @@ -412,6 +435,7 @@ pub fn jump_statement_continue(s: Span) -> IResult { )) } +#[trace] pub fn wait_statement(s: Span) -> IResult { alt(( wait_statement_wait, @@ -420,6 +444,7 @@ pub fn wait_statement(s: Span) -> IResult { ))(s) } +#[trace] pub fn wait_statement_wait(s: Span) -> IResult { let (s, a) = symbol("wait")(s)?; let (s, b) = paren(expression)(s)?; @@ -430,6 +455,7 @@ pub fn wait_statement_wait(s: Span) -> IResult { )) } +#[trace] pub fn wait_statement_fork(s: Span) -> IResult { let (s, a) = symbol("wait")(s)?; let (s, b) = symbol("fork")(s)?; @@ -440,6 +466,7 @@ pub fn wait_statement_fork(s: Span) -> IResult { )) } +#[trace] pub fn wait_statement_order(s: Span) -> IResult { let (s, a) = symbol("wait_order")(s)?; let (s, b) = paren(list(symbol(","), hierarchical_identifier))(s)?; @@ -450,10 +477,12 @@ pub fn wait_statement_order(s: Span) -> IResult { )) } +#[trace] pub fn event_trigger(s: Span) -> IResult { alt((event_trigger_named, event_trigger_nonblocking))(s) } +#[trace] pub fn event_trigger_named(s: Span) -> IResult { let (s, a) = symbol("->")(s)?; let (s, b) = hierarchical_event_identifier(s)?; @@ -464,6 +493,7 @@ pub fn event_trigger_named(s: Span) -> IResult { )) } +#[trace] pub fn event_trigger_nonblocking(s: Span) -> IResult { let (s, a) = symbol("->>")(s)?; let (s, b) = opt(delay_or_event_control)(s)?; @@ -477,6 +507,7 @@ pub fn event_trigger_nonblocking(s: Span) -> IResult { )) } +#[trace] pub fn disable_statement(s: Span) -> IResult { alt(( disable_statement_task, @@ -485,6 +516,7 @@ pub fn disable_statement(s: Span) -> IResult { ))(s) } +#[trace] pub fn disable_statement_task(s: Span) -> IResult { let (s, a) = symbol("disable")(s)?; let (s, b) = hierarchical_task_identifier(s)?; @@ -495,6 +527,7 @@ pub fn disable_statement_task(s: Span) -> IResult { )) } +#[trace] pub fn disable_statement_block(s: Span) -> IResult { let (s, a) = symbol("disable")(s)?; let (s, b) = hierarchical_block_identifier(s)?; @@ -505,6 +538,7 @@ pub fn disable_statement_block(s: Span) -> IResult { )) } +#[trace] pub fn disable_statement_fork(s: Span) -> IResult { let (s, a) = symbol("disable")(s)?; let (s, b) = symbol("fork")(s)?; diff --git a/src/parser/declarations/assertion_declarations.rs b/src/parser/declarations/assertion_declarations.rs index affcf15..83f7b23 100644 --- a/src/parser/declarations/assertion_declarations.rs +++ b/src/parser/declarations/assertion_declarations.rs @@ -756,6 +756,7 @@ pub struct AssertionVariableDeclaration<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn concurrent_assertion_item(s: Span) -> IResult { alt(( concurrent_assertion_item_statement, @@ -765,6 +766,7 @@ pub fn concurrent_assertion_item(s: Span) -> IResult IResult { let (s, a) = opt(pair(block_identifier, symbol(":")))(s)?; let (s, b) = concurrent_assertion_statement(s)?; @@ -774,6 +776,7 @@ pub fn concurrent_assertion_item_statement(s: Span) -> IResult IResult { alt(( map(assert_property_statement, |x| { @@ -794,6 +797,7 @@ pub fn concurrent_assertion_statement(s: Span) -> IResult IResult { let (s, a) = symbol("assert")(s)?; let (s, b) = symbol("property")(s)?; @@ -807,6 +811,7 @@ pub fn assert_property_statement(s: Span) -> IResult IResult { let (s, a) = symbol("assume")(s)?; let (s, b) = symbol("property")(s)?; @@ -820,6 +825,7 @@ pub fn assume_property_statement(s: Span) -> IResult IResult { let (s, a) = symbol("cover")(s)?; let (s, b) = symbol("property")(s)?; @@ -833,6 +839,7 @@ pub fn cover_property_statement(s: Span) -> IResult IResult { let (s, a) = symbol("expect")(s)?; let (s, b) = paren(property_spec)(s)?; @@ -840,6 +847,7 @@ pub fn expect_property_statement(s: Span) -> IResult IResult { let (s, a) = symbol("cover")(s)?; let (s, b) = symbol("sequence")(s)?; @@ -861,6 +869,7 @@ pub fn cover_sequence_statement(s: Span) -> IResult IResult { let (s, a) = symbol("restrict")(s)?; let (s, b) = symbol("property")(s)?; @@ -874,12 +883,14 @@ pub fn restrict_property_statement(s: Span) -> IResult IResult { let (s, a) = ps_or_hierarchical_property_identifier(s)?; let (s, b) = opt(paren(opt(property_list_of_arguments)))(s)?; Ok((s, PropertyInstance { nodes: (a, b) })) } +#[trace] pub fn property_list_of_arguments(s: Span) -> IResult { alt(( property_list_of_arguments_ordered, @@ -887,6 +898,7 @@ pub fn property_list_of_arguments(s: Span) -> IResult IResult { let (s, a) = list(symbol(","), opt(property_actual_arg))(s)?; let (s, b) = many0(tuple(( @@ -901,6 +913,7 @@ pub fn property_list_of_arguments_ordered(s: Span) -> IResult IResult { let (s, a) = list( symbol(","), @@ -912,6 +925,7 @@ pub fn property_list_of_arguments_named(s: Span) -> IResult IResult { alt(( map(property_expr, |x| PropertyActualArg::PropertyExpr(x)), @@ -921,6 +935,7 @@ pub fn property_actual_arg(s: Span) -> IResult { ))(s) } +#[trace] pub fn assertion_item_declaration(s: Span) -> IResult { alt(( map(property_declaration, |x| { @@ -935,6 +950,7 @@ pub fn assertion_item_declaration(s: Span) -> IResult IResult { let (s, a) = symbol("property")(s)?; let (s, b) = property_identifier(s)?; @@ -953,11 +969,13 @@ pub fn property_declaration(s: Span) -> IResult { )) } +#[trace] pub fn property_port_list(s: Span) -> IResult { let (s, a) = list(symbol(","), property_port_item)(s)?; Ok((s, PropertyPortList { nodes: (a,) })) } +#[trace] pub fn property_port_item(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = opt(pair(local, opt(property_lvar_port_direction)))(s)?; @@ -973,11 +991,13 @@ pub fn property_port_item(s: Span) -> IResult { )) } +#[trace] pub fn property_lvar_port_direction(s: Span) -> IResult { let (s, a) = symbol("input")(s)?; Ok((s, PropertyLvarPortDirection::Input(a))) } +#[trace] pub fn property_formal_type(s: Span) -> IResult { alt(( map(sequence_formal_type, |x| { @@ -987,6 +1007,7 @@ pub fn property_formal_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn property_spec(s: Span) -> IResult { let (s, a) = opt(clocking_event)(s)?; let (s, b) = opt(triple( @@ -998,6 +1019,7 @@ pub fn property_spec(s: Span) -> IResult { Ok((s, PropertySpec { nodes: (a, b, c) })) } +#[trace] pub fn property_expr(s: Span) -> IResult { alt(( alt(( @@ -1040,6 +1062,7 @@ pub fn property_expr(s: Span) -> IResult { ))(s) } +#[trace] pub fn property_expr_strong(s: Span) -> IResult { let (s, a) = symbol("strong")(s)?; let (s, b) = paren(sequence_expr)(s)?; @@ -1049,6 +1072,7 @@ pub fn property_expr_strong(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_weak(s: Span) -> IResult { let (s, a) = symbol("weak")(s)?; let (s, b) = paren(sequence_expr)(s)?; @@ -1058,6 +1082,7 @@ pub fn property_expr_weak(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_paren(s: Span) -> IResult { let (s, a) = paren(sequence_expr)(s)?; Ok(( @@ -1066,6 +1091,7 @@ pub fn property_expr_paren(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_not(s: Span) -> IResult { let (s, a) = symbol("not")(s)?; let (s, b) = property_expr(s)?; @@ -1075,6 +1101,7 @@ pub fn property_expr_not(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_or(s: Span) -> IResult { let (s, a) = property_expr(s)?; let (s, b) = symbol("or")(s)?; @@ -1085,6 +1112,7 @@ pub fn property_expr_or(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_and(s: Span) -> IResult { let (s, a) = property_expr(s)?; let (s, b) = symbol("and")(s)?; @@ -1095,6 +1123,7 @@ pub fn property_expr_and(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_implication_overlapped(s: Span) -> IResult { let (s, a) = sequence_expr(s)?; let (s, b) = symbol("|->")(s)?; @@ -1107,6 +1136,7 @@ pub fn property_expr_implication_overlapped(s: Span) -> IResult IResult { let (s, a) = sequence_expr(s)?; let (s, b) = symbol("|=>")(s)?; @@ -1119,6 +1149,7 @@ pub fn property_expr_implication_nonoverlapped(s: Span) -> IResult IResult { let (s, a) = symbol("if")(s)?; let (s, b) = paren(expression_or_dist)(s)?; @@ -1132,6 +1163,7 @@ pub fn property_expr_if(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_case(s: Span) -> IResult { let (s, a) = symbol("case")(s)?; let (s, b) = paren(expression_or_dist)(s)?; @@ -1146,6 +1178,7 @@ pub fn property_expr_case(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_followed_by_overlapped(s: Span) -> IResult { let (s, a) = sequence_expr(s)?; let (s, b) = symbol("#-#")(s)?; @@ -1158,6 +1191,7 @@ pub fn property_expr_followed_by_overlapped(s: Span) -> IResult IResult { let (s, a) = sequence_expr(s)?; let (s, b) = symbol("#=#")(s)?; @@ -1170,6 +1204,7 @@ pub fn property_expr_followed_by_nonoverlapped(s: Span) -> IResult IResult { let (s, a) = symbol("nexttime")(s)?; let (s, b) = opt(bracket(constant_expression))(s)?; @@ -1180,6 +1215,7 @@ pub fn property_expr_nexttime(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_s_nexttime(s: Span) -> IResult { let (s, a) = symbol("s_nexttime")(s)?; let (s, b) = opt(bracket(constant_expression))(s)?; @@ -1190,6 +1226,7 @@ pub fn property_expr_s_nexttime(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_always(s: Span) -> IResult { let (s, a) = symbol("always")(s)?; let (s, b) = opt(bracket(cycle_delay_const_range_expression))(s)?; @@ -1200,6 +1237,7 @@ pub fn property_expr_always(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_s_always(s: Span) -> IResult { let (s, a) = symbol("s_always")(s)?; let (s, b) = bracket(cycle_delay_const_range_expression)(s)?; @@ -1210,6 +1248,7 @@ pub fn property_expr_s_always(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_eventually(s: Span) -> IResult { let (s, a) = symbol("eventually")(s)?; let (s, b) = bracket(constant_range)(s)?; @@ -1220,6 +1259,7 @@ pub fn property_expr_eventually(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_s_eventually(s: Span) -> IResult { let (s, a) = symbol("s_eventually")(s)?; let (s, b) = opt(bracket(cycle_delay_const_range_expression))(s)?; @@ -1230,6 +1270,7 @@ pub fn property_expr_s_eventually(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_until(s: Span) -> IResult { let (s, a) = property_expr(s)?; let (s, b) = symbol("until")(s)?; @@ -1240,6 +1281,7 @@ pub fn property_expr_until(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_s_until(s: Span) -> IResult { let (s, a) = property_expr(s)?; let (s, b) = symbol("s_until")(s)?; @@ -1250,6 +1292,7 @@ pub fn property_expr_s_until(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_until_with(s: Span) -> IResult { let (s, a) = property_expr(s)?; let (s, b) = symbol("until_with")(s)?; @@ -1260,6 +1303,7 @@ pub fn property_expr_until_with(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_s_until_with(s: Span) -> IResult { let (s, a) = property_expr(s)?; let (s, b) = symbol("s_until_with")(s)?; @@ -1270,6 +1314,7 @@ pub fn property_expr_s_until_with(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_implies(s: Span) -> IResult { let (s, a) = property_expr(s)?; let (s, b) = symbol("implies")(s)?; @@ -1280,6 +1325,7 @@ pub fn property_expr_implies(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_iff(s: Span) -> IResult { let (s, a) = property_expr(s)?; let (s, b) = symbol("iff")(s)?; @@ -1290,6 +1336,7 @@ pub fn property_expr_iff(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_accept_on(s: Span) -> IResult { let (s, a) = symbol("accept_on")(s)?; let (s, b) = paren(expression_or_dist)(s)?; @@ -1300,6 +1347,7 @@ pub fn property_expr_accept_on(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_reject_on(s: Span) -> IResult { let (s, a) = symbol("reject_on")(s)?; let (s, b) = paren(expression_or_dist)(s)?; @@ -1310,6 +1358,7 @@ pub fn property_expr_reject_on(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_sync_accept_on(s: Span) -> IResult { let (s, a) = symbol("sync_accept_on")(s)?; let (s, b) = paren(expression_or_dist)(s)?; @@ -1320,6 +1369,7 @@ pub fn property_expr_sync_accept_on(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_sync_reject_on(s: Span) -> IResult { let (s, a) = symbol("sync_reject_on")(s)?; let (s, b) = paren(expression_or_dist)(s)?; @@ -1330,6 +1380,7 @@ pub fn property_expr_sync_reject_on(s: Span) -> IResult { )) } +#[trace] pub fn property_expr_clocking_event(s: Span) -> IResult { let (s, a) = clocking_event(s)?; let (s, b) = property_expr(s)?; @@ -1339,10 +1390,12 @@ pub fn property_expr_clocking_event(s: Span) -> IResult { )) } +#[trace] pub fn property_case_item(s: Span) -> IResult { alt((property_case_item_nondefault, property_case_item_default))(s) } +#[trace] pub fn property_case_item_nondefault(s: Span) -> IResult { let (s, a) = list(symbol(","), expression_or_dist)(s)?; let (s, b) = symbol(":")(s)?; @@ -1356,6 +1409,7 @@ pub fn property_case_item_nondefault(s: Span) -> IResult )) } +#[trace] pub fn property_case_item_default(s: Span) -> IResult { let (s, a) = symbol("default")(s)?; let (s, b) = opt(symbol(":"))(s)?; @@ -1369,6 +1423,7 @@ pub fn property_case_item_default(s: Span) -> IResult { )) } +#[trace] pub fn sequence_declaration(s: Span) -> IResult { let (s, a) = symbol("sequence")(s)?; let (s, b) = sequence_identifier(s)?; @@ -1387,11 +1442,13 @@ pub fn sequence_declaration(s: Span) -> IResult { )) } +#[trace] pub fn sequence_port_list(s: Span) -> IResult { let (s, a) = list(symbol(","), sequence_port_item)(s)?; Ok((s, SequencePortList { nodes: (a,) })) } +#[trace] pub fn sequence_port_item(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = opt(pair(local, opt(sequence_lvar_port_direction)))(s)?; @@ -1407,6 +1464,7 @@ pub fn sequence_port_item(s: Span) -> IResult { )) } +#[trace] pub fn sequence_lvar_port_direction(s: Span) -> IResult { alt(( map(symbol("input"), |x| SequenceLvarPortDirection::Input(x)), @@ -1415,6 +1473,7 @@ pub fn sequence_lvar_port_direction(s: Span) -> IResult IResult { alt(( map(data_type_or_implicit, |x| { @@ -1425,6 +1484,7 @@ pub fn sequence_formal_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn sequence_expr(s: Span) -> IResult { alt(( sequence_expr_cycle_delay_expr, @@ -1442,6 +1502,7 @@ pub fn sequence_expr(s: Span) -> IResult { ))(s) } +#[trace] pub fn sequence_expr_cycle_delay_expr(s: Span) -> IResult { let (s, a) = cycle_delay_range(s)?; let (s, b) = sequence_expr(s)?; @@ -1452,6 +1513,7 @@ pub fn sequence_expr_cycle_delay_expr(s: Span) -> IResult { )) } +#[trace] pub fn sequence_expr_expr_cycle_delay_expr(s: Span) -> IResult { let (s, a) = sequence_expr(s)?; let (s, b) = cycle_delay_range(s)?; @@ -1465,6 +1527,7 @@ pub fn sequence_expr_expr_cycle_delay_expr(s: Span) -> IResult IResult { let (s, a) = expression_or_dist(s)?; let (s, b) = opt(boolean_abbrev)(s)?; @@ -1474,6 +1537,7 @@ pub fn sequence_expr_expression(s: Span) -> IResult { )) } +#[trace] pub fn sequence_expr_instance(s: Span) -> IResult { let (s, a) = sequence_instance(s)?; let (s, b) = opt(sequence_abbrev)(s)?; @@ -1483,6 +1547,7 @@ pub fn sequence_expr_instance(s: Span) -> IResult { )) } +#[trace] pub fn sequence_expr_paren(s: Span) -> IResult { let (s, a) = paren(pair( sequence_expr, @@ -1495,6 +1560,7 @@ pub fn sequence_expr_paren(s: Span) -> IResult { )) } +#[trace] pub fn sequence_expr_and(s: Span) -> IResult { let (s, a) = sequence_expr(s)?; let (s, b) = symbol("and")(s)?; @@ -1505,6 +1571,7 @@ pub fn sequence_expr_and(s: Span) -> IResult { )) } +#[trace] pub fn sequence_expr_intersect(s: Span) -> IResult { let (s, a) = sequence_expr(s)?; let (s, b) = symbol("intersect")(s)?; @@ -1515,6 +1582,7 @@ pub fn sequence_expr_intersect(s: Span) -> IResult { )) } +#[trace] pub fn sequence_expr_or(s: Span) -> IResult { let (s, a) = sequence_expr(s)?; let (s, b) = symbol("or")(s)?; @@ -1525,6 +1593,7 @@ pub fn sequence_expr_or(s: Span) -> IResult { )) } +#[trace] pub fn sequence_expr_first_match(s: Span) -> IResult { let (s, a) = symbol("first_match")(s)?; let (s, b) = paren(pair( @@ -1537,6 +1606,7 @@ pub fn sequence_expr_first_match(s: Span) -> IResult { )) } +#[trace] pub fn sequence_expr_throughout(s: Span) -> IResult { let (s, a) = expression_or_dist(s)?; let (s, b) = symbol("throughout")(s)?; @@ -1547,6 +1617,7 @@ pub fn sequence_expr_throughout(s: Span) -> IResult { )) } +#[trace] pub fn sequence_expr_within(s: Span) -> IResult { let (s, a) = sequence_expr(s)?; let (s, b) = symbol("within")(s)?; @@ -1557,6 +1628,7 @@ pub fn sequence_expr_within(s: Span) -> IResult { )) } +#[trace] pub fn sequence_expr_clocking_event(s: Span) -> IResult { let (s, a) = clocking_event(s)?; let (s, b) = sequence_expr(s)?; @@ -1566,6 +1638,7 @@ pub fn sequence_expr_clocking_event(s: Span) -> IResult { )) } +#[trace] pub fn cycle_delay_range(s: Span) -> IResult { alt(( cycle_delay_range_primary, @@ -1575,6 +1648,7 @@ pub fn cycle_delay_range(s: Span) -> IResult { ))(s) } +#[trace] pub fn cycle_delay_range_primary(s: Span) -> IResult { let (s, a) = symbol("##")(s)?; let (s, b) = constant_primary(s)?; @@ -1584,6 +1658,7 @@ pub fn cycle_delay_range_primary(s: Span) -> IResult { )) } +#[trace] pub fn cycle_delay_range_expression(s: Span) -> IResult { let (s, a) = symbol("##")(s)?; let (s, b) = bracket(cycle_delay_const_range_expression)(s)?; @@ -1593,6 +1668,7 @@ pub fn cycle_delay_range_expression(s: Span) -> IResult { )) } +#[trace] pub fn cycle_delay_range_asterisk(s: Span) -> IResult { let (s, a) = symbol("##")(s)?; let (s, b) = bracket(symbol("*"))(s)?; @@ -1602,6 +1678,7 @@ pub fn cycle_delay_range_asterisk(s: Span) -> IResult { )) } +#[trace] pub fn cycle_delay_range_plus(s: Span) -> IResult { let (s, a) = symbol("##")(s)?; let (s, b) = bracket(symbol("+"))(s)?; @@ -1611,6 +1688,7 @@ pub fn cycle_delay_range_plus(s: Span) -> IResult { )) } +#[trace] pub fn sequence_method_call(s: Span) -> IResult { let (s, a) = sequence_instance(s)?; let (s, b) = symbol(".")(s)?; @@ -1618,6 +1696,7 @@ pub fn sequence_method_call(s: Span) -> IResult { Ok((s, SequenceMethodCall { nodes: (a, b, c) })) } +#[trace] pub fn sequence_match_item(s: Span) -> IResult { alt(( map(operator_assignment, |x| { @@ -1630,12 +1709,14 @@ pub fn sequence_match_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn sequence_instance(s: Span) -> IResult { let (s, a) = ps_or_hierarchical_sequence_identifier(s)?; let (s, b) = opt(paren(opt(sequence_list_of_arguments)))(s)?; Ok((s, SequenceInstance { nodes: (a, b) })) } +#[trace] pub fn sequence_list_of_arguments(s: Span) -> IResult { alt(( sequence_list_of_arguments_ordered, @@ -1643,6 +1724,7 @@ pub fn sequence_list_of_arguments(s: Span) -> IResult IResult { let (s, a) = list(symbol(","), opt(sequence_actual_arg))(s)?; let (s, b) = many0(tuple(( @@ -1657,6 +1739,7 @@ pub fn sequence_list_of_arguments_ordered(s: Span) -> IResult IResult { let (s, a) = list( symbol(","), @@ -1668,6 +1751,7 @@ pub fn sequence_list_of_arguments_named(s: Span) -> IResult IResult { alt(( map(event_expression, |x| SequenceActualArg::EventExpression(x)), @@ -1675,6 +1759,7 @@ pub fn sequence_actual_arg(s: Span) -> IResult { ))(s) } +#[trace] pub fn boolean_abbrev(s: Span) -> IResult { alt(( map(consecutive_repetition, |x| { @@ -1687,11 +1772,13 @@ pub fn boolean_abbrev(s: Span) -> IResult { ))(s) } +#[trace] pub fn sequence_abbrev(s: Span) -> IResult { let (s, a) = consecutive_repetition(s)?; Ok((s, SequenceAbbrev { nodes: (a,) })) } +#[trace] pub fn consecutive_repetition(s: Span) -> IResult { alt(( consecutive_repetition_expression, @@ -1700,6 +1787,7 @@ pub fn consecutive_repetition(s: Span) -> IResult { ))(s) } +#[trace] pub fn consecutive_repetition_expression(s: Span) -> IResult { let (s, a) = bracket(pair(symbol("*"), const_or_range_expression))(s)?; Ok(( @@ -1708,6 +1796,7 @@ pub fn consecutive_repetition_expression(s: Span) -> IResult IResult { let (s, a) = bracket(symbol("*"))(s)?; Ok(( @@ -1716,6 +1805,7 @@ pub fn consecutive_repetition_asterisk(s: Span) -> IResult IResult { let (s, a) = bracket(symbol("+"))(s)?; Ok(( @@ -1724,16 +1814,19 @@ pub fn consecutive_repetition_plus(s: Span) -> IResult IResult { let (s, a) = bracket(pair(symbol("="), const_or_range_expression))(s)?; Ok((s, NonConsecutiveRepetition { nodes: (a,) })) } +#[trace] pub fn goto_repetition(s: Span) -> IResult { let (s, a) = bracket(pair(symbol("->"), const_or_range_expression))(s)?; Ok((s, GotoRepetition { nodes: (a,) })) } +#[trace] pub fn const_or_range_expression(s: Span) -> IResult { alt(( map(constant_expression, |x| { @@ -1745,6 +1838,7 @@ pub fn const_or_range_expression(s: Span) -> IResult IResult { @@ -1754,6 +1848,7 @@ pub fn cycle_delay_const_range_expression( ))(s) } +#[trace] pub fn cycle_delay_const_range_expression_binary( s: Span, ) -> IResult { @@ -1768,6 +1863,7 @@ pub fn cycle_delay_const_range_expression_binary( )) } +#[trace] pub fn cycle_delay_const_range_expression_dollar( s: Span, ) -> IResult { @@ -1782,12 +1878,14 @@ pub fn cycle_delay_const_range_expression_dollar( )) } +#[trace] pub fn expression_or_dist(s: Span) -> IResult { let (s, a) = expression(s)?; let (s, b) = opt(pair(symbol("dist"), brace(dist_list)))(s)?; Ok((s, ExpressionOrDist { nodes: (a, b) })) } +#[trace] pub fn assertion_variable_declaration(s: Span) -> IResult { let (s, a) = var_data_type(s)?; let (s, b) = list_of_variable_decl_assignments(s)?; diff --git a/src/parser/declarations/block_item_declarations.rs b/src/parser/declarations/block_item_declarations.rs index 2c46ef0..837e359 100644 --- a/src/parser/declarations/block_item_declarations.rs +++ b/src/parser/declarations/block_item_declarations.rs @@ -44,6 +44,7 @@ pub struct BlockItemDeclarationLet<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn block_item_declaration(s: Span) -> IResult { alt(( block_item_declaration_data, @@ -53,6 +54,7 @@ pub fn block_item_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn block_item_declaration_data(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = data_declaration(s)?; @@ -62,6 +64,7 @@ pub fn block_item_declaration_data(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = local_parameter_declaration(s)?; @@ -74,6 +77,7 @@ pub fn block_item_declaration_local_parameter(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = parameter_declaration(s)?; @@ -84,6 +88,7 @@ pub fn block_item_declaration_parameter(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = let_declaration(s)?; diff --git a/src/parser/declarations/covergroup_declarations.rs b/src/parser/declarations/covergroup_declarations.rs index 1beeb4a..85b0b03 100644 --- a/src/parser/declarations/covergroup_declarations.rs +++ b/src/parser/declarations/covergroup_declarations.rs @@ -521,6 +521,7 @@ pub struct CovergroupExpression<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn covergroup_declaration(s: Span) -> IResult { let (s, a) = symbol("covergroup")(s)?; let (s, b) = covergroup_identifier(s)?; @@ -538,10 +539,12 @@ pub fn covergroup_declaration(s: Span) -> IResult { )) } +#[trace] pub fn coverage_spec_or_option(s: Span) -> IResult { alt((coverage_spec_or_option_spec, coverage_spec_or_option_option))(s) } +#[trace] pub fn coverage_spec_or_option_spec(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = coverage_spec(s)?; @@ -551,6 +554,7 @@ pub fn coverage_spec_or_option_spec(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = coverage_option(s)?; @@ -561,10 +565,12 @@ pub fn coverage_spec_or_option_option(s: Span) -> IResult IResult { alt((coverage_option_option, coverage_option_type_option))(s) } +#[trace] pub fn coverage_option_option(s: Span) -> IResult { let (s, a) = symbol("option")(s)?; let (s, b) = symbol(".")(s)?; @@ -579,6 +585,7 @@ pub fn coverage_option_option(s: Span) -> IResult { )) } +#[trace] pub fn coverage_option_type_option(s: Span) -> IResult { let (s, a) = symbol("type_option")(s)?; let (s, b) = symbol(".")(s)?; @@ -593,6 +600,7 @@ pub fn coverage_option_type_option(s: Span) -> IResult { )) } +#[trace] pub fn coverage_spec(s: Span) -> IResult { alt(( map(cover_point, |x| CoverageSpec::CoverPoint(x)), @@ -600,6 +608,7 @@ pub fn coverage_spec(s: Span) -> IResult { ))(s) } +#[trace] pub fn coverage_event(s: Span) -> IResult { alt(( map(clocking_event, |x| CoverageEvent::ClockingEvent(x)), @@ -608,6 +617,7 @@ pub fn coverage_event(s: Span) -> IResult { ))(s) } +#[trace] pub fn coverage_event_sample(s: Span) -> IResult { let (s, a) = symbol("with")(s)?; let (s, b) = symbol("function")(s)?; @@ -621,12 +631,14 @@ pub fn coverage_event_sample(s: Span) -> IResult { )) } +#[trace] pub fn coverage_event_at(s: Span) -> IResult { let (s, a) = symbol("@@")(s)?; let (s, b) = paren(block_event_expression)(s)?; Ok((s, CoverageEvent::At(CoverageEventAt { nodes: (a, b) }))) } +#[trace] pub fn block_event_expression(s: Span) -> IResult { alt(( block_event_expression_or, @@ -635,6 +647,7 @@ pub fn block_event_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn block_event_expression_or(s: Span) -> IResult { let (s, a) = block_event_expression(s)?; let (s, b) = symbol("or")(s)?; @@ -645,6 +658,7 @@ pub fn block_event_expression_or(s: Span) -> IResult )) } +#[trace] pub fn block_event_expression_begin(s: Span) -> IResult { let (s, a) = symbol("begin")(s)?; let (s, b) = hierarchical_btf_identifier(s)?; @@ -654,6 +668,7 @@ pub fn block_event_expression_begin(s: Span) -> IResult IResult { let (s, a) = symbol("end")(s)?; let (s, b) = hierarchical_btf_identifier(s)?; @@ -663,6 +678,7 @@ pub fn block_event_expression_end(s: Span) -> IResult IResult { alt(( map(hierarchical_tf_identifier, |x| { @@ -675,6 +691,7 @@ pub fn hierarchical_btf_identifier(s: Span) -> IResult IResult { let (s, a) = opt(hierarchical_identifier_or_class_scope)(s)?; let (s, b) = method_identifier(s)?; @@ -684,6 +701,7 @@ pub fn hierarchical_btf_identifier_method(s: Span) -> IResult IResult { @@ -697,6 +715,7 @@ pub fn hierarchical_identifier_or_class_scope( ))(s) } +#[trace] pub fn cover_point(s: Span) -> IResult { let (s, a) = opt(triple( opt(data_type_or_implicit), @@ -715,6 +734,7 @@ pub fn cover_point(s: Span) -> IResult { )) } +#[trace] pub fn bins_or_empty(s: Span) -> IResult { alt(( bins_or_empty_non_empty, @@ -722,6 +742,7 @@ pub fn bins_or_empty(s: Span) -> IResult { ))(s) } +#[trace] pub fn bins_or_empty_non_empty(s: Span) -> IResult { let (s, a) = brace(pair( many0(attribute_instance), @@ -733,6 +754,7 @@ pub fn bins_or_empty_non_empty(s: Span) -> IResult { )) } +#[trace] pub fn bins_or_options(s: Span) -> IResult { alt(( map(coverage_option, |x| BinsOrOptions::CoverageOption(x)), @@ -745,6 +767,7 @@ pub fn bins_or_options(s: Span) -> IResult { ))(s) } +#[trace] pub fn bins_or_options_covergroup(s: Span) -> IResult { let (s, a) = opt(wildcard)(s)?; let (s, b) = bins_keyword(s)?; @@ -762,11 +785,13 @@ pub fn bins_or_options_covergroup(s: Span) -> IResult { )) } +#[trace] pub fn wildcard(s: Span) -> IResult { let (s, a) = symbol("wildcard")(s)?; Ok((s, Wildcard { nodes: (a,) })) } +#[trace] pub fn bins_or_options_cover_point(s: Span) -> IResult { let (s, a) = opt(wildcard)(s)?; let (s, b) = bins_keyword(s)?; @@ -785,6 +810,7 @@ pub fn bins_or_options_cover_point(s: Span) -> IResult { )) } +#[trace] pub fn bins_or_options_set_covergroup(s: Span) -> IResult { let (s, a) = opt(wildcard)(s)?; let (s, b) = bins_keyword(s)?; @@ -801,6 +827,7 @@ pub fn bins_or_options_set_covergroup(s: Span) -> IResult { )) } +#[trace] pub fn bins_or_options_trans_list(s: Span) -> IResult { let (s, a) = opt(wildcard)(s)?; let (s, b) = bins_keyword(s)?; @@ -817,6 +844,7 @@ pub fn bins_or_options_trans_list(s: Span) -> IResult { )) } +#[trace] pub fn bins_or_options_default(s: Span) -> IResult { let (s, a) = bins_keyword(s)?; let (s, b) = bin_identifier(s)?; @@ -832,6 +860,7 @@ pub fn bins_or_options_default(s: Span) -> IResult { )) } +#[trace] pub fn bins_or_options_default_sequence(s: Span) -> IResult { let (s, a) = bins_keyword(s)?; let (s, b) = bin_identifier(s)?; @@ -847,6 +876,7 @@ pub fn bins_or_options_default_sequence(s: Span) -> IResult )) } +#[trace] pub fn bins_keyword(s: Span) -> IResult { alt(( map(symbol("bins"), |x| BinsKeyword::Bins(x)), @@ -855,16 +885,19 @@ pub fn bins_keyword(s: Span) -> IResult { ))(s) } +#[trace] pub fn trans_list(s: Span) -> IResult { let (s, a) = list(symbol(","), paren(trans_set))(s)?; Ok((s, TransList { nodes: (a,) })) } +#[trace] pub fn trans_set(s: Span) -> IResult { let (s, a) = list(symbol("=>"), trans_range_list)(s)?; Ok((s, TransSet { nodes: (a,) })) } +#[trace] pub fn trans_range_list(s: Span) -> IResult { alt(( map(trans_item, |x| TransRangeList::TransItem(x)), @@ -874,6 +907,7 @@ pub fn trans_range_list(s: Span) -> IResult { ))(s) } +#[trace] pub fn trans_range_list_asterisk(s: Span) -> IResult { let (s, a) = trans_item(s)?; let (s, b) = bracket(pair(symbol("*"), repeat_range))(s)?; @@ -883,6 +917,7 @@ pub fn trans_range_list_asterisk(s: Span) -> IResult { )) } +#[trace] pub fn trans_range_list_arrow(s: Span) -> IResult { let (s, a) = trans_item(s)?; let (s, b) = bracket(pair(symbol("->"), repeat_range))(s)?; @@ -892,6 +927,7 @@ pub fn trans_range_list_arrow(s: Span) -> IResult { )) } +#[trace] pub fn trans_range_list_equal(s: Span) -> IResult { let (s, a) = trans_item(s)?; let (s, b) = bracket(pair(symbol("="), repeat_range))(s)?; @@ -901,11 +937,13 @@ pub fn trans_range_list_equal(s: Span) -> IResult { )) } +#[trace] pub fn trans_item(s: Span) -> IResult { let (s, a) = covergroup_range_list(s)?; Ok((s, TransItem { nodes: (a,) })) } +#[trace] pub fn repeat_range(s: Span) -> IResult { alt(( map(covergroup_expression, |x| { @@ -915,6 +953,7 @@ pub fn repeat_range(s: Span) -> IResult { ))(s) } +#[trace] pub fn repeat_range_binary(s: Span) -> IResult { let (s, a) = covergroup_expression(s)?; let (s, b) = symbol(":")(s)?; @@ -925,6 +964,7 @@ pub fn repeat_range_binary(s: Span) -> IResult { )) } +#[trace] pub fn cover_cross(s: Span) -> IResult { let (s, a) = opt(pair(cross_identifier, symbol(":")))(s)?; let (s, b) = symbol("cross")(s)?; @@ -939,12 +979,14 @@ pub fn cover_cross(s: Span) -> IResult { )) } +#[trace] pub fn list_of_cross_items(s: Span) -> IResult { let (s, a) = cross_item(s)?; let (s, b) = list(symbol(","), cross_item)(s)?; Ok((s, ListOfCrossItems { nodes: (a, b) })) } +#[trace] pub fn cross_item(s: Span) -> IResult { alt(( map(cover_point_identifier, |x| { @@ -954,6 +996,7 @@ pub fn cross_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn cross_body(s: Span) -> IResult { alt(( cross_body_non_empty, @@ -961,11 +1004,13 @@ pub fn cross_body(s: Span) -> IResult { ))(s) } +#[trace] pub fn cross_body_non_empty(s: Span) -> IResult { let (s, a) = brace(many0(pair(cross_body_item, symbol(";"))))(s)?; Ok((s, CrossBody::NonEmpty(CrossBodyNonEmpty { nodes: (a,) }))) } +#[trace] pub fn cross_body_item(s: Span) -> IResult { alt(( map(function_declaration, |x| { @@ -977,6 +1022,7 @@ pub fn cross_body_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn bins_selection_or_option(s: Span) -> IResult { alt(( bins_selection_or_option_coverage, @@ -984,6 +1030,7 @@ pub fn bins_selection_or_option(s: Span) -> IResult ))(s) } +#[trace] pub fn bins_selection_or_option_coverage(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = coverage_option(s)?; @@ -993,6 +1040,7 @@ pub fn bins_selection_or_option_coverage(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = bins_selection(s)?; @@ -1002,6 +1050,7 @@ pub fn bins_selection_or_option_bins(s: Span) -> IResult IResult { let (s, a) = bins_keyword(s)?; let (s, b) = bin_identifier(s)?; @@ -1016,6 +1065,7 @@ pub fn bins_selection(s: Span) -> IResult { )) } +#[trace] pub fn select_expression(s: Span) -> IResult { alt(( map(select_condition, |x| SelectExpression::SelectCondition(x)), @@ -1029,6 +1079,7 @@ pub fn select_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn select_expression_not(s: Span) -> IResult { let (s, a) = symbol("!")(s)?; let (s, b) = select_condition(s)?; @@ -1038,6 +1089,7 @@ pub fn select_expression_not(s: Span) -> IResult { )) } +#[trace] pub fn select_expression_and(s: Span) -> IResult { let (s, a) = select_expression(s)?; let (s, b) = symbol("&&")(s)?; @@ -1048,6 +1100,7 @@ pub fn select_expression_and(s: Span) -> IResult { )) } +#[trace] pub fn select_expression_or(s: Span) -> IResult { let (s, a) = select_expression(s)?; let (s, b) = symbol("||")(s)?; @@ -1058,6 +1111,7 @@ pub fn select_expression_or(s: Span) -> IResult { )) } +#[trace] pub fn select_expression_paren(s: Span) -> IResult { let (s, a) = paren(select_expression)(s)?; Ok(( @@ -1066,6 +1120,7 @@ pub fn select_expression_paren(s: Span) -> IResult { )) } +#[trace] pub fn select_expression_with(s: Span) -> IResult { let (s, a) = select_expression(s)?; let (s, b) = symbol("with")(s)?; @@ -1079,6 +1134,7 @@ pub fn select_expression_with(s: Span) -> IResult { )) } +#[trace] pub fn select_expression_cross_set(s: Span) -> IResult { let (s, a) = cross_set_expression(s)?; let (s, b) = opt(pair(symbol("matches"), integer_covergroup_expression))(s)?; @@ -1088,6 +1144,7 @@ pub fn select_expression_cross_set(s: Span) -> IResult { )) } +#[trace] pub fn select_condition(s: Span) -> IResult { let (s, a) = symbol("binsof")(s)?; let (s, b) = paren(bins_expression)(s)?; @@ -1095,6 +1152,7 @@ pub fn select_condition(s: Span) -> IResult { Ok((s, SelectCondition { nodes: (a, b, c) })) } +#[trace] pub fn bins_expression(s: Span) -> IResult { alt(( map(variable_identifier, |x| { @@ -1104,6 +1162,7 @@ pub fn bins_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn bins_expression_cover_point(s: Span) -> IResult { let (s, a) = cover_point_identifier(s)?; let (s, b) = opt(pair(symbol("."), bin_identifier))(s)?; @@ -1113,11 +1172,13 @@ pub fn bins_expression_cover_point(s: Span) -> IResult { )) } +#[trace] pub fn covergroup_range_list(s: Span) -> IResult { let (s, a) = list(symbol(","), covergroup_value_range)(s)?; Ok((s, CovergroupRangeList { nodes: (a,) })) } +#[trace] pub fn covergroup_value_range(s: Span) -> IResult { alt(( map(covergroup_expression, |x| { @@ -1127,6 +1188,7 @@ pub fn covergroup_value_range(s: Span) -> IResult { ))(s) } +#[trace] pub fn covergroup_value_range_binary(s: Span) -> IResult { let (s, a) = bracket(triple( covergroup_expression, @@ -1139,26 +1201,31 @@ pub fn covergroup_value_range_binary(s: Span) -> IResult IResult { let (s, a) = covergroup_expression(s)?; Ok((s, WithCovergroupExpression { nodes: (a,) })) } +#[trace] pub fn set_covergroup_expression(s: Span) -> IResult { let (s, a) = covergroup_expression(s)?; Ok((s, SetCovergroupExpression { nodes: (a,) })) } +#[trace] pub fn integer_covergroup_expression(s: Span) -> IResult { let (s, a) = covergroup_expression(s)?; Ok((s, IntegerCovergroupExpression { nodes: (a,) })) } +#[trace] pub fn cross_set_expression(s: Span) -> IResult { let (s, a) = covergroup_expression(s)?; Ok((s, CrossSetExpression { nodes: (a,) })) } +#[trace] pub fn covergroup_expression(s: Span) -> IResult { let (s, a) = expression(s)?; Ok((s, CovergroupExpression { nodes: (a,) })) diff --git a/src/parser/declarations/declaration_assignments.rs b/src/parser/declarations/declaration_assignments.rs index 901f8ab..70ef49d 100644 --- a/src/parser/declarations/declaration_assignments.rs +++ b/src/parser/declarations/declaration_assignments.rs @@ -174,6 +174,7 @@ pub struct DynamicArrayNew<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn defparam_assignment(s: Span) -> IResult { let (s, a) = hierarchical_parameter_identifier(s)?; let (s, b) = symbol("=")(s)?; @@ -181,6 +182,7 @@ pub fn defparam_assignment(s: Span) -> IResult { Ok((s, DefparamAssignment { nodes: (a, b, c) })) } +#[trace] pub fn net_decl_assignment(s: Span) -> IResult { let (s, a) = net_identifier(s)?; let (s, b) = many0(unpacked_dimension)(s)?; @@ -188,6 +190,7 @@ pub fn net_decl_assignment(s: Span) -> IResult { Ok((s, NetDeclAssignment { nodes: (a, b, c) })) } +#[trace] pub fn param_assignment(s: Span) -> IResult { let (s, a) = parameter_identifier(s)?; let (s, b) = many0(unpacked_dimension)(s)?; @@ -195,6 +198,7 @@ pub fn param_assignment(s: Span) -> IResult { Ok((s, ParamAssignment { nodes: (a, b, c) })) } +#[trace] pub fn specparam_assignment(s: Span) -> IResult { alt(( specparam_assignment_mintypmax, @@ -204,6 +208,7 @@ pub fn specparam_assignment(s: Span) -> IResult { ))(s) } +#[trace] pub fn specparam_assignment_mintypmax(s: Span) -> IResult { let (s, a) = specparam_identifier(s)?; let (s, b) = symbol("=")(s)?; @@ -214,12 +219,14 @@ pub fn specparam_assignment_mintypmax(s: Span) -> IResult IResult { let (s, a) = type_identifier(s)?; let (s, b) = opt(pair(symbol("="), data_type))(s)?; Ok((s, TypeAssignment { nodes: (a, b) })) } +#[trace] pub fn pulse_control_specparam(s: Span) -> IResult { alt(( pulse_control_specparam_without_descriptor, @@ -227,6 +234,7 @@ pub fn pulse_control_specparam(s: Span) -> IResult ))(s) } +#[trace] pub fn pulse_control_specparam_without_descriptor(s: Span) -> IResult { let (s, a) = symbol("PATHPULSE$")(s)?; let (s, b) = symbol("=")(s)?; @@ -242,6 +250,7 @@ pub fn pulse_control_specparam_without_descriptor(s: Span) -> IResult IResult { let (s, a) = symbol("PATHPULSE$")(s)?; let (s, b) = specify_input_terminal_descriptor(s)?; @@ -260,21 +269,25 @@ pub fn pulse_control_specparam_with_descriptor(s: Span) -> IResult IResult { let (s, a) = limit_value(s)?; Ok((s, ErrorLimitValue { nodes: (a,) })) } +#[trace] pub fn reject_limit_value(s: Span) -> IResult { let (s, a) = limit_value(s)?; Ok((s, RejectLimitValue { nodes: (a,) })) } +#[trace] pub fn limit_value(s: Span) -> IResult { let (s, a) = constant_mintypmax_expression(s)?; Ok((s, LimitValue { nodes: (a,) })) } +#[trace] pub fn variable_decl_assignment(s: Span) -> IResult { alt(( variable_decl_assignment_variable, @@ -283,6 +296,7 @@ pub fn variable_decl_assignment(s: Span) -> IResult IResult { let (s, a) = variable_identifier(s)?; let (s, b) = many0(variable_dimension)(s)?; @@ -293,6 +307,7 @@ pub fn variable_decl_assignment_variable(s: Span) -> IResult IResult { let (s, a) = dynamic_array_variable_identifier(s)?; let (s, b) = unsized_dimension(s)?; @@ -306,6 +321,7 @@ pub fn variable_decl_assignment_dynamic_array(s: Span) -> IResult IResult { let (s, a) = class_variable_identifier(s)?; let (s, b) = opt(pair(symbol("="), class_new))(s)?; @@ -315,10 +331,12 @@ pub fn variable_decl_assignment_class(s: Span) -> IResult IResult { alt((class_new_argument, class_new_expression))(s) } +#[trace] pub fn class_new_argument(s: Span) -> IResult { let (s, a) = opt(class_scope)(s)?; let (s, b) = symbol("new")(s)?; @@ -326,6 +344,7 @@ pub fn class_new_argument(s: Span) -> IResult { Ok((s, ClassNew::Argument(ClassNewArgument { nodes: (a, b, c) }))) } +#[trace] pub fn class_new_expression(s: Span) -> IResult { let (s, a) = symbol("new")(s)?; let (s, b) = expression(s)?; @@ -335,6 +354,7 @@ pub fn class_new_expression(s: Span) -> IResult { )) } +#[trace] pub fn dynamic_array_new(s: Span) -> IResult { let (s, a) = symbol("new")(s)?; let (s, b) = bracket(expression)(s)?; diff --git a/src/parser/declarations/declaration_lists.rs b/src/parser/declarations/declaration_lists.rs index bda9e77..9c956f0 100644 --- a/src/parser/declarations/declaration_lists.rs +++ b/src/parser/declarations/declaration_lists.rs @@ -92,16 +92,19 @@ pub struct ListOfVariablePortIdentifiers<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn list_of_defparam_assignments(s: Span) -> IResult { let (s, a) = list(symbol(","), defparam_assignment)(s)?; Ok((s, ListOfDefparamAssignments { nodes: (a,) })) } +#[trace] pub fn list_of_genvar_identifiers(s: Span) -> IResult { let (s, a) = list(symbol(","), genvar_identifier)(s)?; Ok((s, ListOfGenvarIdentifiers { nodes: (a,) })) } +#[trace] pub fn list_of_interface_identifiers(s: Span) -> IResult { let (s, a) = list( symbol(","), @@ -110,16 +113,19 @@ pub fn list_of_interface_identifiers(s: Span) -> IResult IResult { let (s, a) = list(symbol(","), net_decl_assignment)(s)?; Ok((s, ListOfNetDeclAssignments { nodes: (a,) })) } +#[trace] pub fn list_of_param_assignments(s: Span) -> IResult { let (s, a) = list(symbol(","), param_assignment)(s)?; Ok((s, ListOfParamAssignments { nodes: (a,) })) } +#[trace] pub fn list_of_port_identifiers(s: Span) -> IResult { let (s, a) = list( symbol(","), @@ -128,16 +134,19 @@ pub fn list_of_port_identifiers(s: Span) -> IResult Ok((s, ListOfPortIdentifiers { nodes: (a,) })) } +#[trace] pub fn list_of_udp_port_identifiers(s: Span) -> IResult { let (s, a) = list(symbol(","), port_identifier)(s)?; Ok((s, ListOfUdpPortIdentifiers { nodes: (a,) })) } +#[trace] pub fn list_of_specparam_assignments(s: Span) -> IResult { let (s, a) = list(symbol(","), specparam_assignment)(s)?; Ok((s, ListOfSpecparamAssignments { nodes: (a,) })) } +#[trace] pub fn list_of_tf_variable_identifiers(s: Span) -> IResult { let (s, a) = list( symbol(","), @@ -150,16 +159,19 @@ pub fn list_of_tf_variable_identifiers(s: Span) -> IResult IResult { let (s, a) = list(symbol(","), type_assignment)(s)?; Ok((s, ListOfTypeAssignments { nodes: (a,) })) } +#[trace] pub fn list_of_variable_decl_assignments(s: Span) -> IResult { let (s, a) = list(symbol(","), variable_decl_assignment)(s)?; Ok((s, ListOfVariableDeclAssignments { nodes: (a,) })) } +#[trace] pub fn list_of_variable_identifiers(s: Span) -> IResult { let (s, a) = list( symbol(","), @@ -168,6 +180,7 @@ pub fn list_of_variable_identifiers(s: Span) -> IResult IResult { let (s, a) = list( symbol(","), diff --git a/src/parser/declarations/declaration_ranges.rs b/src/parser/declarations/declaration_ranges.rs index de78303..2defeb0 100644 --- a/src/parser/declarations/declaration_ranges.rs +++ b/src/parser/declarations/declaration_ranges.rs @@ -70,10 +70,12 @@ pub struct UnsizedDimension<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn unpacked_dimension(s: Span) -> IResult { alt((unpacked_dimension_range, unpacked_dimension_expression))(s) } +#[trace] pub fn unpacked_dimension_range(s: Span) -> IResult { let (s, a) = bracket(constant_range)(s)?; Ok(( @@ -82,6 +84,7 @@ pub fn unpacked_dimension_range(s: Span) -> IResult { )) } +#[trace] pub fn unpacked_dimension_expression(s: Span) -> IResult { let (s, a) = bracket(constant_expression)(s)?; Ok(( @@ -90,6 +93,7 @@ pub fn unpacked_dimension_expression(s: Span) -> IResult IResult { alt(( packed_dimension_range, @@ -97,6 +101,7 @@ pub fn packed_dimension(s: Span) -> IResult { ))(s) } +#[trace] pub fn packed_dimension_range(s: Span) -> IResult { let (s, a) = bracket(constant_range)(s)?; Ok(( @@ -105,6 +110,7 @@ pub fn packed_dimension_range(s: Span) -> IResult { )) } +#[trace] pub fn associative_dimension(s: Span) -> IResult { alt(( associative_dimension_data_type, @@ -112,6 +118,7 @@ pub fn associative_dimension(s: Span) -> IResult { ))(s) } +#[trace] pub fn associative_dimension_data_type(s: Span) -> IResult { let (s, a) = bracket(data_type)(s)?; Ok(( @@ -120,6 +127,7 @@ pub fn associative_dimension_data_type(s: Span) -> IResult IResult { let (s, a) = bracket(symbol("*"))(s)?; Ok(( @@ -128,6 +136,7 @@ pub fn associative_dimension_asterisk(s: Span) -> IResult IResult { alt(( map(unsized_dimension, |x| { @@ -143,6 +152,7 @@ pub fn variable_dimension(s: Span) -> IResult { ))(s) } +#[trace] pub fn queue_dimension(s: Span) -> IResult { let (s, a) = bracket(pair( symbol("$"), @@ -151,6 +161,7 @@ pub fn queue_dimension(s: Span) -> IResult { Ok((s, QueueDimension { nodes: (a,) })) } +#[trace] pub fn unsized_dimension(s: Span) -> IResult { let (s, a) = symbol("[")(s)?; let (s, b) = symbol("]")(s)?; diff --git a/src/parser/declarations/delays.rs b/src/parser/declarations/delays.rs index 9d68b8b..e031771 100644 --- a/src/parser/declarations/delays.rs +++ b/src/parser/declarations/delays.rs @@ -72,16 +72,19 @@ pub enum DelayValue<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn delay3(s: Span) -> IResult { alt((delay3_single, delay3_mintypmax))(s) } +#[trace] pub fn delay3_single(s: Span) -> IResult { let (s, a) = symbol("#")(s)?; let (s, b) = delay_value(s)?; Ok((s, Delay3::Single(Delay3Single { nodes: (a, b) }))) } +#[trace] pub fn delay3_mintypmax(s: Span) -> IResult { let (s, a) = symbol("#")(s)?; let (s, b) = paren(pair( @@ -95,16 +98,19 @@ pub fn delay3_mintypmax(s: Span) -> IResult { Ok((s, Delay3::Mintypmax(Delay3Mintypmax { nodes: (a, b) }))) } +#[trace] pub fn delay2(s: Span) -> IResult { alt((delay2_single, delay2_mintypmax))(s) } +#[trace] pub fn delay2_single(s: Span) -> IResult { let (s, a) = symbol("#")(s)?; let (s, b) = delay_value(s)?; Ok((s, Delay2::Single(Delay2Single { nodes: (a, b) }))) } +#[trace] pub fn delay2_mintypmax(s: Span) -> IResult { let (s, a) = symbol("#")(s)?; let (s, b) = paren(pair( @@ -114,6 +120,7 @@ pub fn delay2_mintypmax(s: Span) -> IResult { Ok((s, Delay2::Mintypmax(Delay2Mintypmax { nodes: (a, b) }))) } +#[trace] pub fn delay_value(s: Span) -> IResult { alt(( map(unsigned_number, |x| DelayValue::UnsignedNumber(x)), diff --git a/src/parser/declarations/function_declarations.rs b/src/parser/declarations/function_declarations.rs index 126d938..418c7df 100644 --- a/src/parser/declarations/function_declarations.rs +++ b/src/parser/declarations/function_declarations.rs @@ -159,6 +159,7 @@ pub struct DpiTaskProto<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn function_data_type_or_implicit(s: Span) -> IResult { alt(( map(data_type_or_void, |x| { @@ -170,6 +171,7 @@ pub fn function_data_type_or_implicit(s: Span) -> IResult IResult { let (s, a) = symbol("function")(s)?; let (s, b) = opt(lifetime)(s)?; @@ -177,6 +179,7 @@ pub fn function_declaration(s: Span) -> IResult { Ok((s, FunctionDeclaration { nodes: (a, b, c) })) } +#[trace] pub fn function_body_declaration(s: Span) -> IResult { alt(( function_body_declaration_without_port, @@ -184,6 +187,7 @@ pub fn function_body_declaration(s: Span) -> IResult IResult { let (s, a) = function_data_type_or_implicit(s)?; let (s, b) = opt(interface_identifier_or_class_scope)(s)?; @@ -201,6 +205,7 @@ pub fn function_body_declaration_without_port(s: Span) -> IResult IResult { let (s, a) = function_data_type_or_implicit(s)?; let (s, b) = opt(interface_identifier_or_class_scope)(s)?; @@ -219,6 +224,7 @@ pub fn function_body_declaration_with_port(s: Span) -> IResult IResult { @@ -232,6 +238,7 @@ pub fn interface_identifier_or_class_scope( ))(s) } +#[trace] pub fn function_prototype(s: Span) -> IResult { let (s, a) = symbol("function")(s)?; let (s, b) = data_type_or_void(s)?; @@ -245,6 +252,7 @@ pub fn function_prototype(s: Span) -> IResult { )) } +#[trace] pub fn dpi_import_export(s: Span) -> IResult { alt(( dpi_import_export_import_function, @@ -254,6 +262,7 @@ pub fn dpi_import_export(s: Span) -> IResult { ))(s) } +#[trace] pub fn dpi_import_export_import_function(s: Span) -> IResult { let (s, a) = symbol("import")(s)?; let (s, b) = dpi_spec_string(s)?; @@ -269,6 +278,7 @@ pub fn dpi_import_export_import_function(s: Span) -> IResult IResult { let (s, a) = symbol("import")(s)?; let (s, b) = dpi_spec_string(s)?; @@ -284,6 +294,7 @@ pub fn dpi_import_export_import_task(s: Span) -> IResult )) } +#[trace] pub fn dpi_import_export_export_function(s: Span) -> IResult { let (s, a) = symbol("export")(s)?; let (s, b) = dpi_spec_string(s)?; @@ -299,6 +310,7 @@ pub fn dpi_import_export_export_function(s: Span) -> IResult IResult { let (s, a) = symbol("export")(s)?; let (s, b) = dpi_spec_string(s)?; @@ -314,6 +326,7 @@ pub fn dpi_import_export_export_task(s: Span) -> IResult )) } +#[trace] pub fn dpi_spec_string(s: Span) -> IResult { alt(( map(symbol("DPI-C"), |x| DpiSpecString::DpiC(x)), @@ -321,6 +334,7 @@ pub fn dpi_spec_string(s: Span) -> IResult { ))(s) } +#[trace] pub fn dpi_function_import_property(s: Span) -> IResult { alt(( map(symbol("context"), |x| DpiFunctionImportProperty::Context(x)), @@ -328,16 +342,19 @@ pub fn dpi_function_import_property(s: Span) -> IResult IResult { let (s, a) = symbol("context")(s)?; Ok((s, DpiTaskImportProperty::Context(a))) } +#[trace] pub fn dpi_function_proto(s: Span) -> IResult { let (s, a) = function_prototype(s)?; Ok((s, DpiFunctionProto { nodes: (a,) })) } +#[trace] pub fn dpi_task_proto(s: Span) -> IResult { let (s, a) = task_prototype(s)?; Ok((s, DpiTaskProto { nodes: (a,) })) diff --git a/src/parser/declarations/interface_declarations.rs b/src/parser/declarations/interface_declarations.rs index 70da10d..642baf3 100644 --- a/src/parser/declarations/interface_declarations.rs +++ b/src/parser/declarations/interface_declarations.rs @@ -94,6 +94,7 @@ pub enum ImportExport<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn modport_declaration(s: Span) -> IResult { let (s, a) = symbol("modport")(s)?; let (s, b) = list(symbol(","), modport_item)(s)?; @@ -101,12 +102,14 @@ pub fn modport_declaration(s: Span) -> IResult { Ok((s, ModportDeclaration { nodes: (a, b, c) })) } +#[trace] pub fn modport_item(s: Span) -> IResult { let (s, a) = modport_identifier(s)?; let (s, b) = paren(list(symbol(","), modport_ports_declaration))(s)?; Ok((s, ModportItem { nodes: (a, b) })) } +#[trace] pub fn modport_ports_declaration(s: Span) -> IResult { alt(( modport_ports_declaration_simple, @@ -115,6 +118,7 @@ pub fn modport_ports_declaration(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = modport_simple_ports_declaration(s)?; @@ -124,6 +128,7 @@ pub fn modport_ports_declaration_simple(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = modport_tf_ports_declaration(s)?; @@ -133,6 +138,7 @@ pub fn modport_ports_declaration_tf(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = modport_clocking_declaration(s)?; @@ -142,22 +148,26 @@ pub fn modport_ports_declaration_clocking(s: Span) -> IResult IResult { let (s, a) = symbol("clocking")(s)?; let (s, b) = clocking_identifier(s)?; Ok((s, ModportClockingDeclaration { nodes: (a, b) })) } +#[trace] pub fn modport_simple_ports_declaration(s: Span) -> IResult { let (s, a) = port_direction(s)?; let (s, b) = list(symbol(","), modport_simple_port)(s)?; Ok((s, ModportSimplePortsDeclaration { nodes: (a, b) })) } +#[trace] pub fn modport_simple_port(s: Span) -> IResult { alt((modport_simple_port_ordered, modport_simple_port_named))(s) } +#[trace] pub fn modport_simple_port_ordered(s: Span) -> IResult { let (s, a) = port_identifier(s)?; Ok(( @@ -166,6 +176,7 @@ pub fn modport_simple_port_ordered(s: Span) -> IResult )) } +#[trace] pub fn modport_simple_port_named(s: Span) -> IResult { let (s, a) = symbol(".")(s)?; let (s, b) = port_identifier(s)?; @@ -176,12 +187,14 @@ pub fn modport_simple_port_named(s: Span) -> IResult { )) } +#[trace] pub fn modport_tf_ports_declaration(s: Span) -> IResult { let (s, a) = import_export(s)?; let (s, b) = list(symbol(","), modport_tf_port)(s)?; Ok((s, ModportTfPortsDeclaration { nodes: (a, b) })) } +#[trace] pub fn modport_tf_port(s: Span) -> IResult { alt(( map(method_prototype, |x| ModportTfPort::MethodPrototype(x)), @@ -189,6 +202,7 @@ pub fn modport_tf_port(s: Span) -> IResult { ))(s) } +#[trace] pub fn import_export(s: Span) -> IResult { alt(( map(symbol("import"), |x| ImportExport::Import(x)), diff --git a/src/parser/declarations/let_declarations.rs b/src/parser/declarations/let_declarations.rs index 31802c7..cb5c5ab 100644 --- a/src/parser/declarations/let_declarations.rs +++ b/src/parser/declarations/let_declarations.rs @@ -96,6 +96,7 @@ pub struct LetActualArg<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn let_declaration(s: Span) -> IResult { let (s, a) = symbol("let")(s)?; let (s, b) = let_identifier(s)?; @@ -111,16 +112,19 @@ pub fn let_declaration(s: Span) -> IResult { )) } +#[trace] pub fn let_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, LetIdentifier { nodes: (a,) })) } +#[trace] pub fn let_port_list(s: Span) -> IResult { let (s, a) = list(symbol(","), let_port_item)(s)?; Ok((s, LetPortList { nodes: (a,) })) } +#[trace] pub fn let_port_item(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = let_formal_type(s)?; @@ -135,6 +139,7 @@ pub fn let_port_item(s: Span) -> IResult { )) } +#[trace] pub fn let_formal_type(s: Span) -> IResult { alt(( map(data_type_or_implicit, |x| { @@ -144,6 +149,7 @@ pub fn let_formal_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn let_expression(s: Span) -> IResult { let (s, a) = opt(package_scope)(s)?; let (s, b) = let_identifier(s)?; @@ -151,10 +157,12 @@ pub fn let_expression(s: Span) -> IResult { Ok((s, LetExpression { nodes: (a, b, c) })) } +#[trace] pub fn let_list_of_arguments(s: Span) -> IResult { alt((let_list_of_arguments_ordered, let_list_of_arguments_named))(s) } +#[trace] pub fn let_list_of_arguments_ordered(s: Span) -> IResult { let (s, a) = list(symbol(","), opt(let_actual_arg))(s)?; let (s, b) = many0(tuple(( @@ -169,6 +177,7 @@ pub fn let_list_of_arguments_ordered(s: Span) -> IResult IResult { let (s, a) = list( symbol(","), @@ -180,6 +189,7 @@ pub fn let_list_of_arguments_named(s: Span) -> IResult )) } +#[trace] pub fn let_actual_arg(s: Span) -> IResult { let (s, a) = expression(s)?; Ok((s, LetActualArg { nodes: (a,) })) diff --git a/src/parser/declarations/module_parameter_declarations.rs b/src/parser/declarations/module_parameter_declarations.rs index 22adadd..ab70508 100644 --- a/src/parser/declarations/module_parameter_declarations.rs +++ b/src/parser/declarations/module_parameter_declarations.rs @@ -58,6 +58,7 @@ pub struct SpecparamDeclaration<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn local_parameter_declaration(s: Span) -> IResult { alt(( local_parameter_declaration_param, @@ -65,6 +66,7 @@ pub fn local_parameter_declaration(s: Span) -> IResult IResult { let (s, a) = symbol("localparam")(s)?; let (s, b) = data_type_or_implicit(s)?; @@ -75,6 +77,7 @@ pub fn local_parameter_declaration_param(s: Span) -> IResult IResult { let (s, a) = symbol("localparam")(s)?; let (s, b) = symbol("type")(s)?; @@ -85,10 +88,12 @@ pub fn local_parameter_declaration_type(s: Span) -> IResult IResult { alt((parameter_declaration_param, parameter_declaration_type))(s) } +#[trace] pub fn parameter_declaration_param(s: Span) -> IResult { let (s, a) = symbol("parameter")(s)?; let (s, b) = data_type_or_implicit(s)?; @@ -99,6 +104,7 @@ pub fn parameter_declaration_param(s: Span) -> IResult IResult { let (s, a) = symbol("parameter")(s)?; let (s, b) = symbol("type")(s)?; @@ -109,6 +115,7 @@ pub fn parameter_declaration_type(s: Span) -> IResult IResult { let (s, a) = symbol("specparam")(s)?; let (s, b) = opt(packed_dimension)(s)?; diff --git a/src/parser/declarations/net_and_variable_types.rs b/src/parser/declarations/net_and_variable_types.rs index 8dea00d..8a04ce5 100644 --- a/src/parser/declarations/net_and_variable_types.rs +++ b/src/parser/declarations/net_and_variable_types.rs @@ -297,6 +297,7 @@ pub struct TypeReferenceDataType<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn casting_type(s: Span) -> IResult { alt(( map(simple_type, |x| CastingType::SimpleType(Box::new(x))), @@ -309,6 +310,7 @@ pub fn casting_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn data_type(s: Span) -> IResult { alt(( data_type_vector, @@ -329,6 +331,7 @@ pub fn data_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn data_type_vector(s: Span) -> IResult { let (s, a) = integer_vector_type(s)?; let (s, b) = opt(signing)(s)?; @@ -336,12 +339,14 @@ pub fn data_type_vector(s: Span) -> IResult { Ok((s, DataType::Vector(DataTypeVector { nodes: (a, b, c) }))) } +#[trace] pub fn data_type_atom(s: Span) -> IResult { let (s, a) = integer_atom_type(s)?; let (s, b) = opt(signing)(s)?; Ok((s, DataType::Atom(DataTypeAtom { nodes: (a, b) }))) } +#[trace] pub fn data_type_union(s: Span) -> IResult { let (s, a) = struct_union(s)?; let (s, b) = opt(pair(packed, opt(signing)))(s)?; @@ -355,11 +360,13 @@ pub fn data_type_union(s: Span) -> IResult { )) } +#[trace] pub fn packed(s: Span) -> IResult { let (s, a) = symbol("packed")(s)?; Ok((s, Packed { nodes: (a,) })) } +#[trace] pub fn data_type_enum(s: Span) -> IResult { let (s, a) = symbol("enum")(s)?; let (s, b) = opt(enum_base_type)(s)?; @@ -373,6 +380,7 @@ pub fn data_type_enum(s: Span) -> IResult { )) } +#[trace] pub fn data_type_virtual(s: Span) -> IResult { let (s, a) = symbol("virtual")(s)?; let (s, b) = opt(interface)(s)?; @@ -387,11 +395,13 @@ pub fn data_type_virtual(s: Span) -> IResult { )) } +#[trace] pub fn interface(s: Span) -> IResult { let (s, a) = symbol("interface")(s)?; Ok((s, Interface { nodes: (a,) })) } +#[trace] pub fn data_type_type(s: Span) -> IResult { let (s, a) = opt(package_scope_or_class_scope)(s)?; let (s, b) = type_identifier(s)?; @@ -399,6 +409,7 @@ pub fn data_type_type(s: Span) -> IResult { Ok((s, DataType::Type(DataTypeType { nodes: (a, b, c) }))) } +#[trace] pub fn data_type_or_implicit(s: Span) -> IResult { alt(( map(data_type, |x| DataTypeOrImplicit::DataType(x)), @@ -408,12 +419,14 @@ pub fn data_type_or_implicit(s: Span) -> IResult { ))(s) } +#[trace] pub fn implicit_data_type(s: Span) -> IResult { let (s, a) = opt(signing)(s)?; let (s, b) = many0(packed_dimension)(s)?; Ok((s, ImplicitDataType { nodes: (a, b) })) } +#[trace] pub fn enum_base_type(s: Span) -> IResult { alt(( enum_base_type_atom, @@ -422,12 +435,14 @@ pub fn enum_base_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn enum_base_type_atom(s: Span) -> IResult { let (s, a) = integer_atom_type(s)?; let (s, b) = opt(signing)(s)?; Ok((s, EnumBaseType::Atom(EnumBaseTypeAtom { nodes: (a, b) }))) } +#[trace] pub fn enum_base_type_vector(s: Span) -> IResult { let (s, a) = integer_vector_type(s)?; let (s, b) = opt(signing)(s)?; @@ -438,12 +453,14 @@ pub fn enum_base_type_vector(s: Span) -> IResult { )) } +#[trace] pub fn enum_base_type_type(s: Span) -> IResult { let (s, a) = type_identifier(s)?; let (s, b) = opt(packed_dimension)(s)?; Ok((s, EnumBaseType::Type(EnumBaseTypeType { nodes: (a, b) }))) } +#[trace] pub fn enum_name_declaration(s: Span) -> IResult { let (s, a) = enum_identifier(s)?; let (s, b) = opt(bracket(pair( @@ -454,12 +471,14 @@ pub fn enum_name_declaration(s: Span) -> IResult { Ok((s, EnumNameDeclaration { nodes: (a, b, c) })) } +#[trace] pub fn class_scope(s: Span) -> IResult { let (s, a) = class_type(s)?; let (s, b) = symbol("::")(s)?; Ok((s, ClassScope { nodes: (a, b) })) } +#[trace] pub fn class_type(s: Span) -> IResult { let (s, a) = ps_class_identifier(s)?; let (s, b) = opt(parameter_value_assignment)(s)?; @@ -471,6 +490,7 @@ pub fn class_type(s: Span) -> IResult { Ok((s, ClassType { nodes: (a, b, c) })) } +#[trace] pub fn integer_type(s: Span) -> IResult { alt(( map(integer_vector_type, |x| IntegerType::IntegerVectorType(x)), @@ -478,6 +498,7 @@ pub fn integer_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn integer_atom_type(s: Span) -> IResult { alt(( map(symbol("byte"), |x| IntegerAtomType::Byte(x)), @@ -489,6 +510,7 @@ pub fn integer_atom_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn integer_vector_type(s: Span) -> IResult { alt(( map(symbol("bit"), |x| IntegerVectorType::Bit(x)), @@ -497,6 +519,7 @@ pub fn integer_vector_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn non_integer_type(s: Span) -> IResult { alt(( map(symbol("shortreal"), |x| NonIntegerType::Shortreal(x)), @@ -505,6 +528,7 @@ pub fn non_integer_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn net_type(s: Span) -> IResult { alt(( map(symbol("supply0"), |x| NetType::Supply0(x)), @@ -522,6 +546,7 @@ pub fn net_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn net_port_type(s: Span) -> IResult { alt(( net_port_type_data_type, @@ -530,6 +555,7 @@ pub fn net_port_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn net_port_type_data_type(s: Span) -> IResult { let (s, a) = opt(net_type)(s)?; let (s, b) = data_type_or_implicit(s)?; @@ -539,6 +565,7 @@ pub fn net_port_type_data_type(s: Span) -> IResult { )) } +#[trace] pub fn net_port_type_interconnect(s: Span) -> IResult { let (s, a) = symbol("interconnect")(s)?; let (s, b) = implicit_data_type(s)?; @@ -548,11 +575,13 @@ pub fn net_port_type_interconnect(s: Span) -> IResult { )) } +#[trace] pub fn variable_port_type(s: Span) -> IResult { let (s, a) = var_data_type(s)?; Ok((s, VariablePortType { nodes: (a,) })) } +#[trace] pub fn var_data_type(s: Span) -> IResult { alt(( map(data_type, |x| VarDataType::DataType(x)), @@ -560,12 +589,14 @@ pub fn var_data_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn var_data_type_var(s: Span) -> IResult { let (s, a) = symbol("var")(s)?; let (s, b) = data_type_or_implicit(s)?; Ok((s, VarDataType::Var(VarDataTypeVar { nodes: (a, b) }))) } +#[trace] pub fn signing(s: Span) -> IResult { alt(( map(symbol("signed"), |x| Signing::Signed(x)), @@ -573,6 +604,7 @@ pub fn signing(s: Span) -> IResult { ))(s) } +#[trace] pub fn simple_type(s: Span) -> IResult { alt(( map(integer_type, |x| SimpleType::IntegerType(x)), @@ -584,6 +616,7 @@ pub fn simple_type(s: Span) -> IResult { ))(s) } +#[trace] pub fn struct_union_member(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = opt(random_qualifier)(s)?; @@ -598,6 +631,7 @@ pub fn struct_union_member(s: Span) -> IResult { )) } +#[trace] pub fn data_type_or_void(s: Span) -> IResult { alt(( map(data_type, |x| DataTypeOrVoid::DataType(x)), @@ -605,6 +639,7 @@ pub fn data_type_or_void(s: Span) -> IResult { ))(s) } +#[trace] pub fn struct_union(s: Span) -> IResult { alt(( map(symbol("struct"), |x| StructUnion::Struct(x)), @@ -615,10 +650,12 @@ pub fn struct_union(s: Span) -> IResult { ))(s) } +#[trace] pub fn type_reference(s: Span) -> IResult { alt((type_reference_expression, type_reference_data_type))(s) } +#[trace] pub fn type_reference_expression(s: Span) -> IResult { let (s, a) = symbol("type")(s)?; let (s, b) = paren(expression)(s)?; @@ -628,6 +665,7 @@ pub fn type_reference_expression(s: Span) -> IResult { )) } +#[trace] pub fn type_reference_data_type(s: Span) -> IResult { let (s, a) = symbol("type")(s)?; let (s, b) = paren(data_type)(s)?; diff --git a/src/parser/declarations/port_declarations.rs b/src/parser/declarations/port_declarations.rs index 032bb26..53363bf 100644 --- a/src/parser/declarations/port_declarations.rs +++ b/src/parser/declarations/port_declarations.rs @@ -72,6 +72,7 @@ pub struct RefDeclaration<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn inout_declaration(s: Span) -> IResult { let (s, a) = symbol("inout")(s)?; let (s, b) = net_port_type(s)?; @@ -79,10 +80,12 @@ pub fn inout_declaration(s: Span) -> IResult { Ok((s, InoutDeclaration { nodes: (a, b, c) })) } +#[trace] pub fn input_declaration(s: Span) -> IResult { alt((input_declaration_net, input_declaration_variable))(s) } +#[trace] pub fn input_declaration_net(s: Span) -> IResult { let (s, a) = symbol("input")(s)?; let (s, b) = net_port_type(s)?; @@ -93,6 +96,7 @@ pub fn input_declaration_net(s: Span) -> IResult { )) } +#[trace] pub fn input_declaration_variable(s: Span) -> IResult { let (s, a) = symbol("input")(s)?; let (s, b) = variable_port_type(s)?; @@ -103,10 +107,12 @@ pub fn input_declaration_variable(s: Span) -> IResult { )) } +#[trace] pub fn output_declaration(s: Span) -> IResult { alt((output_declaration_net, output_declaration_variable))(s) } +#[trace] pub fn output_declaration_net(s: Span) -> IResult { let (s, a) = symbol("output")(s)?; let (s, b) = net_port_type(s)?; @@ -117,6 +123,7 @@ pub fn output_declaration_net(s: Span) -> IResult { )) } +#[trace] pub fn output_declaration_variable(s: Span) -> IResult { let (s, a) = symbol("output")(s)?; let (s, b) = variable_port_type(s)?; @@ -127,6 +134,7 @@ pub fn output_declaration_variable(s: Span) -> IResult )) } +#[trace] pub fn interface_port_declaration(s: Span) -> IResult { let (s, a) = interface_identifier(s)?; let (s, b) = opt(pair(symbol("."), modport_identifier))(s)?; @@ -134,6 +142,7 @@ pub fn interface_port_declaration(s: Span) -> IResult IResult { let (s, a) = symbol("ref")(s)?; let (s, b) = variable_port_type(s)?; diff --git a/src/parser/declarations/strengths.rs b/src/parser/declarations/strengths.rs index 36eac62..b704a50 100644 --- a/src/parser/declarations/strengths.rs +++ b/src/parser/declarations/strengths.rs @@ -86,6 +86,7 @@ pub struct ChargeStrengthLarge<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn drive_strength(s: Span) -> IResult { alt(( drive_strength01, @@ -97,6 +98,7 @@ pub fn drive_strength(s: Span) -> IResult { ))(s) } +#[trace] pub fn drive_strength01(s: Span) -> IResult { let (s, a) = paren(triple(strength0, symbol(","), strength1))(s)?; Ok(( @@ -105,6 +107,7 @@ pub fn drive_strength01(s: Span) -> IResult { )) } +#[trace] pub fn drive_strength10(s: Span) -> IResult { let (s, a) = paren(triple(strength1, symbol(","), strength0))(s)?; Ok(( @@ -113,6 +116,7 @@ pub fn drive_strength10(s: Span) -> IResult { )) } +#[trace] pub fn drive_strength0z(s: Span) -> IResult { let (s, a) = paren(triple(strength0, symbol(","), symbol("highz1")))(s)?; Ok(( @@ -121,6 +125,7 @@ pub fn drive_strength0z(s: Span) -> IResult { )) } +#[trace] pub fn drive_strength1z(s: Span) -> IResult { let (s, a) = paren(triple(strength1, symbol(","), symbol("highz0")))(s)?; Ok(( @@ -129,6 +134,7 @@ pub fn drive_strength1z(s: Span) -> IResult { )) } +#[trace] pub fn drive_strengthz1(s: Span) -> IResult { let (s, a) = paren(triple(symbol("highz0"), symbol(","), strength1))(s)?; Ok(( @@ -137,6 +143,7 @@ pub fn drive_strengthz1(s: Span) -> IResult { )) } +#[trace] pub fn drive_strengthz0(s: Span) -> IResult { let (s, a) = paren(triple(symbol("highz1"), symbol(","), strength0))(s)?; Ok(( @@ -145,6 +152,7 @@ pub fn drive_strengthz0(s: Span) -> IResult { )) } +#[trace] pub fn strength0(s: Span) -> IResult { alt(( map(symbol("supply0"), |x| Strength0::Supply0(x)), @@ -154,6 +162,7 @@ pub fn strength0(s: Span) -> IResult { ))(s) } +#[trace] pub fn strength1(s: Span) -> IResult { alt(( map(symbol("supply1"), |x| Strength1::Supply1(x)), @@ -163,6 +172,7 @@ pub fn strength1(s: Span) -> IResult { ))(s) } +#[trace] pub fn charge_strength(s: Span) -> IResult { alt(( charge_strength_small, @@ -171,6 +181,7 @@ pub fn charge_strength(s: Span) -> IResult { ))(s) } +#[trace] pub fn charge_strength_small(s: Span) -> IResult { let (s, a) = paren(symbol("small"))(s)?; Ok(( @@ -179,6 +190,7 @@ pub fn charge_strength_small(s: Span) -> IResult { )) } +#[trace] pub fn charge_strength_medium(s: Span) -> IResult { let (s, a) = paren(symbol("medium"))(s)?; Ok(( @@ -187,6 +199,7 @@ pub fn charge_strength_medium(s: Span) -> IResult { )) } +#[trace] pub fn charge_strength_large(s: Span) -> IResult { let (s, a) = paren(symbol("large"))(s)?; Ok(( diff --git a/src/parser/declarations/task_declarations.rs b/src/parser/declarations/task_declarations.rs index a668c25..7359fa3 100644 --- a/src/parser/declarations/task_declarations.rs +++ b/src/parser/declarations/task_declarations.rs @@ -101,6 +101,7 @@ pub struct TaskPrototype<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn task_declaration(s: Span) -> IResult { let (s, a) = symbol("task")(s)?; let (s, b) = opt(lifetime)(s)?; @@ -108,6 +109,7 @@ pub fn task_declaration(s: Span) -> IResult { Ok((s, TaskDeclaration { nodes: (a, b, c) })) } +#[trace] pub fn task_body_declaration(s: Span) -> IResult { alt(( task_body_declaration_without_port, @@ -115,6 +117,7 @@ pub fn task_body_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn task_body_declaration_without_port(s: Span) -> IResult { let (s, a) = opt(interface_identifier_or_class_scope)(s)?; let (s, b) = task_identifier(s)?; @@ -131,6 +134,7 @@ pub fn task_body_declaration_without_port(s: Span) -> IResult IResult { let (s, a) = opt(interface_identifier_or_class_scope)(s)?; let (s, b) = task_identifier(s)?; @@ -148,6 +152,7 @@ pub fn task_body_declaration_with_port(s: Span) -> IResult IResult { alt(( map(block_item_declaration, |x| { @@ -159,11 +164,13 @@ pub fn tf_item_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn tf_port_list(s: Span) -> IResult { let (s, a) = list(symbol(","), tf_port_item)(s)?; Ok((s, TfPortList { nodes: (a,) })) } +#[trace] pub fn tf_port_item(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = opt(tf_port_direction)(s)?; @@ -182,6 +189,7 @@ pub fn tf_port_item(s: Span) -> IResult { )) } +#[trace] pub fn tf_port_direction(s: Span) -> IResult { alt(( map(port_direction, |x| TfPortDirection::PortDirection(x)), @@ -191,6 +199,7 @@ pub fn tf_port_direction(s: Span) -> IResult { ))(s) } +#[trace] pub fn tf_port_declaration(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = tf_port_direction(s)?; @@ -206,6 +215,7 @@ pub fn tf_port_declaration(s: Span) -> IResult { )) } +#[trace] pub fn task_prototype(s: Span) -> IResult { let (s, a) = symbol("task")(s)?; let (s, b) = task_identifier(s)?; diff --git a/src/parser/declarations/type_declarations.rs b/src/parser/declarations/type_declarations.rs index adb5c30..dcb1102 100644 --- a/src/parser/declarations/type_declarations.rs +++ b/src/parser/declarations/type_declarations.rs @@ -228,6 +228,7 @@ pub enum Lifetime<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn data_declaration(s: Span) -> IResult { alt(( data_declaration_variable, @@ -241,6 +242,7 @@ pub fn data_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn data_declaration_variable(s: Span) -> IResult { let (s, a) = opt(r#const)(s)?; let (s, b) = opt(var)(s)?; @@ -256,11 +258,13 @@ pub fn data_declaration_variable(s: Span) -> IResult { )) } +#[trace] pub fn r#const(s: Span) -> IResult { let (s, a) = symbol("const")(s)?; Ok((s, Const { nodes: (a,) })) } +#[trace] pub fn package_import_declaration(s: Span) -> IResult { let (s, a) = symbol("import")(s)?; let (s, b) = list(symbol(","), package_import_item)(s)?; @@ -268,10 +272,12 @@ pub fn package_import_declaration(s: Span) -> IResult IResult { alt((package_import_item_identifier, package_import_item_asterisk))(s) } +#[trace] pub fn package_import_item_identifier(s: Span) -> IResult { let (s, a) = package_identifier(s)?; let (s, b) = symbol("::")(s)?; @@ -282,6 +288,7 @@ pub fn package_import_item_identifier(s: Span) -> IResult IResult { let (s, a) = package_identifier(s)?; let (s, b) = symbol("::")(s)?; @@ -292,6 +299,7 @@ pub fn package_import_item_asterisk(s: Span) -> IResult )) } +#[trace] pub fn package_export_declaration(s: Span) -> IResult { alt(( package_export_declaration_asterisk, @@ -299,6 +307,7 @@ pub fn package_export_declaration(s: Span) -> IResult IResult { let (s, a) = symbol("export")(s)?; let (s, b) = symbol("*::*")(s)?; @@ -309,6 +318,7 @@ pub fn package_export_declaration_asterisk(s: Span) -> IResult IResult { let (s, a) = symbol("export")(s)?; let (s, b) = list(symbol(","), package_import_item)(s)?; @@ -319,6 +329,7 @@ pub fn package_export_declaration_item(s: Span) -> IResult IResult { let (s, a) = symbol("genvar")(s)?; let (s, b) = list_of_genvar_identifiers(s)?; @@ -326,6 +337,7 @@ pub fn genvar_declaration(s: Span) -> IResult { Ok((s, GenvarDeclaration { nodes: (a, b, c) })) } +#[trace] pub fn net_declaration(s: Span) -> IResult { alt(( net_declaration_net_type, @@ -334,6 +346,7 @@ pub fn net_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn net_declaration_net_type(s: Span) -> IResult { let (s, a) = net_type(s)?; let (s, b) = opt(strength)(s)?; @@ -350,6 +363,7 @@ pub fn net_declaration_net_type(s: Span) -> IResult { )) } +#[trace] pub fn strength(s: Span) -> IResult { alt(( map(drive_strength, |x| Strength::Drive(x)), @@ -357,6 +371,7 @@ pub fn strength(s: Span) -> IResult { ))(s) } +#[trace] pub fn vector_scalar(s: Span) -> IResult { alt(( map(symbol("vectored"), |x| VectorScalar::Vectored(x)), @@ -364,6 +379,7 @@ pub fn vector_scalar(s: Span) -> IResult { ))(s) } +#[trace] pub fn net_declaration_net_type_identifier(s: Span) -> IResult { let (s, a) = net_type_identifier(s)?; let (s, b) = opt(delay_control)(s)?; @@ -377,6 +393,7 @@ pub fn net_declaration_net_type_identifier(s: Span) -> IResult IResult { let (s, a) = symbol("interconnect")(s)?; let (s, b) = implicit_data_type(s)?; @@ -397,6 +414,7 @@ pub fn net_declaration_interconnect(s: Span) -> IResult { )) } +#[trace] pub fn type_declaration(s: Span) -> IResult { alt(( type_declaration_data_type, @@ -405,6 +423,7 @@ pub fn type_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn type_declaration_data_type(s: Span) -> IResult { let (s, a) = symbol("typedef")(s)?; let (s, b) = data_type(s)?; @@ -419,6 +438,7 @@ pub fn type_declaration_data_type(s: Span) -> IResult { )) } +#[trace] pub fn type_declaration_interface(s: Span) -> IResult { let (s, a) = symbol("typedef")(s)?; let (s, b) = interface_instance_identifier(s)?; @@ -435,6 +455,7 @@ pub fn type_declaration_interface(s: Span) -> IResult { )) } +#[trace] pub fn type_declaration_reserved(s: Span) -> IResult { let (s, a) = symbol("typedef")(s)?; let (s, b) = type_declaration_keyword(s)?; @@ -448,6 +469,7 @@ pub fn type_declaration_reserved(s: Span) -> IResult { )) } +#[trace] pub fn type_declaration_keyword(s: Span) -> IResult { alt(( map(symbol("enum"), |x| TypeDeclarationKeyword::Enum(x)), @@ -460,6 +482,7 @@ pub fn type_declaration_keyword(s: Span) -> IResult IResult { alt(( net_type_declaration_data_type, @@ -467,6 +490,7 @@ pub fn net_type_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn net_type_declaration_data_type(s: Span) -> IResult { let (s, a) = symbol("nettype")(s)?; let (s, b) = data_type(s)?; @@ -485,6 +509,7 @@ pub fn net_type_declaration_data_type(s: Span) -> IResult IResult { let (s, a) = symbol("nettype")(s)?; let (s, b) = opt(package_scope_or_class_scope)(s)?; @@ -499,6 +524,7 @@ pub fn net_type_declaration_net_type(s: Span) -> IResult IResult { alt(( map(symbol("static"), |x| Lifetime::Static(x)), diff --git a/src/parser/expressions/concatenations.rs b/src/parser/expressions/concatenations.rs index b57a765..27e8bc4 100644 --- a/src/parser/expressions/concatenations.rs +++ b/src/parser/expressions/concatenations.rs @@ -105,26 +105,31 @@ pub struct EmptyUnpackedArrayConcatenation<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn concatenation(s: Span) -> IResult { let (s, a) = brace(list(symbol(","), expression))(s)?; Ok((s, Concatenation { nodes: (a,) })) } +#[trace] pub fn constant_concatenation(s: Span) -> IResult { let (s, a) = brace(list(symbol(","), constant_expression))(s)?; Ok((s, ConstantConcatenation { nodes: (a,) })) } +#[trace] pub fn constant_multiple_concatenation(s: Span) -> IResult { let (s, a) = brace(pair(constant_expression, constant_concatenation))(s)?; Ok((s, ConstantMultipleConcatenation { nodes: (a,) })) } +#[trace] pub fn module_path_concatenation(s: Span) -> IResult { let (s, a) = brace(list(symbol(","), module_path_expression))(s)?; Ok((s, ModulePathConcatenation { nodes: (a,) })) } +#[trace] pub fn module_path_multiple_concatenation( s: Span, ) -> IResult { @@ -132,11 +137,13 @@ pub fn module_path_multiple_concatenation( Ok((s, ModulePathMultipleConcatenation { nodes: (a,) })) } +#[trace] pub fn multiple_concatenation(s: Span) -> IResult { let (s, a) = brace(pair(expression, concatenation))(s)?; Ok((s, MultipleConcatenation { nodes: (a,) })) } +#[trace] pub fn streaming_concatenation(s: Span) -> IResult { let (s, a) = brace(triple( stream_operator, @@ -146,6 +153,7 @@ pub fn streaming_concatenation(s: Span) -> IResult Ok((s, StreamingConcatenation { nodes: (a,) })) } +#[trace] pub fn stream_operator(s: Span) -> IResult { alt(( map(symbol(">>"), |x| StreamOperator { nodes: (x,) }), @@ -153,6 +161,7 @@ pub fn stream_operator(s: Span) -> IResult { ))(s) } +#[trace] pub fn slice_size(s: Span) -> IResult { alt(( map(simple_type, |x| SliceSize::SimpleType(x)), @@ -160,17 +169,20 @@ pub fn slice_size(s: Span) -> IResult { ))(s) } +#[trace] pub fn stream_concatenation(s: Span) -> IResult { let (s, a) = brace(list(symbol(","), stream_expression))(s)?; Ok((s, StreamConcatenation { nodes: (a,) })) } +#[trace] pub fn stream_expression(s: Span) -> IResult { let (s, a) = expression(s)?; let (s, b) = opt(pair(symbol("with"), bracket(array_range_expression)))(s)?; Ok((s, StreamExpression { nodes: (a, b) })) } +#[trace] pub fn array_range_expression(s: Span) -> IResult { alt(( map(expression, |x| ArrayRangeExpression::Expression(x)), @@ -180,6 +192,7 @@ pub fn array_range_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn array_range_expression_colon(s: Span) -> IResult { let (s, a) = expression(s)?; let (s, b) = symbol(":")(s)?; @@ -190,6 +203,7 @@ pub fn array_range_expression_colon(s: Span) -> IResult IResult { let (s, a) = expression(s)?; let (s, b) = symbol("+:")(s)?; @@ -200,6 +214,7 @@ pub fn array_range_expression_plus_colon(s: Span) -> IResult IResult { let (s, a) = expression(s)?; let (s, b) = symbol("-:")(s)?; @@ -210,6 +225,7 @@ pub fn array_range_expression_minus_colon(s: Span) -> IResult IResult { diff --git a/src/parser/expressions/expression_leftside_values.rs b/src/parser/expressions/expression_leftside_values.rs index f989810..2e1a3c8 100644 --- a/src/parser/expressions/expression_leftside_values.rs +++ b/src/parser/expressions/expression_leftside_values.rs @@ -72,10 +72,12 @@ pub struct NonrangeVariableLvalue<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn net_lvalue(s: Span) -> IResult { alt((net_lvalue_identifier, net_lvalue_lvalue, net_lvalue_pattern))(s) } +#[trace] pub fn net_lvalue_identifier(s: Span) -> IResult { let (s, a) = ps_or_hierarchical_net_identifier(s)?; let (s, b) = constant_select(s)?; @@ -85,6 +87,7 @@ pub fn net_lvalue_identifier(s: Span) -> IResult { )) } +#[trace] 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)?; @@ -94,6 +97,7 @@ pub fn net_lvalue_pattern(s: Span) -> IResult { )) } +#[trace] pub fn net_lvalue_lvalue(s: Span) -> IResult { let (s, a) = brace(list(symbol(","), net_lvalue))(s)?; Ok(( @@ -102,6 +106,7 @@ pub fn net_lvalue_lvalue(s: Span) -> IResult { )) } +#[trace] pub fn variable_lvalue(s: Span) -> IResult { alt(( variable_lvalue_identifier, @@ -113,6 +118,7 @@ pub fn variable_lvalue(s: Span) -> IResult { ))(s) } +#[trace] pub fn variable_lvalue_identifier(s: Span) -> IResult { let (s, a) = opt(implicit_class_handle_or_package_scope)(s)?; let (s, b) = hierarchical_variable_identifier(s)?; @@ -123,6 +129,7 @@ pub fn variable_lvalue_identifier(s: Span) -> IResult { )) } +#[trace] pub fn variable_lvalue_pattern(s: Span) -> IResult { let (s, a) = opt(assignment_pattern_expression_type)(s)?; let (s, b) = assignment_pattern_variable_lvalue(s)?; @@ -132,6 +139,7 @@ pub fn variable_lvalue_pattern(s: Span) -> IResult { )) } +#[trace] pub fn variable_lvalue_lvalue(s: Span) -> IResult { let (s, a) = brace(list(symbol(","), variable_lvalue))(s)?; Ok(( @@ -140,6 +148,7 @@ pub fn variable_lvalue_lvalue(s: Span) -> IResult { )) } +#[trace] pub fn nonrange_variable_lvalue(s: Span) -> IResult { let (s, a) = opt(implicit_class_handle_or_package_scope)(s)?; let (s, b) = hierarchical_variable_identifier(s)?; diff --git a/src/parser/expressions/expressions.rs b/src/parser/expressions/expressions.rs index 9396122..43c0bb5 100644 --- a/src/parser/expressions/expressions.rs +++ b/src/parser/expressions/expressions.rs @@ -279,10 +279,12 @@ pub struct GenvarExpression<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn inc_or_dec_expression(s: Span) -> IResult { alt((inc_or_dec_expression_prefix, inc_or_dec_expression_suffix))(s) } +#[trace] pub fn inc_or_dec_expression_prefix(s: Span) -> IResult { let (s, a) = inc_or_dec_operator(s)?; let (s, b) = many0(attribute_instance)(s)?; @@ -293,6 +295,7 @@ pub fn inc_or_dec_expression_prefix(s: Span) -> IResult IResult { let (s, a) = variable_lvalue(s)?; let (s, b) = many0(attribute_instance)(s)?; @@ -303,6 +306,7 @@ pub fn inc_or_dec_expression_suffix(s: Span) -> IResult IResult { let (s, a) = cond_predicate(s)?; let (s, b) = symbol("?")(s)?; @@ -318,6 +322,7 @@ pub fn conditional_expression(s: Span) -> IResult { )) } +#[trace] pub fn constant_expression(s: Span) -> IResult { alt(( map(constant_primary, |x| { @@ -329,6 +334,7 @@ pub fn constant_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn constant_expression_unary(s: Span) -> IResult { let (s, a) = unary_operator(s)?; let (s, b) = many0(attribute_instance)(s)?; @@ -339,6 +345,7 @@ pub fn constant_expression_unary(s: Span) -> IResult { )) } +#[trace] pub fn constant_expression_binary(s: Span) -> IResult { let (s, a) = constant_expression(s)?; let (s, b) = binary_operator(s)?; @@ -352,6 +359,7 @@ pub fn constant_expression_binary(s: Span) -> IResult )) } +#[trace] pub fn constant_expression_ternary(s: Span) -> IResult { let (s, a) = constant_expression(s)?; let (s, b) = symbol("?")(s)?; @@ -367,6 +375,7 @@ pub fn constant_expression_ternary(s: Span) -> IResult )) } +#[trace] pub fn constant_mintypmax_expression(s: Span) -> IResult { alt(( constant_mintypmax_expression_ternary, @@ -376,6 +385,7 @@ pub fn constant_mintypmax_expression(s: Span) -> IResult IResult { @@ -392,6 +402,7 @@ pub fn constant_mintypmax_expression_ternary( )) } +#[trace] pub fn constant_param_expression(s: Span) -> IResult { alt(( map(symbol("$"), |x| ConstantParamExpression::Dollar(x)), @@ -402,6 +413,7 @@ pub fn constant_param_expression(s: Span) -> IResult IResult { alt(( map(symbol("$"), |x| ParamExpression::Dollar(x)), @@ -412,6 +424,7 @@ pub fn param_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn constant_range_expression(s: Span) -> IResult { alt(( map(constant_part_select_range, |x| { @@ -423,6 +436,7 @@ pub fn constant_range_expression(s: Span) -> IResult IResult { alt(( map(constant_range, |x| { @@ -434,6 +448,7 @@ pub fn constant_part_select_range(s: Span) -> IResult IResult { let (s, a) = constant_expression(s)?; let (s, b) = symbol(":")(s)?; @@ -441,6 +456,7 @@ pub fn constant_range(s: Span) -> IResult { Ok((s, ConstantRange { nodes: (a, b, c) })) } +#[trace] pub fn constant_indexed_range(s: Span) -> IResult { let (s, a) = constant_expression(s)?; let (s, b) = alt((symbol("+:"), symbol("-:")))(s)?; @@ -448,6 +464,7 @@ pub fn constant_indexed_range(s: Span) -> IResult { Ok((s, ConstantIndexedRange { nodes: (a, b, c) })) } +#[trace] pub fn expression(s: Span) -> IResult { alt(( map(primary, |x| Expression::Primary(Box::new(x))), @@ -469,6 +486,7 @@ pub fn expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn expression_unary(s: Span) -> IResult { let (s, x) = unary_operator(s)?; let (s, y) = many0(attribute_instance)(s)?; @@ -479,6 +497,7 @@ pub fn expression_unary(s: Span) -> IResult { )) } +#[trace] pub fn expression_operator_assignment(s: Span) -> IResult { let (s, a) = paren(operator_assignment)(s)?; Ok(( @@ -487,6 +506,7 @@ pub fn expression_operator_assignment(s: Span) -> IResult { )) } +#[trace] pub fn expression_binary(s: Span) -> IResult { let (s, a) = expression(s)?; let (s, b) = binary_operator(s)?; @@ -500,6 +520,7 @@ pub fn expression_binary(s: Span) -> IResult { )) } +#[trace] pub fn tagged_union_expression(s: Span) -> IResult { let (s, a) = symbol("tagged")(s)?; let (s, b) = member_identifier(s)?; @@ -507,6 +528,7 @@ pub fn tagged_union_expression(s: Span) -> IResult Ok((s, TaggedUnionExpression { nodes: (a, b, c) })) } +#[trace] pub fn inside_expression(s: Span) -> IResult { let (s, a) = expression(s)?; let (s, b) = symbol("inside")(s)?; @@ -514,6 +536,7 @@ pub fn inside_expression(s: Span) -> IResult { Ok((s, InsideExpression { nodes: (a, b, c) })) } +#[trace] pub fn value_range(s: Span) -> IResult { alt(( value_range_binary, @@ -521,11 +544,13 @@ pub fn value_range(s: Span) -> IResult { ))(s) } +#[trace] pub fn value_range_binary(s: Span) -> IResult { let (s, a) = bracket(triple(expression, symbol(":"), expression))(s)?; Ok((s, ValueRange::Binary(ValueRangeBinary { nodes: (a,) }))) } +#[trace] pub fn mintypmax_expression(s: Span) -> IResult { alt(( mintypmax_expression_ternary, @@ -533,6 +558,7 @@ pub fn mintypmax_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn mintypmax_expression_ternary(s: Span) -> IResult { let (s, a) = expression(s)?; let (s, b) = symbol(":")(s)?; @@ -547,6 +573,7 @@ pub fn mintypmax_expression_ternary(s: Span) -> IResult IResult { @@ -564,6 +591,7 @@ pub fn module_path_conditional_expression( )) } +#[trace] pub fn module_path_expression(s: Span) -> IResult { alt(( map(module_path_primary, |x| { @@ -577,6 +605,7 @@ pub fn module_path_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn module_path_expression_unary(s: Span) -> IResult { let (s, a) = unary_module_path_operator(s)?; let (s, b) = many0(attribute_instance)(s)?; @@ -587,6 +616,7 @@ pub fn module_path_expression_unary(s: Span) -> IResult IResult { let (s, a) = module_path_expression(s)?; let (s, b) = binary_module_path_operator(s)?; @@ -600,6 +630,7 @@ pub fn module_path_expression_binary(s: Span) -> IResult IResult { alt(( module_path_mintypmax_expression_ternary, @@ -609,6 +640,7 @@ pub fn module_path_mintypmax_expression(s: Span) -> IResult IResult { @@ -625,6 +657,7 @@ pub fn module_path_mintypmax_expression_ternary( )) } +#[trace] pub fn part_select_range(s: Span) -> IResult { alt(( map(constant_range, |x| PartSelectRange::ConstantRange(x)), @@ -632,6 +665,7 @@ pub fn part_select_range(s: Span) -> IResult { ))(s) } +#[trace] pub fn indexed_range(s: Span) -> IResult { let (s, a) = expression(s)?; let (s, b) = alt((symbol("+:"), symbol("-:")))(s)?; @@ -639,6 +673,7 @@ pub fn indexed_range(s: Span) -> IResult { Ok((s, IndexedRange { nodes: (a, b, c) })) } +#[trace] pub fn genvar_expression(s: Span) -> IResult { let (s, a) = constant_expression(s)?; Ok((s, GenvarExpression { nodes: (a,) })) diff --git a/src/parser/expressions/numbers.rs b/src/parser/expressions/numbers.rs index d1b8b1f..62305fb 100644 --- a/src/parser/expressions/numbers.rs +++ b/src/parser/expressions/numbers.rs @@ -162,6 +162,7 @@ pub struct UnbasedUnsizedLiteral<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn number(s: Span) -> IResult { alt(( map(real_number, |x| Number::RealNumber(x)), @@ -169,6 +170,7 @@ pub fn number(s: Span) -> IResult { ))(s) } +#[trace] pub fn integral_number(s: Span) -> IResult { alt(( map(octal_number, |x| IntegralNumber::OctalNumber(x)), @@ -178,6 +180,7 @@ pub fn integral_number(s: Span) -> IResult { ))(s) } +#[trace] pub fn decimal_number(s: Span) -> IResult { alt(( decimal_number_base_unsigned, @@ -187,6 +190,7 @@ pub fn decimal_number(s: Span) -> IResult { ))(s) } +#[trace] pub fn decimal_number_base_unsigned(s: Span) -> IResult { let (s, a) = opt(size)(s)?; let (s, b) = decimal_base(s)?; @@ -197,6 +201,7 @@ pub fn decimal_number_base_unsigned(s: Span) -> IResult { )) } +#[trace] pub fn decimal_number_base_x_number(s: Span) -> IResult { let (s, a) = opt(size)(s)?; let (s, b) = decimal_base(s)?; @@ -207,6 +212,7 @@ pub fn decimal_number_base_x_number(s: Span) -> IResult { )) } +#[trace] pub fn decimal_number_base_z_number(s: Span) -> IResult { let (s, a) = opt(size)(s)?; let (s, b) = decimal_base(s)?; @@ -217,6 +223,7 @@ pub fn decimal_number_base_z_number(s: Span) -> IResult { )) } +#[trace] pub fn binary_number(s: Span) -> IResult { let (s, a) = opt(size)(s)?; let (s, b) = binary_base(s)?; @@ -224,6 +231,7 @@ pub fn binary_number(s: Span) -> IResult { Ok((s, BinaryNumber { nodes: (a, b, c) })) } +#[trace] pub fn octal_number(s: Span) -> IResult { let (s, a) = opt(size)(s)?; let (s, b) = octal_base(s)?; @@ -231,6 +239,7 @@ pub fn octal_number(s: Span) -> IResult { Ok((s, OctalNumber { nodes: (a, b, c) })) } +#[trace] pub fn hex_number(s: Span) -> IResult { let (s, a) = opt(size)(s)?; let (s, b) = hex_base(s)?; @@ -238,6 +247,7 @@ pub fn hex_number(s: Span) -> IResult { Ok((s, HexNumber { nodes: (a, b, c) })) } +#[trace] pub fn sign(s: Span) -> IResult { alt(( map(symbol("+"), |x| Sign::Plus(x)), @@ -245,16 +255,19 @@ pub fn sign(s: Span) -> IResult { ))(s) } +#[trace] pub fn size(s: Span) -> IResult { let (s, a) = non_zero_unsigned_number(s)?; Ok((s, Size { nodes: (a,) })) } +#[trace] pub fn non_zero_unsigned_number(s: Span) -> IResult { let (s, a) = ws(non_zero_unsigned_number_impl)(s)?; Ok((s, NonZeroUnsignedNumber { nodes: a })) } +#[trace] pub fn non_zero_unsigned_number_impl(s: Span) -> IResult { let (s, a) = is_a("123456789")(s)?; fold_many0(alt((tag("_"), digit1)), a, |acc, item| { @@ -262,6 +275,7 @@ pub fn non_zero_unsigned_number_impl(s: Span) -> IResult { })(s) } +#[trace] pub fn real_number(s: Span) -> IResult { alt(( real_number_floating, @@ -269,6 +283,7 @@ pub fn real_number(s: Span) -> IResult { ))(s) } +#[trace] pub fn real_number_floating(s: Span) -> IResult { let (s, a) = unsigned_number(s)?; let (s, b) = opt(pair(symbol("."), unsigned_number))(s)?; @@ -283,6 +298,7 @@ pub fn real_number_floating(s: Span) -> IResult { )) } +#[trace] pub fn fixed_point_number(s: Span) -> IResult { let (s, a) = unsigned_number(s)?; let (s, b) = map(tag("."), |x| Symbol { nodes: (x, vec![]) })(s)?;; @@ -290,16 +306,19 @@ pub fn fixed_point_number(s: Span) -> IResult { Ok((s, FixedPointNumber { nodes: (a, b, c) })) } +#[trace] pub fn exp(s: Span) -> IResult { let (s, a) = alt((symbol("e"), symbol("E")))(s)?; Ok((s, Exp { nodes: (a,) })) } +#[trace] pub fn unsigned_number(s: Span) -> IResult { let (s, a) = ws(unsigned_number_impl)(s)?; Ok((s, UnsignedNumber { nodes: a })) } +#[trace] pub fn unsigned_number_impl(s: Span) -> IResult { let (s, a) = digit1(s)?; fold_many0(alt((tag("_"), digit1)), a, |acc, item| { @@ -307,11 +326,13 @@ pub fn unsigned_number_impl(s: Span) -> IResult { })(s) } +#[trace] pub fn binary_value(s: Span) -> IResult { let (s, a) = ws(binary_value_impl)(s)?; Ok((s, BinaryValue { nodes: a })) } +#[trace] pub fn binary_value_impl(s: Span) -> IResult { let (s, a) = is_a("01xXzZ?")(s)?; fold_many0(alt((tag("_"), is_a("01xXzZ?"))), a, |acc, item| { @@ -319,11 +340,13 @@ pub fn binary_value_impl(s: Span) -> IResult { })(s) } +#[trace] pub fn octal_value(s: Span) -> IResult { let (s, a) = ws(octal_value_impl)(s)?; Ok((s, OctalValue { nodes: a })) } +#[trace] pub fn octal_value_impl(s: Span) -> IResult { let (s, a) = is_a("01234567xXzZ?")(s)?; fold_many0(alt((tag("_"), is_a("01234567xXzZ?"))), a, |acc, item| { @@ -331,11 +354,13 @@ pub fn octal_value_impl(s: Span) -> IResult { })(s) } +#[trace] pub fn hex_value(s: Span) -> IResult { let (s, a) = ws(hex_value_impl)(s)?; Ok((s, HexValue { nodes: a })) } +#[trace] pub fn hex_value_impl(s: Span) -> IResult { let (s, a) = is_a("0123456789abcdefABCDEFxXzZ?")(s)?; fold_many0( @@ -345,47 +370,57 @@ pub fn hex_value_impl(s: Span) -> IResult { )(s) } +#[trace] pub fn decimal_base(s: Span) -> IResult { let (s, a) = ws(decimal_base_impl)(s)?; Ok((s, DecimalBase { nodes: a })) } +#[trace] pub fn decimal_base_impl(s: Span) -> IResult { alt((tag_no_case("'d"), tag_no_case("'sd")))(s) } +#[trace] pub fn binary_base(s: Span) -> IResult { let (s, a) = ws(binary_base_impl)(s)?; Ok((s, BinaryBase { nodes: a })) } +#[trace] pub fn binary_base_impl(s: Span) -> IResult { alt((tag_no_case("'b"), tag_no_case("'sb")))(s) } +#[trace] pub fn octal_base(s: Span) -> IResult { let (s, a) = ws(octal_base_impl)(s)?; Ok((s, OctalBase { nodes: a })) } +#[trace] pub fn octal_base_impl(s: Span) -> IResult { alt((tag_no_case("'o"), tag_no_case("'so")))(s) } +#[trace] pub fn hex_base(s: Span) -> IResult { let (s, a) = ws(hex_base_impl)(s)?; Ok((s, HexBase { nodes: a })) } +#[trace] pub fn hex_base_impl(s: Span) -> IResult { alt((tag_no_case("'h"), tag_no_case("'sh")))(s) } +#[trace] pub fn x_number(s: Span) -> IResult { let (s, a) = ws(x_number_impl)(s)?; Ok((s, XNumber { nodes: a })) } +#[trace] pub fn x_number_impl(s: Span) -> IResult { let (s, a) = tag_no_case("x")(s)?; fold_many0(alt((tag("_"), is_a("_"))), a, |acc, item| { @@ -393,11 +428,13 @@ pub fn x_number_impl(s: Span) -> IResult { })(s) } +#[trace] pub fn z_number(s: Span) -> IResult { let (s, a) = ws(z_number_impl)(s)?; Ok((s, ZNumber { nodes: a })) } +#[trace] pub fn z_number_impl(s: Span) -> IResult { let (s, a) = alt((tag_no_case("z"), tag("?")))(s)?; fold_many0(alt((tag("_"), is_a("_"))), a, |acc, item| { @@ -405,6 +442,7 @@ pub fn z_number_impl(s: Span) -> IResult { })(s) } +#[trace] pub fn unbased_unsized_literal(s: Span) -> IResult { let (s, a) = alt((symbol("'0"), symbol("'1"), symbol("'z"), symbol("'x")))(s)?; Ok((s, UnbasedUnsizedLiteral { nodes: (a,) })) diff --git a/src/parser/expressions/operators.rs b/src/parser/expressions/operators.rs index ea6dd85..31a8ebd 100644 --- a/src/parser/expressions/operators.rs +++ b/src/parser/expressions/operators.rs @@ -32,6 +32,7 @@ pub struct BinaryModulePathOperator<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn unary_operator(s: Span) -> IResult { let (s, a) = alt(( symbol("+"), @@ -49,6 +50,7 @@ pub fn unary_operator(s: Span) -> IResult { Ok((s, UnaryOperator { nodes: (a,) })) } +#[trace] pub fn binary_operator(s: Span) -> IResult { let (s, a) = alt(( alt(( @@ -88,11 +90,13 @@ pub fn binary_operator(s: Span) -> IResult { Ok((s, BinaryOperator { nodes: (a,) })) } +#[trace] pub fn inc_or_dec_operator(s: Span) -> IResult { let (s, a) = alt((symbol("++"), symbol("--")))(s)?; Ok((s, IncOrDecOperator { nodes: (a,) })) } +#[trace] pub fn unary_module_path_operator(s: Span) -> IResult { let (s, a) = alt(( symbol("!"), @@ -108,6 +112,7 @@ pub fn unary_module_path_operator(s: Span) -> IResult IResult { let (s, a) = alt(( symbol("=="), diff --git a/src/parser/expressions/primaries.rs b/src/parser/expressions/primaries.rs index 9a7a450..3bc2af6 100644 --- a/src/parser/expressions/primaries.rs +++ b/src/parser/expressions/primaries.rs @@ -261,6 +261,7 @@ pub struct Cast<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn constant_primary(s: Span) -> IResult { alt(( map(symbol("null"), |x| ConstantPrimary::Null(x)), @@ -287,6 +288,7 @@ pub fn constant_primary(s: Span) -> IResult { ))(s) } +#[trace] pub fn constant_primary_ps_parameter(s: Span) -> IResult { let (s, a) = ps_parameter_identifier(s)?; let (s, b) = constant_select(s)?; @@ -296,6 +298,7 @@ pub fn constant_primary_ps_parameter(s: Span) -> IResult )) } +#[trace] pub fn constant_primary_specparam(s: Span) -> IResult { let (s, a) = specparam_identifier(s)?; let (s, b) = opt(bracket(constant_range_expression))(s)?; @@ -305,6 +308,7 @@ pub fn constant_primary_specparam(s: Span) -> IResult { )) } +#[trace] pub fn constant_primary_formal_port(s: Span) -> IResult { let (s, a) = formal_port_identifier(s)?; let (s, b) = constant_select(s)?; @@ -314,6 +318,7 @@ pub fn constant_primary_formal_port(s: Span) -> IResult { )) } +#[trace] pub fn constant_primary_enum(s: Span) -> IResult { let (s, a) = package_scope_or_class_scope(s)?; let (s, b) = enum_identifier(s)?; @@ -323,6 +328,7 @@ pub fn constant_primary_enum(s: Span) -> IResult { )) } +#[trace] pub fn constant_primary_concatenation(s: Span) -> IResult { let (s, a) = constant_concatenation(s)?; let (s, b) = opt(bracket(constant_range_expression))(s)?; @@ -332,6 +338,7 @@ pub fn constant_primary_concatenation(s: Span) -> IResult )) } +#[trace] pub fn constant_primary_multiple_concatenation(s: Span) -> IResult { let (s, a) = constant_multiple_concatenation(s)?; let (s, b) = opt(bracket(constant_range_expression))(s)?; @@ -343,6 +350,7 @@ pub fn constant_primary_multiple_concatenation(s: Span) -> IResult IResult { let (s, a) = paren(constant_mintypmax_expression)(s)?; Ok(( @@ -351,6 +359,7 @@ pub fn constant_primary_mintypmax_expression(s: Span) -> IResult IResult { alt(( map(number, |x| ModulePathPrimary::Number(x)), @@ -368,6 +377,7 @@ pub fn module_path_primary(s: Span) -> IResult { ))(s) } +#[trace] pub fn module_path_primary_mintypmax_expression(s: Span) -> IResult { let (s, a) = paren(module_path_mintypmax_expression)(s)?; Ok(( @@ -376,6 +386,7 @@ pub fn module_path_primary_mintypmax_expression(s: Span) -> IResult IResult { alt(( map(symbol("this"), |x| Primary::This(x)), @@ -387,7 +398,7 @@ pub fn primary(s: Span) -> IResult { Primary::EmptyUnpackedArrayConcatenation(x) }), primary_concatenation, - map(rec(function_subroutine_call, REC_PRIMARY), |x| { + map(function_subroutine_call, |x| { Primary::FunctionSubroutineCall(x) }), map(let_expression, |x| Primary::LetExpression(x)), @@ -403,6 +414,7 @@ pub fn primary(s: Span) -> IResult { ))(s) } +#[trace] pub fn primary_hierarchical(s: Span) -> IResult { let (s, a) = opt(class_qualifier_or_package_scope)(s)?; let (s, b) = hierarchical_identifier(s)?; @@ -413,6 +425,7 @@ pub fn primary_hierarchical(s: Span) -> IResult { )) } +#[trace] pub fn primary_concatenation(s: Span) -> IResult { let (s, a) = concatenation(s)?; let (s, b) = opt(bracket(range_expression))(s)?; @@ -422,6 +435,7 @@ pub fn primary_concatenation(s: Span) -> IResult { )) } +#[trace] pub fn primary_multiple_concatenation(s: Span) -> IResult { let (s, a) = multiple_concatenation(s)?; let (s, b) = opt(bracket(range_expression))(s)?; @@ -431,6 +445,7 @@ pub fn primary_multiple_concatenation(s: Span) -> IResult { )) } +#[trace] pub fn primary_mintypmax_expression(s: Span) -> IResult { let (s, a) = paren(mintypmax_expression)(s)?; Ok(( @@ -439,6 +454,7 @@ pub fn primary_mintypmax_expression(s: Span) -> IResult { )) } +#[trace] pub fn class_qualifier_or_package_scope(s: Span) -> IResult { alt(( map(class_qualifier, |x| { @@ -450,12 +466,14 @@ pub fn class_qualifier_or_package_scope(s: Span) -> IResult IResult { let (s, a) = opt(local)(s)?; let (s, b) = opt(implicit_class_handle_or_class_scope)(s)?; Ok((s, ClassQualifier { nodes: (a, b) })) } +#[trace] pub fn range_expression(s: Span) -> IResult { alt(( map(expression, |x| RangeExpression::Expression(x)), @@ -463,6 +481,7 @@ pub fn range_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn primary_literal(s: Span) -> IResult { alt(( map(time_literal, |x| PrimaryLiteral::TimeLiteral(x)), @@ -474,10 +493,12 @@ pub fn primary_literal(s: Span) -> IResult { ))(s) } +#[trace] pub fn time_literal(s: Span) -> IResult { alt((time_literal_unsigned, time_literal_fixed_point))(s) } +#[trace] pub fn time_literal_unsigned(s: Span) -> IResult { let (s, a) = unsigned_number(s)?; let (s, b) = time_unit(s)?; @@ -487,6 +508,7 @@ pub fn time_literal_unsigned(s: Span) -> IResult { )) } +#[trace] pub fn time_literal_fixed_point(s: Span) -> IResult { let (s, a) = fixed_point_number(s)?; let (s, b) = time_unit(s)?; @@ -496,6 +518,7 @@ pub fn time_literal_fixed_point(s: Span) -> IResult { )) } +#[trace] pub fn time_unit(s: Span) -> IResult { alt(( map(symbol("s"), |x| TimeUnit::S(x)), @@ -507,6 +530,7 @@ pub fn time_unit(s: Span) -> IResult { ))(s) } +#[trace] pub fn implicit_class_handle(s: Span) -> IResult { alt(( map( @@ -518,11 +542,13 @@ pub fn implicit_class_handle(s: Span) -> IResult { ))(s) } +#[trace] pub fn bit_select(s: Span) -> IResult { let (s, a) = many0(bracket(expression))(s)?; Ok((s, BitSelect { nodes: (a,) })) } +#[trace] pub fn select(s: Span) -> IResult { let (s, a) = opt(triple( many0(triple(symbol("."), member_identifier, bit_select)), @@ -534,6 +560,7 @@ pub fn select(s: Span) -> IResult { Ok((s, Select { nodes: (a, b, c) })) } +#[trace] pub fn nonrange_select(s: Span) -> IResult { let (s, a) = opt(triple( many0(triple(symbol("."), member_identifier, bit_select)), @@ -544,11 +571,13 @@ pub fn nonrange_select(s: Span) -> IResult { Ok((s, NonrangeSelect { nodes: (a, b) })) } +#[trace] pub fn constant_bit_select(s: Span) -> IResult { let (s, a) = many0(bracket(constant_expression))(s)?; Ok((s, ConstantBitSelect { nodes: (a,) })) } +#[trace] pub fn constant_select(s: Span) -> IResult { let (s, a) = opt(triple( many0(triple(symbol("."), member_identifier, constant_bit_select)), @@ -560,6 +589,7 @@ pub fn constant_select(s: Span) -> IResult { Ok((s, ConstantSelect { nodes: (a, b, c) })) } +#[trace] pub fn constant_cast(s: Span) -> IResult { let (s, a) = casting_type(s)?; let (s, b) = symbol("'")(s)?; @@ -567,11 +597,13 @@ pub fn constant_cast(s: Span) -> IResult { Ok((s, ConstantCast { nodes: (a, b, c) })) } +#[trace] pub fn constant_let_expression(s: Span) -> IResult { let (s, a) = let_expression(s)?; Ok((s, ConstantLetExpression { nodes: (a,) })) } +#[trace] pub fn cast(s: Span) -> IResult { let (s, a) = casting_type(s)?; let (s, b) = symbol("'")(s)?; diff --git a/src/parser/expressions/strings.rs b/src/parser/expressions/strings.rs index ff461e3..2daa2ab 100644 --- a/src/parser/expressions/strings.rs +++ b/src/parser/expressions/strings.rs @@ -15,11 +15,13 @@ pub struct StringLiteral<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn string_literal(s: Span) -> IResult { let (s, a) = ws(string_literal_impl)(s)?; Ok((s, StringLiteral { nodes: a })) } +#[trace] pub fn string_literal_impl(s: Span) -> IResult { let (s, a) = tag("\"")(s)?; let (s, b) = many1(pair(is_not("\\\""), opt(pair(tag("\\"), take(1usize)))))(s)?; diff --git a/src/parser/expressions/subroutine_calls.rs b/src/parser/expressions/subroutine_calls.rs index bb9bb23..5929270 100644 --- a/src/parser/expressions/subroutine_calls.rs +++ b/src/parser/expressions/subroutine_calls.rs @@ -184,11 +184,13 @@ pub enum ArrayMethodName<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn constant_function_call(s: Span) -> IResult { let (s, a) = function_subroutine_call(s)?; Ok((s, ConstantFunctionCall { nodes: (a,) })) } +#[trace] pub fn tf_call(s: Span) -> IResult { let (s, a) = ps_or_hierarchical_tf_identifier(s)?; let (s, b) = many0(attribute_instance)(s)?; @@ -196,6 +198,7 @@ pub fn tf_call(s: Span) -> IResult { Ok((s, TfCall { nodes: (a, b, c) })) } +#[trace] pub fn system_tf_call(s: Span) -> IResult { alt(( system_tf_call_arg_optional, @@ -204,6 +207,7 @@ pub fn system_tf_call(s: Span) -> IResult { ))(s) } +#[trace] pub fn system_tf_call_arg_optional(s: Span) -> IResult { let (s, a) = system_tf_identifier(s)?; let (s, b) = opt(paren(list_of_arguments))(s)?; @@ -213,6 +217,7 @@ pub fn system_tf_call_arg_optional(s: Span) -> IResult { )) } +#[trace] pub fn system_tf_call_arg_data_type(s: Span) -> IResult { let (s, a) = system_tf_identifier(s)?; let (s, b) = paren(pair(data_type, opt(pair(symbol(","), expression))))(s)?; @@ -222,6 +227,7 @@ pub fn system_tf_call_arg_data_type(s: Span) -> IResult { )) } +#[trace] pub fn system_tf_call_arg_expression(s: Span) -> IResult { let (s, a) = system_tf_identifier(s)?; let (s, b) = paren(pair( @@ -234,6 +240,7 @@ pub fn system_tf_call_arg_expression(s: Span) -> IResult { )) } +#[trace] pub fn subroutine_call(s: Span) -> IResult { alt(( map(tf_call, |x| SubroutineCall::TfCall(Box::new(x))), @@ -245,6 +252,7 @@ pub fn subroutine_call(s: Span) -> IResult { ))(s) } +#[trace] pub fn subroutine_call_randomize(s: Span) -> IResult { let (s, a) = opt(pair(symbol("std"), symbol("::")))(s)?; let (s, b) = randomize_call(s)?; @@ -254,14 +262,17 @@ pub fn subroutine_call_randomize(s: Span) -> IResult { )) } +#[trace] pub fn function_subroutine_call(s: Span) -> IResult { map(subroutine_call, |x| FunctionSubroutineCall { nodes: (x,) })(s) } +#[trace] pub fn list_of_arguments(s: Span) -> IResult { alt((list_of_arguments_ordered, list_of_arguments_named))(s) } +#[trace] pub fn list_of_arguments_ordered(s: Span) -> IResult { let (s, a) = list(symbol(","), opt(expression))(s)?; let (s, b) = many0(tuple(( @@ -276,6 +287,7 @@ pub fn list_of_arguments_ordered(s: Span) -> IResult { )) } +#[trace] pub fn list_of_arguments_named(s: Span) -> IResult { let (s, a) = symbol(".")(s)?; let (s, b) = identifier(s)?; @@ -294,6 +306,7 @@ pub fn list_of_arguments_named(s: Span) -> IResult { )) } +#[trace] pub fn method_call(s: Span) -> IResult { let (s, a) = method_call_root(s)?; let (s, b) = symbol(".")(s)?; @@ -302,6 +315,7 @@ pub fn method_call(s: Span) -> IResult { Ok((s, MethodCall { nodes: (a, b, c) })) } +#[trace] pub fn method_call_body(s: Span) -> IResult { alt(( method_call_body_user, @@ -311,6 +325,7 @@ pub fn method_call_body(s: Span) -> IResult { ))(s) } +#[trace] pub fn method_call_body_user(s: Span) -> IResult { let (s, a) = method_identifier(s)?; let (s, b) = many0(attribute_instance)(s)?; @@ -321,6 +336,7 @@ pub fn method_call_body_user(s: Span) -> IResult { )) } +#[trace] pub fn built_in_method_call(s: Span) -> IResult { alt(( map(array_manipulation_call, |x| { @@ -330,6 +346,7 @@ pub fn built_in_method_call(s: Span) -> IResult { ))(s) } +#[trace] pub fn array_manipulation_call(s: Span) -> IResult { let (s, a) = array_method_name(s)?; let (s, b) = many0(attribute_instance)(s)?; @@ -343,6 +360,7 @@ pub fn array_manipulation_call(s: Span) -> IResult )) } +#[trace] pub fn randomize_call(s: Span) -> IResult { let (s, a) = symbol("randomize")(s)?; let (s, b) = many0(attribute_instance)(s)?; @@ -360,6 +378,7 @@ pub fn randomize_call(s: Span) -> IResult { )) } +#[trace] pub fn variable_identifier_list_or_null(s: Span) -> IResult { alt(( map(variable_identifier_list, |x| { @@ -369,6 +388,7 @@ pub fn variable_identifier_list_or_null(s: Span) -> IResult IResult { alt(( map(primary, |x| MethodCallRoot::Primary(x)), @@ -378,6 +398,7 @@ pub fn method_call_root(s: Span) -> IResult { ))(s) } +#[trace] pub fn array_method_name(s: Span) -> IResult { alt(( map(symbol("unique"), |x| ArrayMethodName::Unique(x)), diff --git a/src/parser/general/attributes.rs b/src/parser/general/attributes.rs index 7d21aed..9120f69 100644 --- a/src/parser/general/attributes.rs +++ b/src/parser/general/attributes.rs @@ -18,6 +18,7 @@ pub struct AttrSpec<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn attribute_instance(s: Span) -> IResult { let (s, a) = symbol("(*")(s)?; let (s, b) = list(symbol(","), attr_spec)(s)?; @@ -25,6 +26,7 @@ pub fn attribute_instance(s: Span) -> IResult { Ok((s, AttributeInstance { nodes: (a, b, c) })) } +#[trace] pub fn attr_spec(s: Span) -> IResult { let (s, a) = identifier(s)?; let (s, b) = opt(pair(symbol("="), constant_expression))(s)?; diff --git a/src/parser/general/comments.rs b/src/parser/general/comments.rs index c89836c..df06b2a 100644 --- a/src/parser/general/comments.rs +++ b/src/parser/general/comments.rs @@ -13,10 +13,12 @@ pub struct Comment<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn comment(s: Span) -> IResult { alt((one_line_comment, block_comment))(s) } +#[trace] pub fn one_line_comment(s: Span) -> IResult { let (s, a) = tag("//")(s)?; let (s, b) = is_not("\n")(s)?; @@ -24,6 +26,7 @@ pub fn one_line_comment(s: Span) -> IResult { Ok((s, Comment { nodes: (a,) })) } +#[trace] pub fn block_comment(s: Span) -> IResult { let (s, a) = tag("/*")(s)?; let (s, b) = is_not("*/")(s)?; diff --git a/src/parser/general/identifiers.rs b/src/parser/general/identifiers.rs index 4890805..ce9c706 100644 --- a/src/parser/general/identifiers.rs +++ b/src/parser/general/identifiers.rs @@ -544,26 +544,31 @@ pub enum PackageScopeOrClassScope<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn array_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ArrayIdentifier { nodes: (a,) })) } +#[trace] pub fn block_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, BlockIdentifier { nodes: (a,) })) } +#[trace] pub fn bin_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, BinIdentifier { nodes: (a,) })) } +#[trace] pub fn c_identifier(s: Span) -> IResult { let (s, a) = ws(c_identifier_impl)(s)?; Ok((s, CIdentifier { nodes: a })) } +#[trace] pub fn c_identifier_impl(s: Span) -> IResult { let (s, a) = is_a(AZ_)(s)?; let (s, b) = opt(is_a(AZ09_))(s)?; @@ -575,81 +580,97 @@ pub fn c_identifier_impl(s: Span) -> IResult { Ok((s, a)) } +#[trace] pub fn cell_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, CellIdentifier { nodes: (a,) })) } +#[trace] pub fn checker_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, CheckerIdentifier { nodes: (a,) })) } +#[trace] pub fn class_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ClassIdentifier { nodes: (a,) })) } +#[trace] pub fn class_variable_identifier(s: Span) -> IResult { let (s, a) = variable_identifier(s)?; Ok((s, ClassVariableIdentifier { nodes: (a,) })) } +#[trace] pub fn clocking_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ClockingIdentifier { nodes: (a,) })) } +#[trace] pub fn config_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ConfigIdentifier { nodes: (a,) })) } +#[trace] pub fn const_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ConstIdentifier { nodes: (a,) })) } +#[trace] pub fn constraint_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ConstraintIdentifier { nodes: (a,) })) } +#[trace] pub fn covergroup_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, CovergroupIdentifier { nodes: (a,) })) } +#[trace] pub fn covergroup_variable_identifier(s: Span) -> IResult { let (s, a) = variable_identifier(s)?; Ok((s, CovergroupVariableIdentifier { nodes: (a,) })) } +#[trace] pub fn cover_point_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, CoverPointIdentifier { nodes: (a,) })) } +#[trace] pub fn cross_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, CrossIdentifier { nodes: (a,) })) } +#[trace] pub fn dynamic_array_variable_identifier(s: Span) -> IResult { let (s, a) = variable_identifier(s)?; Ok((s, DynamicArrayVariableIdentifier { nodes: (a,) })) } +#[trace] pub fn enum_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, EnumIdentifier { nodes: (a,) })) } +#[trace] pub fn escaped_identifier(s: Span) -> IResult { let (s, a) = ws(escaped_identifier_impl)(s)?; Ok((s, EscapedIdentifier { nodes: a })) } +#[trace] pub fn escaped_identifier_impl(s: Span) -> IResult { let (s, a) = tag("\\")(s)?; let (s, b) = is_not(" \t\r\n")(s)?; @@ -657,46 +678,55 @@ pub fn escaped_identifier_impl(s: Span) -> IResult { Ok((s, a)) } +#[trace] pub fn formal_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, FormalIdentifier { nodes: (a,) })) } +#[trace] pub fn formal_port_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, FormalPortIdentifier { nodes: (a,) })) } +#[trace] pub fn function_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, FunctionIdentifier { nodes: (a,) })) } +#[trace] pub fn generate_block_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, GenerateBlockIdentifier { nodes: (a,) })) } +#[trace] pub fn genvar_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, GenvarIdentifier { nodes: (a,) })) } +#[trace] pub fn hierarchical_array_identifier(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; Ok((s, HierarchicalArrayIdentifier { nodes: (a,) })) } +#[trace] pub fn hierarchical_block_identifier(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; Ok((s, HierarchicalBlockIdentifier { nodes: (a,) })) } +#[trace] pub fn hierarchical_event_identifier(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; Ok((s, HierarchicalEventIdentifier { nodes: (a,) })) } +#[trace] pub fn hierarchical_identifier(s: Span) -> IResult { let (s, a) = opt(root)(s)?; let (s, b) = many0(triple(identifier, constant_bit_select, symbol(".")))(s)?; @@ -704,17 +734,20 @@ pub fn hierarchical_identifier(s: Span) -> IResult Ok((s, HierarchicalIdentifier { nodes: (a, b, c) })) } +#[trace] pub fn root(s: Span) -> IResult { let (s, a) = symbol("$root")(s)?; let (s, b) = symbol(".")(s)?; Ok((s, Root { nodes: (a, b) })) } +#[trace] pub fn hierarchical_net_identifier(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; Ok((s, HierarchicalNetIdentifier { nodes: (a,) })) } +#[trace] pub fn hierarchical_parameter_identifier( s: Span, ) -> IResult { @@ -722,31 +755,37 @@ pub fn hierarchical_parameter_identifier( Ok((s, HierarchicalParameterIdentifier { nodes: (a,) })) } +#[trace] pub fn hierarchical_property_identifier(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; Ok((s, HierarchicalPropertyIdentifier { nodes: (a,) })) } +#[trace] pub fn hierarchical_sequence_identifier(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; Ok((s, HierarchicalSequenceIdentifier { nodes: (a,) })) } +#[trace] pub fn hierarchical_task_identifier(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; Ok((s, HierarchicalTaskIdentifier { nodes: (a,) })) } +#[trace] pub fn hierarchical_tf_identifier(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; Ok((s, HierarchicalTfIdentifier { nodes: (a,) })) } +#[trace] pub fn hierarchical_variable_identifier(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; Ok((s, HierarchicalVariableIdentifier { nodes: (a,) })) } +#[trace] pub fn identifier(s: Span) -> IResult { alt(( map(escaped_identifier, |x| Identifier::EscapedIdentifier(x)), @@ -754,85 +793,102 @@ pub fn identifier(s: Span) -> IResult { ))(s) } +#[trace] pub fn index_variable_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, IndexVariableIdentifier { nodes: (a,) })) } +#[trace] pub fn interface_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, InterfaceIdentifier { nodes: (a,) })) } +#[trace] pub fn interface_instance_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, InterfaceInstanceIdentifier { nodes: (a,) })) } +#[trace] pub fn inout_port_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, InoutPortIdentifier { nodes: (a,) })) } +#[trace] pub fn input_port_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, InputPortIdentifier { nodes: (a,) })) } +#[trace] pub fn instance_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, InstanceIdentifier { nodes: (a,) })) } +#[trace] pub fn library_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, LibraryIdentifier { nodes: (a,) })) } +#[trace] pub fn member_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, MemberIdentifier { nodes: (a,) })) } +#[trace] pub fn method_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, MethodIdentifier { nodes: (a,) })) } +#[trace] pub fn modport_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ModportIdentifier { nodes: (a,) })) } +#[trace] pub fn module_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ModuleIdentifier { nodes: (a,) })) } +#[trace] pub fn net_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, NetIdentifier { nodes: (a,) })) } +#[trace] pub fn net_type_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, NetTypeIdentifier { nodes: (a,) })) } +#[trace] pub fn output_port_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, OutputPortIdentifier { nodes: (a,) })) } +#[trace] pub fn package_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, PackageIdentifier { nodes: (a,) })) } +#[trace] pub fn package_scope(s: Span) -> IResult { alt((package_scope_package, map(unit, |x| PackageScope::Unit(x))))(s) } +#[trace] pub fn package_scope_package(s: Span) -> IResult { let (s, a) = package_identifier(s)?; let (s, b) = symbol("::")(s)?; @@ -842,61 +898,72 @@ pub fn package_scope_package(s: Span) -> IResult { )) } +#[trace] pub fn unit(s: Span) -> IResult { let (s, a) = symbol("$unit")(s)?; let (s, b) = symbol("::")(s)?; Ok((s, Unit { nodes: (a, b) })) } +#[trace] pub fn parameter_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ParameterIdentifier { nodes: (a,) })) } +#[trace] pub fn port_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, PortIdentifier { nodes: (a,) })) } +#[trace] pub fn production_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ProductionIdentifier { nodes: (a,) })) } +#[trace] pub fn program_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, ProgramIdentifier { nodes: (a,) })) } +#[trace] pub fn property_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, PropertyIdentifier { nodes: (a,) })) } +#[trace] pub fn ps_class_identifier(s: Span) -> IResult { let (s, a) = opt(package_scope)(s)?; let (s, b) = class_identifier(s)?; Ok((s, PsClassIdentifier { nodes: (a, b) })) } +#[trace] pub fn ps_covergroup_identifier(s: Span) -> IResult { let (s, a) = opt(package_scope)(s)?; let (s, b) = covergroup_identifier(s)?; Ok((s, PsCovergroupIdentifier { nodes: (a, b) })) } +#[trace] pub fn ps_checker_identifier(s: Span) -> IResult { let (s, a) = opt(package_scope)(s)?; let (s, b) = checker_identifier(s)?; Ok((s, PsCheckerIdentifier { nodes: (a, b) })) } +#[trace] pub fn ps_identifier(s: Span) -> IResult { let (s, a) = opt(package_scope)(s)?; let (s, b) = identifier(s)?; Ok((s, PsIdentifier { nodes: (a, b) })) } +#[trace] pub fn ps_or_hierarchical_array_identifier( s: Span, ) -> IResult { @@ -905,6 +972,7 @@ pub fn ps_or_hierarchical_array_identifier( Ok((s, PsOrHierarchicalArrayIdentifier { nodes: (a, b) })) } +#[trace] pub fn ps_or_hierarchical_net_identifier(s: Span) -> IResult { alt(( ps_or_hierarchical_net_identifier_package_scope, @@ -914,6 +982,7 @@ pub fn ps_or_hierarchical_net_identifier(s: Span) -> IResult IResult { @@ -927,6 +996,7 @@ pub fn ps_or_hierarchical_net_identifier_package_scope( )) } +#[trace] pub fn ps_or_hierarchical_property_identifier( s: Span, ) -> IResult { @@ -938,6 +1008,7 @@ pub fn ps_or_hierarchical_property_identifier( ))(s) } +#[trace] pub fn ps_or_hierarchical_property_identifier_package_scope( s: Span, ) -> IResult { @@ -951,6 +1022,7 @@ pub fn ps_or_hierarchical_property_identifier_package_scope( )) } +#[trace] pub fn ps_or_hierarchical_sequence_identifier( s: Span, ) -> IResult { @@ -962,6 +1034,7 @@ pub fn ps_or_hierarchical_sequence_identifier( ))(s) } +#[trace] pub fn ps_or_hierarchical_sequence_identifier_package_scope( s: Span, ) -> IResult { @@ -975,6 +1048,7 @@ pub fn ps_or_hierarchical_sequence_identifier_package_scope( )) } +#[trace] pub fn ps_or_hierarchical_tf_identifier(s: Span) -> IResult { alt(( ps_or_hierarchical_tf_identifier_package_scope, @@ -984,6 +1058,7 @@ pub fn ps_or_hierarchical_tf_identifier(s: Span) -> IResult IResult { @@ -997,6 +1072,7 @@ pub fn ps_or_hierarchical_tf_identifier_package_scope( )) } +#[trace] pub fn ps_parameter_identifier(s: Span) -> IResult { alt(( ps_parameter_identifier_scope, @@ -1004,6 +1080,7 @@ pub fn ps_parameter_identifier(s: Span) -> IResult ))(s) } +#[trace] 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)?; @@ -1013,6 +1090,7 @@ pub fn ps_parameter_identifier_scope(s: Span) -> IResult IResult { let (s, a) = many0(triple( generate_block_identifier, @@ -1026,27 +1104,32 @@ pub fn ps_parameter_identifier_generate(s: Span) -> IResult IResult { let (s, a) = opt(local_or_package_scope_or_class_scope)(s)?; let (s, b) = type_identifier(s)?; Ok((s, PsTypeIdentifier { nodes: (a, b) })) } +#[trace] pub fn sequence_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, SequenceIdentifier { nodes: (a,) })) } +#[trace] pub fn signal_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, SignalIdentifier { nodes: (a,) })) } +#[trace] pub fn simple_identifier(s: Span) -> IResult { let (s, a) = ws(simple_identifier_impl)(s)?; Ok((s, SimpleIdentifier { nodes: a })) } +#[trace] pub fn simple_identifier_impl(s: Span) -> IResult { let (s, a) = is_a(AZ_)(s)?; let (s, b) = opt(is_a(AZ09_DOLLAR))(s)?; @@ -1058,16 +1141,19 @@ pub fn simple_identifier_impl(s: Span) -> IResult { Ok((s, a)) } +#[trace] pub fn specparam_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, SpecparamIdentifier { nodes: (a,) })) } +#[trace] pub fn system_tf_identifier(s: Span) -> IResult { let (s, a) = ws(system_tf_identifier_impl)(s)?; Ok((s, SystemTfIdentifier { nodes: a })) } +#[trace] pub fn system_tf_identifier_impl(s: Span) -> IResult { let (s, a) = tag("$")(s)?; let (s, b) = is_a(AZ09_DOLLAR)(s)?; @@ -1075,41 +1161,49 @@ pub fn system_tf_identifier_impl(s: Span) -> IResult { Ok((s, a)) } +#[trace] pub fn task_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, TaskIdentifier { nodes: (a,) })) } +#[trace] pub fn tf_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, TfIdentifier { nodes: (a,) })) } +#[trace] pub fn terminal_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, TerminalIdentifier { nodes: (a,) })) } +#[trace] pub fn topmodule_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, TopmoduleIdentifier { nodes: (a,) })) } +#[trace] pub fn type_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, TypeIdentifier { nodes: (a,) })) } +#[trace] pub fn udp_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, UdpIdentifier { nodes: (a,) })) } +#[trace] pub fn variable_identifier(s: Span) -> IResult { let (s, a) = identifier(s)?; Ok((s, VariableIdentifier { nodes: (a,) })) } +#[trace] pub fn implicit_class_handle_or_class_scope_or_package_scope( s: Span, ) -> IResult { @@ -1126,6 +1220,7 @@ pub fn implicit_class_handle_or_class_scope_or_package_scope( ))(s) } +#[trace] pub fn implicit_class_handle_or_package_scope( s: Span, ) -> IResult { @@ -1139,6 +1234,7 @@ pub fn implicit_class_handle_or_package_scope( ))(s) } +#[trace] pub fn implicit_class_handle_or_class_scope( s: Span, ) -> IResult { @@ -1152,6 +1248,7 @@ pub fn implicit_class_handle_or_class_scope( ))(s) } +#[trace] pub fn package_scope_or_class_scope(s: Span) -> IResult { alt(( map(package_scope, |x| PackageScopeOrClassScope::PackageScope(x)), @@ -1159,6 +1256,7 @@ pub fn package_scope_or_class_scope(s: Span) -> IResult IResult { @@ -1173,6 +1271,7 @@ pub fn local_or_package_scope_or_class_scope( ))(s) } +#[trace] pub fn local(s: Span) -> IResult { let (s, a) = symbol("local")(s)?; let (s, b) = symbol("::")(s)?; diff --git a/src/parser/instantiations/checker_instantiation.rs b/src/parser/instantiations/checker_instantiation.rs index 68f1adc..61c7566 100644 --- a/src/parser/instantiations/checker_instantiation.rs +++ b/src/parser/instantiations/checker_instantiation.rs @@ -61,6 +61,7 @@ pub struct NamedCheckerPortConnectionAsterisk<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn checker_instantiation(s: Span) -> IResult { let (s, a) = ps_checker_identifier(s)?; let (s, b) = name_of_instance(s)?; @@ -74,6 +75,7 @@ pub fn checker_instantiation(s: Span) -> IResult { )) } +#[trace] pub fn list_of_checker_port_connections(s: Span) -> IResult { alt(( list_of_checker_port_connections_ordered, @@ -81,6 +83,7 @@ pub fn list_of_checker_port_connections(s: Span) -> IResult IResult { @@ -91,6 +94,7 @@ pub fn list_of_checker_port_connections_ordered( )) } +#[trace] pub fn list_of_checker_port_connections_named( s: Span, ) -> IResult { @@ -101,12 +105,14 @@ pub fn list_of_checker_port_connections_named( )) } +#[trace] pub fn ordered_checker_port_connection(s: Span) -> IResult { let (s, x) = many0(attribute_instance)(s)?; let (s, y) = opt(property_actual_arg)(s)?; Ok((s, OrderedCheckerPortConnection { nodes: (x, y) })) } +#[trace] pub fn named_checker_port_connection(s: Span) -> IResult { alt(( named_checker_port_connection_identifier, @@ -114,6 +120,7 @@ pub fn named_checker_port_connection(s: Span) -> IResult IResult { @@ -129,6 +136,7 @@ pub fn named_checker_port_connection_identifier( )) } +#[trace] pub fn named_checker_port_connection_asterisk( s: Span, ) -> IResult { diff --git a/src/parser/instantiations/generated_instantiation.rs b/src/parser/instantiations/generated_instantiation.rs index f390f7a..8f8344d 100644 --- a/src/parser/instantiations/generated_instantiation.rs +++ b/src/parser/instantiations/generated_instantiation.rs @@ -145,6 +145,7 @@ pub enum GenerateItem<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn generate_region(s: Span) -> IResult { let (s, a) = symbol("generate")(s)?; let (s, b) = many0(generate_item)(s)?; @@ -152,6 +153,7 @@ pub fn generate_region(s: Span) -> IResult { Ok((s, GenerateRegion { nodes: (a, b, c) })) } +#[trace] pub fn loop_generate_construct(s: Span) -> IResult { let (s, a) = symbol("for")(s)?; let (s, b) = paren(tuple(( @@ -165,6 +167,7 @@ pub fn loop_generate_construct(s: Span) -> IResult Ok((s, LoopGenerateConstruct { nodes: (a, b, c) })) } +#[trace] pub fn generate_initialization(s: Span) -> IResult { let (s, a) = opt(map(symbol("genvar"), |x| Genvar { nodes: (x,) }))(s)?; let (s, b) = genvar_identifier(s)?; @@ -178,6 +181,7 @@ pub fn generate_initialization(s: Span) -> IResult { )) } +#[trace] pub fn genvar_iteration(s: Span) -> IResult { alt(( genvar_iteration_assignment, @@ -186,6 +190,7 @@ pub fn genvar_iteration(s: Span) -> IResult { ))(s) } +#[trace] pub fn genvar_iteration_assignment(s: Span) -> IResult { let (s, a) = genvar_identifier(s)?; let (s, b) = assignment_operator(s)?; @@ -196,6 +201,7 @@ pub fn genvar_iteration_assignment(s: Span) -> IResult { )) } +#[trace] pub fn genvar_iteration_prefix(s: Span) -> IResult { let (s, a) = inc_or_dec_operator(s)?; let (s, b) = genvar_identifier(s)?; @@ -205,6 +211,7 @@ pub fn genvar_iteration_prefix(s: Span) -> IResult { )) } +#[trace] pub fn genvar_iteration_suffix(s: Span) -> IResult { let (s, a) = genvar_identifier(s)?; let (s, b) = inc_or_dec_operator(s)?; @@ -214,6 +221,7 @@ pub fn genvar_iteration_suffix(s: Span) -> IResult { )) } +#[trace] pub fn conditional_generate_construct(s: Span) -> IResult { alt(( map(if_generate_construct, |x| { @@ -225,6 +233,7 @@ pub fn conditional_generate_construct(s: Span) -> IResult IResult { let (s, a) = symbol("if")(s)?; let (s, b) = paren(constant_expression)(s)?; @@ -238,6 +247,7 @@ pub fn if_generate_construct(s: Span) -> IResult { )) } +#[trace] pub fn case_generate_construct(s: Span) -> IResult { let (s, a) = symbol("case")(s)?; let (s, b) = paren(constant_expression)(s)?; @@ -251,10 +261,12 @@ pub fn case_generate_construct(s: Span) -> IResult )) } +#[trace] pub fn case_generate_item(s: Span) -> IResult { alt((case_generate_item_nondefault, case_generate_item_default))(s) } +#[trace] pub fn case_generate_item_nondefault(s: Span) -> IResult { let (s, a) = list(symbol(","), constant_expression)(s)?; let (s, b) = symbol(":")(s)?; @@ -265,6 +277,7 @@ pub fn case_generate_item_nondefault(s: Span) -> IResult )) } +#[trace] pub fn case_generate_item_default(s: Span) -> IResult { let (s, a) = symbol("default")(s)?; let (s, b) = opt(symbol(":"))(s)?; @@ -275,6 +288,7 @@ pub fn case_generate_item_default(s: Span) -> IResult { )) } +#[trace] pub fn generate_block(s: Span) -> IResult { alt(( map(generate_item, |x| GenerateBlock::GenerateItem(x)), @@ -282,6 +296,7 @@ pub fn generate_block(s: Span) -> IResult { ))(s) } +#[trace] pub fn generate_block_multiple(s: Span) -> IResult { let (s, a) = opt(pair(generate_block_identifier, symbol(":")))(s)?; let (s, b) = symbol("begin")(s)?; @@ -297,6 +312,7 @@ pub fn generate_block_multiple(s: Span) -> IResult { )) } +#[trace] pub fn generate_item(s: Span) -> IResult { alt(( map(module_or_generate_item, |x| { diff --git a/src/parser/instantiations/interface_instantiation.rs b/src/parser/instantiations/interface_instantiation.rs index 27e83f1..6faa028 100644 --- a/src/parser/instantiations/interface_instantiation.rs +++ b/src/parser/instantiations/interface_instantiation.rs @@ -17,6 +17,7 @@ pub struct InterfaceInstantiation<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn interface_instantiation(s: Span) -> IResult { let (s, a) = interface_identifier(s)?; let (s, b) = opt(parameter_value_assignment)(s)?; diff --git a/src/parser/instantiations/module_instantiation.rs b/src/parser/instantiations/module_instantiation.rs index 1f648dd..f531a6d 100644 --- a/src/parser/instantiations/module_instantiation.rs +++ b/src/parser/instantiations/module_instantiation.rs @@ -112,6 +112,7 @@ pub struct NamedPortConnectionAsterisk<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn module_instantiation(s: Span) -> IResult { let (s, a) = module_identifier(s)?; let (s, b) = opt(parameter_value_assignment)(s)?; @@ -125,12 +126,14 @@ pub fn module_instantiation(s: Span) -> IResult { )) } +#[trace] pub fn parameter_value_assignment(s: Span) -> IResult { let (s, a) = symbol("#")(s)?; let (s, b) = paren(opt(list_of_parameter_assignments))(s)?; Ok((s, ParameterValueAssignment { nodes: (a, b) })) } +#[trace] pub fn list_of_parameter_assignments(s: Span) -> IResult { alt(( list_of_parameter_assignments_ordered, @@ -138,6 +141,7 @@ pub fn list_of_parameter_assignments(s: Span) -> IResult IResult { let (s, a) = list(symbol(","), ordered_parameter_assignment)(s)?; Ok(( @@ -146,6 +150,7 @@ pub fn list_of_parameter_assignments_ordered(s: Span) -> IResult IResult { let (s, a) = list(symbol(","), named_parameter_assignment)(s)?; Ok(( @@ -154,11 +159,13 @@ pub fn list_of_parameter_assignments_named(s: Span) -> IResult IResult { let (s, x) = param_expression(s)?; Ok((s, OrderedParameterAssignment { nodes: (x,) })) } +#[trace] pub fn named_parameter_assignment(s: Span) -> IResult { let (s, a) = symbol(".")(s)?; let (s, b) = parameter_identifier(s)?; @@ -166,18 +173,21 @@ pub fn named_parameter_assignment(s: Span) -> IResult IResult { let (s, a) = name_of_instance(s)?; let (s, b) = paren(opt(list_of_port_connections))(s)?; Ok((s, HierarchicalInstance { nodes: (a, b) })) } +#[trace] pub fn name_of_instance(s: Span) -> IResult { let (s, x) = instance_identifier(s)?; let (s, y) = many0(unpacked_dimension)(s)?; Ok((s, NameOfInstance { nodes: (x, y) })) } +#[trace] pub fn list_of_port_connections(s: Span) -> IResult { alt(( list_of_port_connections_ordered, @@ -185,6 +195,7 @@ pub fn list_of_port_connections(s: Span) -> IResult ))(s) } +#[trace] pub fn list_of_port_connections_ordered(s: Span) -> IResult { let (s, a) = list(symbol(","), ordered_port_connection)(s)?; Ok(( @@ -193,6 +204,7 @@ pub fn list_of_port_connections_ordered(s: Span) -> IResult IResult { let (s, a) = list(symbol(","), named_port_connection)(s)?; Ok(( @@ -201,12 +213,14 @@ pub fn list_of_port_connections_named(s: Span) -> IResult IResult { let (s, x) = many0(attribute_instance)(s)?; let (s, y) = opt(expression)(s)?; Ok((s, OrderedPortConnection { nodes: (x, y) })) } +#[trace] pub fn named_port_connection(s: Span) -> IResult { alt(( named_port_connection_identifier, @@ -214,6 +228,7 @@ pub fn named_port_connection(s: Span) -> IResult { ))(s) } +#[trace] pub fn named_port_connection_identifier(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol(".")(s)?; @@ -227,6 +242,7 @@ pub fn named_port_connection_identifier(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol(".*")(s)?; diff --git a/src/parser/instantiations/program_instantiation.rs b/src/parser/instantiations/program_instantiation.rs index 64c3907..7c2b4ac 100644 --- a/src/parser/instantiations/program_instantiation.rs +++ b/src/parser/instantiations/program_instantiation.rs @@ -17,6 +17,7 @@ pub struct ProgramInstantiation<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn program_instantiation(s: Span) -> IResult { let (s, a) = program_identifier(s)?; let (s, b) = opt(parameter_value_assignment)(s)?; diff --git a/src/parser/primitive_instances/primitive_gate_and_switch_types.rs b/src/parser/primitive_instances/primitive_gate_and_switch_types.rs index 09275a4..e2a975a 100644 --- a/src/parser/primitive_instances/primitive_gate_and_switch_types.rs +++ b/src/parser/primitive_instances/primitive_gate_and_switch_types.rs @@ -42,11 +42,13 @@ pub struct PassSwitchtype<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn cmos_switchtype(s: Span) -> IResult { let (s, a) = alt((symbol("cmos"), symbol("rcmos")))(s)?; Ok((s, CmosSwitchtype { nodes: (a,) })) } +#[trace] pub fn enable_gatetype(s: Span) -> IResult { let (s, a) = alt(( symbol("bufif0"), @@ -57,6 +59,7 @@ pub fn enable_gatetype(s: Span) -> IResult { Ok((s, EnableGatetype { nodes: (a,) })) } +#[trace] pub fn mos_switchtype(s: Span) -> IResult { let (s, a) = alt(( symbol("nmos"), @@ -67,6 +70,7 @@ pub fn mos_switchtype(s: Span) -> IResult { Ok((s, MosSwitchtype { nodes: (a,) })) } +#[trace] pub fn n_input_gatetype(s: Span) -> IResult { let (s, a) = alt(( symbol("and"), @@ -79,11 +83,13 @@ pub fn n_input_gatetype(s: Span) -> IResult { Ok((s, NInputGatetype { nodes: (a,) })) } +#[trace] pub fn n_output_gatetype(s: Span) -> IResult { let (s, a) = alt((symbol("buf"), symbol("not")))(s)?; Ok((s, NOutputGatetype { nodes: (a,) })) } +#[trace] pub fn pass_en_switchtype(s: Span) -> IResult { let (s, a) = alt(( symbol("tranif0"), @@ -94,6 +100,7 @@ pub fn pass_en_switchtype(s: Span) -> IResult { Ok((s, PassEnSwitchtype { nodes: (a,) })) } +#[trace] pub fn pass_switchtype(s: Span) -> IResult { let (s, a) = alt((symbol("tran"), symbol("rtran")))(s)?; Ok((s, PassSwitchtype { nodes: (a,) })) diff --git a/src/parser/primitive_instances/primitive_instantiation_and_instances.rs b/src/parser/primitive_instances/primitive_instantiation_and_instances.rs index f3ca350..e8035ed 100644 --- a/src/parser/primitive_instances/primitive_instantiation_and_instances.rs +++ b/src/parser/primitive_instances/primitive_instantiation_and_instances.rs @@ -227,6 +227,7 @@ pub struct PullGateInstance<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn gate_instantiation(s: Span) -> IResult { alt(( gate_instantiation_cmos, @@ -241,6 +242,7 @@ pub fn gate_instantiation(s: Span) -> IResult { ))(s) } +#[trace] pub fn gate_instantiation_cmos(s: Span) -> IResult { let (s, a) = cmos_switchtype(s)?; let (s, b) = opt(delay3)(s)?; @@ -254,6 +256,7 @@ pub fn gate_instantiation_cmos(s: Span) -> IResult { )) } +#[trace] pub fn gate_instantiation_enable(s: Span) -> IResult { let (s, a) = enable_gatetype(s)?; let (s, b) = opt(drive_strength)(s)?; @@ -268,6 +271,7 @@ pub fn gate_instantiation_enable(s: Span) -> IResult { )) } +#[trace] pub fn gate_instantiation_mos(s: Span) -> IResult { let (s, a) = mos_switchtype(s)?; let (s, b) = opt(delay3)(s)?; @@ -281,6 +285,7 @@ pub fn gate_instantiation_mos(s: Span) -> IResult { )) } +#[trace] pub fn gate_instantiation_n_input(s: Span) -> IResult { let (s, a) = n_input_gatetype(s)?; let (s, b) = opt(drive_strength)(s)?; @@ -295,6 +300,7 @@ pub fn gate_instantiation_n_input(s: Span) -> IResult { )) } +#[trace] pub fn gate_instantiation_n_output(s: Span) -> IResult { let (s, a) = n_output_gatetype(s)?; let (s, b) = opt(drive_strength)(s)?; @@ -309,6 +315,7 @@ pub fn gate_instantiation_n_output(s: Span) -> IResult )) } +#[trace] pub fn gate_instantiation_pass_en(s: Span) -> IResult { let (s, a) = pass_en_switchtype(s)?; let (s, b) = opt(delay2)(s)?; @@ -322,6 +329,7 @@ pub fn gate_instantiation_pass_en(s: Span) -> IResult { )) } +#[trace] pub fn gate_instantiation_pass(s: Span) -> IResult { let (s, a) = pass_switchtype(s)?; let (s, b) = list(symbol(","), pass_switch_instance)(s)?; @@ -332,6 +340,7 @@ pub fn gate_instantiation_pass(s: Span) -> IResult { )) } +#[trace] pub fn gate_instantiation_pulldown(s: Span) -> IResult { let (s, a) = symbol("pulldown")(s)?; let (s, b) = opt(pulldown_strength)(s)?; @@ -345,6 +354,7 @@ pub fn gate_instantiation_pulldown(s: Span) -> IResult )) } +#[trace] pub fn gate_instantiation_pullup(s: Span) -> IResult { let (s, a) = symbol("pullup")(s)?; let (s, b) = opt(pullup_strength)(s)?; @@ -358,6 +368,7 @@ pub fn gate_instantiation_pullup(s: Span) -> IResult { )) } +#[trace] pub fn cmos_switch_instance(s: Span) -> IResult { let (s, a) = opt(name_of_instance)(s)?; let (s, b) = paren(tuple(( @@ -372,6 +383,7 @@ pub fn cmos_switch_instance(s: Span) -> IResult { Ok((s, CmosSwitchInstance { nodes: (a, b) })) } +#[trace] pub fn enable_gate_instance(s: Span) -> IResult { let (s, a) = opt(name_of_instance)(s)?; let (s, b) = paren(tuple(( @@ -384,6 +396,7 @@ pub fn enable_gate_instance(s: Span) -> IResult { Ok((s, EnableGateInstance { nodes: (a, b) })) } +#[trace] pub fn mos_switch_instance(s: Span) -> IResult { let (s, a) = opt(name_of_instance)(s)?; let (s, b) = paren(tuple(( @@ -396,6 +409,7 @@ pub fn mos_switch_instance(s: Span) -> IResult { Ok((s, MosSwitchInstance { nodes: (a, b) })) } +#[trace] pub fn n_input_gate_instance(s: Span) -> IResult { let (s, a) = opt(name_of_instance)(s)?; let (s, b) = paren(tuple(( @@ -406,6 +420,7 @@ pub fn n_input_gate_instance(s: Span) -> IResult { Ok((s, NInputGateInstance { nodes: (a, b) })) } +#[trace] pub fn n_output_gate_instance(s: Span) -> IResult { let (s, a) = opt(name_of_instance)(s)?; let (s, b) = paren(tuple(( @@ -416,12 +431,14 @@ pub fn n_output_gate_instance(s: Span) -> IResult { Ok((s, NOutputGateInstance { nodes: (a, b) })) } +#[trace] pub fn pass_switch_instance(s: Span) -> IResult { let (s, a) = opt(name_of_instance)(s)?; let (s, b) = paren(tuple((inout_terminal, symbol(","), inout_terminal)))(s)?; Ok((s, PassSwitchInstance { nodes: (a, b) })) } +#[trace] pub fn pass_enable_switch_instance(s: Span) -> IResult { let (s, a) = opt(name_of_instance)(s)?; let (s, b) = paren(tuple(( @@ -434,6 +451,7 @@ pub fn pass_enable_switch_instance(s: Span) -> IResult IResult { let (s, a) = opt(name_of_instance)(s)?; let (s, b) = paren(output_terminal)(s)?; diff --git a/src/parser/primitive_instances/primitive_strengths.rs b/src/parser/primitive_instances/primitive_strengths.rs index 34f4dd1..eedb09e 100644 --- a/src/parser/primitive_instances/primitive_strengths.rs +++ b/src/parser/primitive_instances/primitive_strengths.rs @@ -51,10 +51,12 @@ pub struct PullupStrength1<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn pulldown_strength(s: Span) -> IResult { alt((pulldown_strength01, pulldown_strength10, pulldown_strength0))(s) } +#[trace] pub fn pulldown_strength01(s: Span) -> IResult { let (s, a) = paren(triple(strength0, symbol(","), strength1))(s)?; Ok(( @@ -63,6 +65,7 @@ pub fn pulldown_strength01(s: Span) -> IResult { )) } +#[trace] pub fn pulldown_strength10(s: Span) -> IResult { let (s, a) = paren(triple(strength1, symbol(","), strength0))(s)?; Ok(( @@ -71,6 +74,7 @@ pub fn pulldown_strength10(s: Span) -> IResult { )) } +#[trace] pub fn pulldown_strength0(s: Span) -> IResult { let (s, a) = paren(strength0)(s)?; Ok(( @@ -79,10 +83,12 @@ pub fn pulldown_strength0(s: Span) -> IResult { )) } +#[trace] pub fn pullup_strength(s: Span) -> IResult { alt((pullup_strength01, pullup_strength10, pullup_strength1))(s) } +#[trace] pub fn pullup_strength01(s: Span) -> IResult { let (s, a) = paren(triple(strength0, symbol(","), strength1))(s)?; Ok(( @@ -91,6 +97,7 @@ pub fn pullup_strength01(s: Span) -> IResult { )) } +#[trace] pub fn pullup_strength10(s: Span) -> IResult { let (s, a) = paren(triple(strength1, symbol(","), strength0))(s)?; Ok(( @@ -99,6 +106,7 @@ pub fn pullup_strength10(s: Span) -> IResult { )) } +#[trace] pub fn pullup_strength1(s: Span) -> IResult { let (s, a) = paren(strength1)(s)?; Ok(( diff --git a/src/parser/primitive_instances/primitive_terminals.rs b/src/parser/primitive_instances/primitive_terminals.rs index f8e1c84..0767b24 100644 --- a/src/parser/primitive_instances/primitive_terminals.rs +++ b/src/parser/primitive_instances/primitive_terminals.rs @@ -36,31 +36,37 @@ pub struct PcontrolTerminal<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn enable_terminal(s: Span) -> IResult { let (s, a) = expression(s)?; Ok((s, EnableTerminal { nodes: (a,) })) } +#[trace] pub fn inout_terminal(s: Span) -> IResult { let (s, a) = net_lvalue(s)?; Ok((s, InoutTerminal { nodes: (a,) })) } +#[trace] pub fn input_terminal(s: Span) -> IResult { let (s, a) = expression(s)?; Ok((s, InputTerminal { nodes: (a,) })) } +#[trace] pub fn ncontrol_terminal(s: Span) -> IResult { let (s, a) = expression(s)?; Ok((s, NcontrolTerminal { nodes: (a,) })) } +#[trace] pub fn output_terminal(s: Span) -> IResult { let (s, a) = net_lvalue(s)?; Ok((s, OutputTerminal { nodes: (a,) })) } +#[trace] pub fn pcontrol_terminal(s: Span) -> IResult { let (s, a) = expression(s)?; Ok((s, PcontrolTerminal { nodes: (a,) })) diff --git a/src/parser/source_text/checker_items.rs b/src/parser/source_text/checker_items.rs index 68bbe33..22bd862 100644 --- a/src/parser/source_text/checker_items.rs +++ b/src/parser/source_text/checker_items.rs @@ -92,11 +92,13 @@ pub enum CheckerGenerateItem<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn checker_port_list(s: Span) -> IResult { let (s, a) = list(symbol(","), checker_port_item)(s)?; Ok((s, CheckerPortList { nodes: (a,) })) } +#[trace] pub fn checker_port_item(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = opt(checker_port_direction)(s)?; @@ -112,6 +114,7 @@ pub fn checker_port_item(s: Span) -> IResult { )) } +#[trace] pub fn checker_port_direction(s: Span) -> IResult { alt(( map(symbol("input"), |x| CheckerPortDirection::Input(x)), @@ -119,6 +122,7 @@ pub fn checker_port_direction(s: Span) -> IResult { ))(s) } +#[trace] pub fn checker_or_generate_item(s: Span) -> IResult { alt(( map(checker_or_generate_item_declaration, |x| { @@ -143,6 +147,7 @@ pub fn checker_or_generate_item(s: Span) -> IResult ))(s) } +#[trace] pub fn checker_or_generate_item_declaration( s: Span, ) -> IResult { @@ -172,6 +177,7 @@ pub fn checker_or_generate_item_declaration( ))(s) } +#[trace] pub fn checker_or_generate_item_declaration_data( s: Span, ) -> IResult { @@ -185,11 +191,13 @@ pub fn checker_or_generate_item_declaration_data( )) } +#[trace] pub fn rand(s: Span) -> IResult { let (s, a) = symbol("rand")(s)?; Ok((s, Rand { nodes: (a,) })) } +#[trace] pub fn checker_or_generate_item_declaration_clocking( s: Span, ) -> IResult { @@ -205,6 +213,7 @@ pub fn checker_or_generate_item_declaration_clocking( )) } +#[trace] pub fn checker_or_generate_item_declaration_disable( s: Span, ) -> IResult { @@ -221,6 +230,7 @@ pub fn checker_or_generate_item_declaration_disable( )) } +#[trace] pub fn checker_generate_item(s: Span) -> IResult { alt(( map(loop_generate_construct, |x| { diff --git a/src/parser/source_text/class_items.rs b/src/parser/source_text/class_items.rs index b398924..f261612 100644 --- a/src/parser/source_text/class_items.rs +++ b/src/parser/source_text/class_items.rs @@ -200,6 +200,7 @@ pub struct New<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn class_item(s: Span) -> IResult { alt(( class_item_property, @@ -217,18 +218,21 @@ pub fn class_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn class_item_property(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = class_property(s)?; Ok((s, ClassItem::Property(ClassItemProperty { nodes: (a, b) }))) } +#[trace] pub fn class_item_method(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = class_method(s)?; Ok((s, ClassItem::Method(ClassItemMethod { nodes: (a, b) }))) } +#[trace] pub fn class_item_constraint(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = class_constraint(s)?; @@ -238,6 +242,7 @@ pub fn class_item_constraint(s: Span) -> IResult { )) } +#[trace] pub fn class_item_declaration(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = class_declaration(s)?; @@ -247,6 +252,7 @@ pub fn class_item_declaration(s: Span) -> IResult { )) } +#[trace] pub fn class_item_covergroup(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = covergroup_declaration(s)?; @@ -256,10 +262,12 @@ pub fn class_item_covergroup(s: Span) -> IResult { )) } +#[trace] pub fn class_property(s: Span) -> IResult { alt((class_property_non_const, class_property_const))(s) } +#[trace] pub fn class_property_non_const(s: Span) -> IResult { let (s, a) = many0(property_qualifier)(s)?; let (s, b) = data_declaration(s)?; @@ -269,6 +277,7 @@ pub fn class_property_non_const(s: Span) -> IResult { )) } +#[trace] pub fn class_property_const(s: Span) -> IResult { let (s, a) = symbol("const")(s)?; let (s, b) = many0(class_item_qualifier)(s)?; @@ -284,6 +293,7 @@ pub fn class_property_const(s: Span) -> IResult { )) } +#[trace] pub fn class_method(s: Span) -> IResult { alt(( class_method_task, @@ -295,12 +305,14 @@ pub fn class_method(s: Span) -> IResult { ))(s) } +#[trace] pub fn class_method_task(s: Span) -> IResult { let (s, a) = many0(method_qualifier)(s)?; let (s, b) = task_declaration(s)?; Ok((s, ClassMethod::Task(ClassMethodTask { nodes: (a, b) }))) } +#[trace] pub fn class_method_function(s: Span) -> IResult { let (s, a) = many0(method_qualifier)(s)?; let (s, b) = function_declaration(s)?; @@ -310,6 +322,7 @@ pub fn class_method_function(s: Span) -> IResult { )) } +#[trace] pub fn class_method_pure_virtual(s: Span) -> IResult { let (s, a) = symbol("pure")(s)?; let (s, b) = symbol("virtual")(s)?; @@ -324,6 +337,7 @@ pub fn class_method_pure_virtual(s: Span) -> IResult { )) } +#[trace] pub fn class_method_extern_method(s: Span) -> IResult { let (s, a) = symbol("extern")(s)?; let (s, b) = many0(method_qualifier)(s)?; @@ -337,6 +351,7 @@ pub fn class_method_extern_method(s: Span) -> IResult { )) } +#[trace] pub fn class_method_constructor(s: Span) -> IResult { let (s, a) = many0(method_qualifier)(s)?; let (s, b) = class_constructor_declaration(s)?; @@ -346,6 +361,7 @@ pub fn class_method_constructor(s: Span) -> IResult { )) } +#[trace] pub fn class_method_extern_constructor(s: Span) -> IResult { let (s, a) = symbol("extern")(s)?; let (s, b) = many0(method_qualifier)(s)?; @@ -356,6 +372,7 @@ pub fn class_method_extern_constructor(s: Span) -> IResult { )) } +#[trace] pub fn class_constructor_prototype(s: Span) -> IResult { let (s, a) = symbol("function")(s)?; let (s, b) = symbol("new")(s)?; @@ -369,6 +386,7 @@ pub fn class_constructor_prototype(s: Span) -> IResult IResult { alt(( map(constraint_prototype, |x| { @@ -380,6 +398,7 @@ pub fn class_constraint(s: Span) -> IResult { ))(s) } +#[trace] pub fn class_item_qualifier(s: Span) -> IResult { alt(( map(symbol("static"), |x| ClassItemQualifier::Static(x)), @@ -388,6 +407,7 @@ pub fn class_item_qualifier(s: Span) -> IResult { ))(s) } +#[trace] pub fn property_qualifier(s: Span) -> IResult { alt(( map(random_qualifier, |x| PropertyQualifier::RandomQualifier(x)), @@ -397,6 +417,7 @@ pub fn property_qualifier(s: Span) -> IResult { ))(s) } +#[trace] pub fn random_qualifier(s: Span) -> IResult { alt(( map(symbol("randc"), |x| RandomQualifier::Randc(x)), @@ -404,6 +425,7 @@ pub fn random_qualifier(s: Span) -> IResult { ))(s) } +#[trace] pub fn method_qualifier(s: Span) -> IResult { alt(( map(pair(symbol("pure"), symbol("virtual")), |x| { @@ -416,6 +438,7 @@ pub fn method_qualifier(s: Span) -> IResult { ))(s) } +#[trace] pub fn method_prototype(s: Span) -> IResult { alt(( map(task_prototype, |x| MethodPrototype::TaskPrototype(x)), @@ -425,6 +448,7 @@ pub fn method_prototype(s: Span) -> IResult { ))(s) } +#[trace] pub fn class_constructor_declaration(s: Span) -> IResult { let (s, a) = symbol("function")(s)?; let (s, b) = opt(class_scope)(s)?; @@ -450,6 +474,7 @@ pub fn class_constructor_declaration(s: Span) -> IResult IResult { let (s, a) = symbol("new")(s)?; Ok((s, New { nodes: (a,) })) diff --git a/src/parser/source_text/configuration_source_text.rs b/src/parser/source_text/configuration_source_text.rs index ac53555..f7028b5 100644 --- a/src/parser/source_text/configuration_source_text.rs +++ b/src/parser/source_text/configuration_source_text.rs @@ -144,6 +144,7 @@ pub struct Config<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn config_declaration(s: Span) -> IResult { let (s, a) = symbol("config")(s)?; let (s, b) = config_identifier(s)?; @@ -161,6 +162,7 @@ pub fn config_declaration(s: Span) -> IResult { )) } +#[trace] pub fn design_statement(s: Span) -> IResult { let (s, a) = symbol("design")(s)?; let (s, b) = many0(pair( @@ -171,6 +173,7 @@ pub fn design_statement(s: Span) -> IResult { Ok((s, DesignStatement { nodes: (a, b, c) })) } +#[trace] pub fn config_rule_statement(s: Span) -> IResult { alt(( config_rule_statement_default, @@ -181,6 +184,7 @@ pub fn config_rule_statement(s: Span) -> IResult { ))(s) } +#[trace] pub fn config_rule_statement_default(s: Span) -> IResult { let (s, a) = default_clause(s)?; let (s, b) = liblist_clause(s)?; @@ -191,6 +195,7 @@ pub fn config_rule_statement_default(s: Span) -> IResult IResult { let (s, a) = inst_clause(s)?; let (s, b) = liblist_clause(s)?; @@ -201,6 +206,7 @@ pub fn config_rule_statement_inst_lib(s: Span) -> IResult IResult { let (s, a) = inst_clause(s)?; let (s, b) = use_clause(s)?; @@ -211,6 +217,7 @@ pub fn config_rule_statement_inst_use(s: Span) -> IResult IResult { let (s, a) = cell_clause(s)?; let (s, b) = liblist_clause(s)?; @@ -221,6 +228,7 @@ pub fn config_rule_statement_cell_lib(s: Span) -> IResult IResult { let (s, a) = cell_clause(s)?; let (s, b) = use_clause(s)?; @@ -231,23 +239,27 @@ pub fn config_rule_statement_cell_use(s: Span) -> IResult IResult { let (s, a) = symbol("default")(s)?; Ok((s, DefaultClause { nodes: (a,) })) } +#[trace] pub fn inst_clause(s: Span) -> IResult { let (s, a) = symbol("instance")(s)?; let (s, b) = inst_name(s)?; Ok((s, InstClause { nodes: (a, b) })) } +#[trace] pub fn inst_name(s: Span) -> IResult { let (s, a) = topmodule_identifier(s)?; let (s, b) = many0(pair(symbol("."), instance_identifier))(s)?; Ok((s, InstName { nodes: (a, b) })) } +#[trace] pub fn cell_clause(s: Span) -> IResult { let (s, a) = symbol("cell")(s)?; let (s, b) = opt(pair(library_identifier, symbol(".")))(s)?; @@ -255,16 +267,19 @@ pub fn cell_clause(s: Span) -> IResult { Ok((s, CellClause { nodes: (a, b, c) })) } +#[trace] pub fn liblist_clause(s: Span) -> IResult { let (s, a) = symbol("liblist")(s)?; let (s, b) = many0(library_identifier)(s)?; Ok((s, LiblistClause { nodes: (a, b) })) } +#[trace] pub fn use_clause(s: Span) -> IResult { alt((use_clause_cell, use_clause_named, use_clause_cell_named))(s) } +#[trace] pub fn use_clause_cell(s: Span) -> IResult { let (s, a) = symbol("use")(s)?; let (s, b) = opt(pair(library_identifier, symbol(".")))(s)?; @@ -278,6 +293,7 @@ pub fn use_clause_cell(s: Span) -> IResult { )) } +#[trace] pub fn use_clause_named(s: Span) -> IResult { let (s, a) = symbol("use")(s)?; let (s, b) = list(symbol(","), named_parameter_assignment)(s)?; @@ -285,6 +301,7 @@ pub fn use_clause_named(s: Span) -> IResult { Ok((s, UseClause::Named(UseClauseNamed { nodes: (a, b, c) }))) } +#[trace] pub fn use_clause_cell_named(s: Span) -> IResult { let (s, a) = symbol("use")(s)?; let (s, b) = opt(pair(library_identifier, symbol(".")))(s)?; @@ -299,6 +316,7 @@ pub fn use_clause_cell_named(s: Span) -> IResult { )) } +#[trace] pub fn config(s: Span) -> IResult { let (s, a) = symbol("config")(s)?; Ok((s, Config { nodes: (a,) })) diff --git a/src/parser/source_text/constraints.rs b/src/parser/source_text/constraints.rs index 54c6789..d6036c8 100644 --- a/src/parser/source_text/constraints.rs +++ b/src/parser/source_text/constraints.rs @@ -191,6 +191,7 @@ pub struct IdentifierList<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn constraint_declaration(s: Span) -> IResult { let (s, a) = opt(r#static)(s)?; let (s, b) = symbol("constraint")(s)?; @@ -204,16 +205,19 @@ pub fn constraint_declaration(s: Span) -> IResult { )) } +#[trace] pub fn r#static(s: Span) -> IResult { let (s, a) = symbol("static")(s)?; Ok((s, Static { nodes: (a,) })) } +#[trace] pub fn constraint_block(s: Span) -> IResult { let (s, a) = brace(many0(constraint_block_item))(s)?; Ok((s, ConstraintBlock { nodes: (a,) })) } +#[trace] pub fn constraint_block_item(s: Span) -> IResult { alt(( constraint_block_item_solve, @@ -223,6 +227,7 @@ pub fn constraint_block_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn constraint_block_item_solve(s: Span) -> IResult { let (s, a) = symbol("solve")(s)?; let (s, b) = solve_before_list(s)?; @@ -237,11 +242,13 @@ pub fn constraint_block_item_solve(s: Span) -> IResult IResult { let (s, a) = list(symbol(","), constraint_primary)(s)?; Ok((s, SolveBeforeList { nodes: (a,) })) } +#[trace] pub fn constraint_primary(s: Span) -> IResult { let (s, a) = opt(implicit_class_handle_or_class_scope)(s)?; let (s, b) = hierarchical_identifier(s)?; @@ -249,6 +256,7 @@ pub fn constraint_primary(s: Span) -> IResult { Ok((s, ConstraintPrimary { nodes: (a, b, c) })) } +#[trace] pub fn constraint_expression(s: Span) -> IResult { alt(( constraint_expression_expression, @@ -262,6 +270,7 @@ pub fn constraint_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn constraint_expression_expression(s: Span) -> IResult { let (s, a) = opt(soft)(s)?; let (s, b) = expression_or_dist(s)?; @@ -272,11 +281,13 @@ pub fn constraint_expression_expression(s: Span) -> IResult IResult { let (s, a) = symbol("soft")(s)?; Ok((s, Soft { nodes: (a,) })) } +#[trace] pub fn constraint_expression_arrow(s: Span) -> IResult { let (s, a) = expression(s)?; let (s, b) = symbol("->")(s)?; @@ -287,6 +298,7 @@ pub fn constraint_expression_arrow(s: Span) -> IResult IResult { let (s, a) = symbol("if")(s)?; let (s, b) = paren(expression)(s)?; @@ -300,6 +312,7 @@ pub fn constraint_expression_if(s: Span) -> IResult )) } +#[trace] pub fn constraint_expression_foreach(s: Span) -> IResult { let (s, a) = symbol("foreach")(s)?; let (s, b) = paren(pair( @@ -313,6 +326,7 @@ pub fn constraint_expression_foreach(s: Span) -> IResult IResult { let (s, a) = symbol("disable")(s)?; let (s, b) = symbol("soft")(s)?; @@ -326,12 +340,14 @@ pub fn constraint_expression_disable(s: Span) -> IResult IResult { let (s, a) = symbol("unique")(s)?; let (s, b) = brace(open_range_list)(s)?; Ok((s, UniquenessConstraint { nodes: (a, b) })) } +#[trace] pub fn constraint_set(s: Span) -> IResult { alt(( map(constraint_expression, |x| { @@ -341,38 +357,45 @@ pub fn constraint_set(s: Span) -> IResult { ))(s) } +#[trace] pub fn constraint_set_brace(s: Span) -> IResult { let (s, a) = brace(many0(constraint_expression))(s)?; Ok((s, ConstraintSet::Brace(ConstraintSetBrace { nodes: (a,) }))) } +#[trace] pub fn dist_list(s: Span) -> IResult { let (s, a) = list(symbol(","), dist_item)(s)?; Ok((s, DistList { nodes: (a,) })) } +#[trace] pub fn dist_item(s: Span) -> IResult { let (s, a) = value_range(s)?; let (s, b) = opt(dist_weight)(s)?; Ok((s, DistItem { nodes: (a, b) })) } +#[trace] pub fn dist_weight(s: Span) -> IResult { alt((dist_weight_equal, dist_weight_divide))(s) } +#[trace] pub fn dist_weight_equal(s: Span) -> IResult { let (s, a) = symbol(":=")(s)?; let (s, b) = expression(s)?; Ok((s, DistWeight::Equal(DistWeightEqual { nodes: (a, b) }))) } +#[trace] pub fn dist_weight_divide(s: Span) -> IResult { let (s, a) = symbol(":/")(s)?; let (s, b) = expression(s)?; Ok((s, DistWeight::Divide(DistWeightDivide { nodes: (a, b) }))) } +#[trace] pub fn constraint_prototype(s: Span) -> IResult { let (s, a) = opt(constraint_prototype_qualifier)(s)?; let (s, b) = opt(r#static)(s)?; @@ -387,6 +410,7 @@ pub fn constraint_prototype(s: Span) -> IResult { )) } +#[trace] pub fn constraint_prototype_qualifier(s: Span) -> IResult { alt(( map(symbol("extern"), |x| { @@ -396,6 +420,7 @@ pub fn constraint_prototype_qualifier(s: Span) -> IResult IResult { let (s, a) = opt(r#static)(s)?; let (s, b) = symbol("constraint")(s)?; @@ -410,6 +435,7 @@ pub fn extern_constraint_declaration(s: Span) -> IResult IResult { let (s, a) = list(symbol(","), identifier)(s)?; Ok((s, IdentifierList { nodes: (a,) })) diff --git a/src/parser/source_text/interface_items.rs b/src/parser/source_text/interface_items.rs index e8c72f8..881fd21 100644 --- a/src/parser/source_text/interface_items.rs +++ b/src/parser/source_text/interface_items.rs @@ -58,6 +58,7 @@ pub enum NonPortInterfaceItem<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn interface_or_generate_item(s: Span) -> IResult { alt(( interface_or_generate_item_module, @@ -65,6 +66,7 @@ pub fn interface_or_generate_item(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = module_common_item(s)?; @@ -74,6 +76,7 @@ pub fn interface_or_generate_item_module(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = extern_tf_declaration(s)?; @@ -83,10 +86,12 @@ pub fn interface_or_generate_item_extern(s: Span) -> IResult IResult { alt((extern_tf_declaration_method, extern_tf_declaration_task))(s) } +#[trace] pub fn extern_tf_declaration_method(s: Span) -> IResult { let (s, a) = symbol("extern")(s)?; let (s, b) = method_prototype(s)?; @@ -97,6 +102,7 @@ pub fn extern_tf_declaration_method(s: Span) -> IResult IResult { let (s, a) = symbol("extern")(s)?; let (s, b) = symbol("forkjoin")(s)?; @@ -110,6 +116,7 @@ pub fn extern_tf_declaration_task(s: Span) -> IResult )) } +#[trace] pub fn interface_item(s: Span) -> IResult { alt(( map(pair(port_declaration, symbol(";")), |x| { @@ -121,6 +128,7 @@ pub fn interface_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn non_port_interface_item(s: Span) -> IResult { alt(( map(generate_region, |x| NonPortInterfaceItem::GenerateRegion(x)), diff --git a/src/parser/source_text/library_source_text.rs b/src/parser/source_text/library_source_text.rs index c358c36..1d4bdd2 100644 --- a/src/parser/source_text/library_source_text.rs +++ b/src/parser/source_text/library_source_text.rs @@ -44,11 +44,13 @@ pub struct FilePathSpec<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn library_text(s: Span) -> IResult { let (s, a) = many0(library_description)(s)?; Ok((s, LibraryText { nodes: (a,) })) } +#[trace] pub fn library_description(s: Span) -> IResult { alt(( map(library_declaration, |x| { @@ -64,6 +66,7 @@ pub fn library_description(s: Span) -> IResult { ))(s) } +#[trace] pub fn library_declaration(s: Span) -> IResult { let (s, a) = symbol("library")(s)?; let (s, b) = library_identifier(s)?; @@ -78,6 +81,7 @@ pub fn library_declaration(s: Span) -> IResult { )) } +#[trace] pub fn include_statement(s: Span) -> IResult { let (s, a) = symbol("include")(s)?; let (s, b) = file_path_spec(s)?; @@ -86,6 +90,7 @@ pub fn include_statement(s: Span) -> IResult { } //TODO support non literal path +#[trace] pub fn file_path_spec(s: Span) -> IResult { let (s, a) = string_literal(s)?; Ok((s, FilePathSpec { nodes: (a,) })) diff --git a/src/parser/source_text/module_items.rs b/src/parser/source_text/module_items.rs index ee022da..e5839a0 100644 --- a/src/parser/source_text/module_items.rs +++ b/src/parser/source_text/module_items.rs @@ -216,6 +216,7 @@ pub enum BindInstantiation<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn elaboration_system_task(s: Span) -> IResult { alt(( elaboration_system_task_fatal, @@ -225,6 +226,7 @@ pub fn elaboration_system_task(s: Span) -> IResult ))(s) } +#[trace] pub fn elaboration_system_task_fatal(s: Span) -> IResult { let (s, a) = symbol("$fatal")(s)?; let (s, b) = opt(paren(pair( @@ -238,6 +240,7 @@ pub fn elaboration_system_task_fatal(s: Span) -> IResult IResult { let (s, a) = symbol("$error")(s)?; let (s, b) = opt(paren(opt(list_of_arguments)))(s)?; @@ -248,6 +251,7 @@ pub fn elaboration_system_task_error(s: Span) -> IResult IResult { let (s, a) = symbol("$warning")(s)?; let (s, b) = opt(paren(opt(list_of_arguments)))(s)?; @@ -258,6 +262,7 @@ pub fn elaboration_system_task_warning(s: Span) -> IResult IResult { let (s, a) = symbol("$info")(s)?; let (s, b) = opt(paren(opt(list_of_arguments)))(s)?; @@ -268,6 +273,7 @@ pub fn elaboration_system_task_info(s: Span) -> IResult IResult { alt(( map(symbol("0"), |x| FinishNumber::Zero(x)), @@ -276,6 +282,7 @@ pub fn finish_number(s: Span) -> IResult { ))(s) } +#[trace] pub fn module_common_item(s: Span) -> IResult { alt(( map(module_or_generate_item_declaration, |x| { @@ -306,6 +313,7 @@ pub fn module_common_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn module_item(s: Span) -> IResult { alt(( map(pair(port_declaration, symbol(";")), |x| { @@ -315,6 +323,7 @@ pub fn module_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn module_or_generate_item(s: Span) -> IResult { alt(( module_or_generate_item_parameter, @@ -325,6 +334,7 @@ pub fn module_or_generate_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn module_or_generate_item_parameter(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = parameter_override(s)?; @@ -334,6 +344,7 @@ pub fn module_or_generate_item_parameter(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = gate_instantiation(s)?; @@ -343,6 +354,7 @@ pub fn module_or_generate_item_gate(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = udp_instantiation(s)?; @@ -352,6 +364,7 @@ pub fn module_or_generate_item_udp(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = module_instantiation(s)?; @@ -361,6 +374,7 @@ pub fn module_or_generate_item_module(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = module_common_item(s)?; @@ -372,6 +386,7 @@ pub fn module_or_generate_item_module_item(s: Span) -> IResult IResult { @@ -390,6 +405,7 @@ pub fn module_or_generate_item_declaration( ))(s) } +#[trace] pub fn module_or_generate_item_declaration_clocking( s: Span, ) -> IResult { @@ -405,6 +421,7 @@ pub fn module_or_generate_item_declaration_clocking( )) } +#[trace] pub fn module_or_generate_item_declaration_disable( s: Span, ) -> IResult { @@ -421,6 +438,7 @@ pub fn module_or_generate_item_declaration_disable( )) } +#[trace] pub fn non_port_module_item(s: Span) -> IResult { alt(( map(generate_region, |x| NonPortModuleItem::GenerateRegion(x)), @@ -444,6 +462,7 @@ pub fn non_port_module_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn non_port_module_item_specparam(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = specparam_declaration(s)?; @@ -453,6 +472,7 @@ pub fn non_port_module_item_specparam(s: Span) -> IResult IResult { let (s, a) = symbol("defparam")(s)?; let (s, b) = list_of_defparam_assignments(s)?; @@ -460,10 +480,12 @@ pub fn parameter_override(s: Span) -> IResult { Ok((s, ParameterOverride { nodes: (a, b, c) })) } +#[trace] pub fn bind_directive(s: Span) -> IResult { alt((bind_directive_scope, bind_directive_instance))(s) } +#[trace] pub fn bind_directive_scope(s: Span) -> IResult { let (s, a) = symbol("bind")(s)?; let (s, b) = bind_target_scope(s)?; @@ -478,6 +500,7 @@ pub fn bind_directive_scope(s: Span) -> IResult { )) } +#[trace] pub fn bind_directive_instance(s: Span) -> IResult { let (s, a) = symbol("bind")(s)?; let (s, b) = bind_target_instance(s)?; @@ -491,6 +514,7 @@ pub fn bind_directive_instance(s: Span) -> IResult { )) } +#[trace] pub fn bind_target_scope(s: Span) -> IResult { alt(( map(module_identifier, |x| BindTargetScope::ModuleIdentifier(x)), @@ -500,17 +524,20 @@ pub fn bind_target_scope(s: Span) -> IResult { ))(s) } +#[trace] pub fn bind_target_instance(s: Span) -> IResult { let (s, a) = hierarchical_identifier(s)?; let (s, b) = constant_bit_select(s)?; Ok((s, BindTargetInstance { nodes: (a, b) })) } +#[trace] pub fn bind_target_instance_list(s: Span) -> IResult { let (s, a) = list(symbol(","), bind_target_instance)(s)?; Ok((s, BindTargetInstanceList { nodes: (a,) })) } +#[trace] pub fn bind_instantiation(s: Span) -> IResult { alt(( map(program_instantiation, |x| { diff --git a/src/parser/source_text/module_parameters_and_ports.rs b/src/parser/source_text/module_parameters_and_ports.rs index b130f24..c5c6952 100644 --- a/src/parser/source_text/module_parameters_and_ports.rs +++ b/src/parser/source_text/module_parameters_and_ports.rs @@ -218,6 +218,7 @@ pub struct AnsiPortDeclarationParen<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn parameter_port_list(s: Span) -> IResult { alt(( parameter_port_list_assignment, @@ -226,6 +227,7 @@ pub fn parameter_port_list(s: Span) -> IResult { ))(s) } +#[trace] pub fn parameter_port_list_assignment(s: Span) -> IResult { let (s, a) = symbol("#")(s)?; let (s, b) = paren(pair( @@ -238,6 +240,7 @@ pub fn parameter_port_list_assignment(s: Span) -> IResult IResult { let (s, a) = symbol("#")(s)?; let (s, b) = paren(list(symbol(","), parameter_port_declaration))(s)?; @@ -247,6 +250,7 @@ pub fn parameter_port_list_declaration(s: Span) -> IResult IResult { let (s, a) = symbol("#")(s)?; let (s, b) = symbol("(")(s)?; @@ -254,6 +258,7 @@ pub fn parameter_port_list_empty(s: Span) -> IResult { Ok((s, ParameterPortList::Empty((a, b, c)))) } +#[trace] pub fn parameter_port_declaration(s: Span) -> IResult { alt(( map(parameter_declaration, |x| { @@ -267,6 +272,7 @@ pub fn parameter_port_declaration(s: Span) -> IResult IResult { let (s, a) = data_type(s)?; let (s, b) = list_of_param_assignments(s)?; @@ -276,6 +282,7 @@ pub fn parameter_port_declaration_param_list(s: Span) -> IResult IResult { let (s, a) = symbol("type")(s)?; let (s, b) = list_of_type_assignments(s)?; @@ -285,11 +292,13 @@ pub fn parameter_port_declaration_type_list(s: Span) -> IResult IResult { let (s, a) = paren(list(symbol(","), port))(s)?; Ok((s, ListOfPorts { nodes: (a,) })) } +#[trace] pub fn list_of_port_declarations(s: Span) -> IResult { let (s, a) = paren(opt(list( symbol(","), @@ -298,6 +307,7 @@ pub fn list_of_port_declarations(s: Span) -> IResult IResult { alt(( port_declaration_inout, @@ -308,6 +318,7 @@ pub fn port_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn port_declaration_inout(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = inout_declaration(s)?; @@ -317,6 +328,7 @@ pub fn port_declaration_inout(s: Span) -> IResult { )) } +#[trace] pub fn port_declaration_input(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = input_declaration(s)?; @@ -326,6 +338,7 @@ pub fn port_declaration_input(s: Span) -> IResult { )) } +#[trace] pub fn port_declaration_output(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = output_declaration(s)?; @@ -335,6 +348,7 @@ pub fn port_declaration_output(s: Span) -> IResult { )) } +#[trace] pub fn port_declaration_ref(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = ref_declaration(s)?; @@ -344,6 +358,7 @@ pub fn port_declaration_ref(s: Span) -> IResult { )) } +#[trace] pub fn port_declaration_interface(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = interface_port_declaration(s)?; @@ -353,15 +368,18 @@ pub fn port_declaration_interface(s: Span) -> IResult { )) } +#[trace] pub fn port(s: Span) -> IResult { alt((port_non_named, port_named))(s) } +#[trace] pub fn port_non_named(s: Span) -> IResult { let (s, a) = opt(port_expression)(s)?; Ok((s, Port::NonNamed(PortNonNamed { nodes: (a,) }))) } +#[trace] pub fn port_named(s: Span) -> IResult { let (s, a) = symbol(".")(s)?; let (s, b) = port_identifier(s)?; @@ -369,6 +387,7 @@ pub fn port_named(s: Span) -> IResult { Ok((s, Port::Named(PortNamed { nodes: (a, b, c) }))) } +#[trace] pub fn port_expression(s: Span) -> IResult { alt(( map(port_reference, |x| PortExpression::PortReference(x)), @@ -376,6 +395,7 @@ pub fn port_expression(s: Span) -> IResult { ))(s) } +#[trace] pub fn port_expressio_named(s: Span) -> IResult { let (s, a) = brace(list(symbol(","), port_reference))(s)?; Ok(( @@ -384,12 +404,14 @@ pub fn port_expressio_named(s: Span) -> IResult { )) } +#[trace] pub fn port_reference(s: Span) -> IResult { let (s, a) = port_identifier(s)?; let (s, b) = constant_select(s)?; Ok((s, PortReference { nodes: (a, b) })) } +#[trace] pub fn port_direction(s: Span) -> IResult { alt(( map(symbol("input"), |x| PortDirection::Input(x)), @@ -399,18 +421,21 @@ pub fn port_direction(s: Span) -> IResult { ))(s) } +#[trace] pub fn net_port_header(s: Span) -> IResult { let (s, a) = opt(port_direction)(s)?; let (s, b) = net_port_type(s)?; Ok((s, NetPortHeader { nodes: (a, b) })) } +#[trace] pub fn variable_port_header(s: Span) -> IResult { let (s, a) = opt(port_direction)(s)?; let (s, b) = variable_port_type(s)?; Ok((s, VariablePortHeader { nodes: (a, b) })) } +#[trace] pub fn interface_port_header(s: Span) -> IResult { alt(( interface_port_header_identifier, @@ -418,6 +443,7 @@ pub fn interface_port_header(s: Span) -> IResult { ))(s) } +#[trace] pub fn interface_port_header_identifier(s: Span) -> IResult { let (s, a) = interface_identifier(s)?; let (s, b) = opt(pair(symbol("."), modport_identifier))(s)?; @@ -427,6 +453,7 @@ pub fn interface_port_header_identifier(s: Span) -> IResult IResult { let (s, a) = symbol("interface")(s)?; let (s, b) = opt(pair(symbol("."), modport_identifier))(s)?; @@ -436,6 +463,7 @@ pub fn interface_port_header_interface(s: Span) -> IResult IResult { alt(( ansi_port_declaration_net, @@ -444,6 +472,7 @@ pub fn ansi_port_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn ansi_port_declaration_net(s: Span) -> IResult { let (s, a) = opt(net_port_header_or_interface_port_header)(s)?; let (s, b) = port_identifier(s)?; @@ -457,6 +486,7 @@ pub fn ansi_port_declaration_net(s: Span) -> IResult )) } +#[trace] pub fn net_port_header_or_interface_port_header( s: Span, ) -> IResult { @@ -470,6 +500,7 @@ pub fn net_port_header_or_interface_port_header( ))(s) } +#[trace] pub fn ansi_port_declaration_port(s: Span) -> IResult { let (s, a) = opt(variable_port_header)(s)?; let (s, b) = port_identifier(s)?; @@ -483,6 +514,7 @@ pub fn ansi_port_declaration_port(s: Span) -> IResult )) } +#[trace] pub fn ansi_port_declaration_paren(s: Span) -> IResult { let (s, a) = opt(port_direction)(s)?; let (s, b) = symbol(".")(s)?; diff --git a/src/parser/source_text/package_items.rs b/src/parser/source_text/package_items.rs index 93a4598..3a7fd2d 100644 --- a/src/parser/source_text/package_items.rs +++ b/src/parser/source_text/package_items.rs @@ -56,6 +56,7 @@ pub enum AnonymousProgramItem<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn package_item(s: Span) -> IResult { alt(( map(package_or_generate_item_declaration, |x| { @@ -71,6 +72,7 @@ pub fn package_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn package_or_generate_item_declaration( s: Span, ) -> IResult { @@ -118,6 +120,7 @@ pub fn package_or_generate_item_declaration( ))(s) } +#[trace] pub fn anonymous_program(s: Span) -> IResult { let (s, a) = symbol("program")(s)?; let (s, b) = symbol(";")(s)?; @@ -131,6 +134,7 @@ pub fn anonymous_program(s: Span) -> IResult { )) } +#[trace] pub fn anonymous_program_item(s: Span) -> IResult { alt(( map(task_declaration, |x| { diff --git a/src/parser/source_text/program_items.rs b/src/parser/source_text/program_items.rs index 174bc15..548a72c 100644 --- a/src/parser/source_text/program_items.rs +++ b/src/parser/source_text/program_items.rs @@ -63,6 +63,7 @@ pub enum ProgramGenerateItem<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn program_item(s: Span) -> IResult { alt(( map(pair(port_declaration, symbol(";")), |x| { @@ -74,6 +75,7 @@ pub fn program_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn non_port_program_item(s: Span) -> IResult { alt(( non_port_program_item_assign, @@ -90,6 +92,7 @@ pub fn non_port_program_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn non_port_program_item_assign(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = continuous_assign(s)?; @@ -99,6 +102,7 @@ pub fn non_port_program_item_assign(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = module_or_generate_item_declaration(s)?; @@ -108,6 +112,7 @@ pub fn non_port_program_item_module(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = initial_construct(s)?; @@ -117,6 +122,7 @@ pub fn non_port_program_item_initial(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = final_construct(s)?; @@ -126,6 +132,7 @@ pub fn non_port_program_item_final(s: Span) -> IResult )) } +#[trace] pub fn non_port_program_item_assertion(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = concurrent_assertion_item(s)?; @@ -135,6 +142,7 @@ pub fn non_port_program_item_assertion(s: Span) -> IResult IResult { alt(( map(loop_generate_construct, |x| { diff --git a/src/parser/source_text/system_verilog_source_text.rs b/src/parser/source_text/system_verilog_source_text.rs index cb6cb74..7536134 100644 --- a/src/parser/source_text/system_verilog_source_text.rs +++ b/src/parser/source_text/system_verilog_source_text.rs @@ -437,12 +437,14 @@ pub struct TimeunitsDeclarationTimeprecisionTimeunit<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn source_text(s: Span) -> IResult { let (s, a) = opt(timeunits_declaration)(s)?; let (s, b) = many0(description)(s)?; Ok((s, SourceText { nodes: (a, b) })) } +#[trace] pub fn description(s: Span) -> IResult { alt(( map(module_declaration, |x| Description::ModuleDeclaration(x)), @@ -458,6 +460,7 @@ pub fn description(s: Span) -> IResult { ))(s) } +#[trace] pub fn description_package_item(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = package_item(s)?; @@ -467,6 +470,7 @@ pub fn description_package_item(s: Span) -> IResult { )) } +#[trace] pub fn description_bind_directive(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = bind_directive(s)?; @@ -476,6 +480,7 @@ pub fn description_bind_directive(s: Span) -> IResult { )) } +#[trace] pub fn module_nonansi_header(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = module_keyword(s)?; @@ -493,6 +498,7 @@ pub fn module_nonansi_header(s: Span) -> IResult { )) } +#[trace] pub fn module_ansi_header(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = module_keyword(s)?; @@ -510,6 +516,7 @@ pub fn module_ansi_header(s: Span) -> IResult { )) } +#[trace] pub fn module_declaration(s: Span) -> IResult { alt(( module_declaration_nonansi, @@ -520,6 +527,7 @@ pub fn module_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn module_declaration_nonansi(s: Span) -> IResult { let (s, a) = module_nonansi_header(s)?; let (s, b) = opt(timeunits_declaration)(s)?; @@ -534,6 +542,7 @@ pub fn module_declaration_nonansi(s: Span) -> IResult { )) } +#[trace] pub fn module_declaration_ansi(s: Span) -> IResult { let (s, a) = module_ansi_header(s)?; let (s, b) = opt(timeunits_declaration)(s)?; @@ -548,6 +557,7 @@ pub fn module_declaration_ansi(s: Span) -> IResult { )) } +#[trace] pub fn module_declaration_wildcard(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = module_keyword(s)?; @@ -567,6 +577,7 @@ pub fn module_declaration_wildcard(s: Span) -> IResult )) } +#[trace] pub fn module_declaration_extern_nonansi(s: Span) -> IResult { let (s, a) = symbol("extern")(s)?; let (s, b) = module_nonansi_header(s)?; @@ -576,6 +587,7 @@ pub fn module_declaration_extern_nonansi(s: Span) -> IResult IResult { let (s, a) = symbol("extern")(s)?; let (s, b) = module_ansi_header(s)?; @@ -585,6 +597,7 @@ pub fn module_declaration_extern_ansi(s: Span) -> IResult IResult { alt(( map(symbol("module"), |x| ModuleKeyword::Module(x)), @@ -592,6 +605,7 @@ pub fn module_keyword(s: Span) -> IResult { ))(s) } +#[trace] pub fn interface_declaration(s: Span) -> IResult { alt(( interface_declaration_nonansi, @@ -602,6 +616,7 @@ pub fn interface_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn interface_declaration_nonansi(s: Span) -> IResult { let (s, a) = interface_nonansi_header(s)?; let (s, b) = opt(timeunits_declaration)(s)?; @@ -616,6 +631,7 @@ pub fn interface_declaration_nonansi(s: Span) -> IResult IResult { let (s, a) = interface_ansi_header(s)?; let (s, b) = opt(timeunits_declaration)(s)?; @@ -630,6 +646,7 @@ pub fn interface_declaration_ansi(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol("interface")(s)?; @@ -649,6 +666,7 @@ pub fn interface_declaration_wildcard(s: Span) -> IResult IResult { let (s, a) = symbol("extern")(s)?; let (s, b) = interface_nonansi_header(s)?; @@ -658,6 +676,7 @@ pub fn interface_declaration_extern_nonansi(s: Span) -> IResult IResult { let (s, a) = symbol("extern")(s)?; let (s, b) = interface_ansi_header(s)?; @@ -667,6 +686,7 @@ pub fn interface_declaration_extern_ansi(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol("interface")(s)?; @@ -684,6 +704,7 @@ pub fn interface_nonansi_header(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol("interface")(s)?; @@ -701,6 +722,7 @@ pub fn interface_ansi_header(s: Span) -> IResult { )) } +#[trace] pub fn program_declaration(s: Span) -> IResult { alt(( program_declaration_nonansi, @@ -711,6 +733,7 @@ pub fn program_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn program_declaration_nonansi(s: Span) -> IResult { let (s, a) = program_nonansi_header(s)?; let (s, b) = opt(timeunits_declaration)(s)?; @@ -725,6 +748,7 @@ pub fn program_declaration_nonansi(s: Span) -> IResult )) } +#[trace] pub fn program_declaration_ansi(s: Span) -> IResult { let (s, a) = program_ansi_header(s)?; let (s, b) = opt(timeunits_declaration)(s)?; @@ -739,6 +763,7 @@ pub fn program_declaration_ansi(s: Span) -> IResult { )) } +#[trace] pub fn program_declaration_wildcard(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol("program")(s)?; @@ -757,6 +782,7 @@ pub fn program_declaration_wildcard(s: Span) -> IResult IResult { let (s, a) = symbol("extern")(s)?; let (s, b) = program_nonansi_header(s)?; @@ -766,6 +792,7 @@ pub fn program_declaration_extern_nonansi(s: Span) -> IResult IResult { let (s, a) = symbol("extern")(s)?; let (s, b) = program_ansi_header(s)?; @@ -775,6 +802,7 @@ pub fn program_declaration_extern_ansi(s: Span) -> IResult IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol("prgogram")(s)?; @@ -792,6 +820,7 @@ pub fn program_nonansi_header(s: Span) -> IResult { )) } +#[trace] pub fn program_ansi_header(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol("program")(s)?; @@ -809,6 +838,7 @@ pub fn program_ansi_header(s: Span) -> IResult { )) } +#[trace] pub fn checker_declaration(s: Span) -> IResult { let (s, a) = symbol("checker")(s)?; let (s, b) = checker_identifier(s)?; @@ -825,6 +855,7 @@ pub fn checker_declaration(s: Span) -> IResult { )) } +#[trace] pub fn class_declaration(s: Span) -> IResult { let (s, a) = opt(map(symbol("virtual"), |x| Virtual { nodes: (x,) }))(s)?; let (s, b) = symbol("class")(s)?; @@ -852,12 +883,14 @@ pub fn class_declaration(s: Span) -> IResult { )) } +#[trace] pub fn interface_class_type(s: Span) -> IResult { let (s, a) = ps_class_identifier(s)?; let (s, b) = opt(parameter_value_assignment)(s)?; Ok((s, InterfaceClassType { nodes: (a, b) })) } +#[trace] pub fn interface_class_declaration(s: Span) -> IResult { let (s, a) = symbol("interface")(s)?; let (s, b) = symbol("class")(s)?; @@ -879,6 +912,7 @@ pub fn interface_class_declaration(s: Span) -> IResult IResult { alt(( map(type_declaration, |x| InterfaceClassItem::TypeDeclaration(x)), @@ -893,6 +927,7 @@ pub fn interface_class_item(s: Span) -> IResult { ))(s) } +#[trace] pub fn interface_class_item_method(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = interface_class_method(s)?; @@ -902,6 +937,7 @@ pub fn interface_class_item_method(s: Span) -> IResult )) } +#[trace] pub fn interface_class_method(s: Span) -> IResult { let (s, a) = symbol("pure")(s)?; let (s, b) = symbol("virtual")(s)?; @@ -915,6 +951,7 @@ pub fn interface_class_method(s: Span) -> IResult { )) } +#[trace] pub fn package_declaration(s: Span) -> IResult { let (s, a) = many0(attribute_instance)(s)?; let (s, b) = symbol("package")(s)?; @@ -933,6 +970,7 @@ pub fn package_declaration(s: Span) -> IResult { )) } +#[trace] pub fn timeunits_declaration(s: Span) -> IResult { alt(( timeunits_declaration_timeunit_timeprecision, @@ -942,6 +980,7 @@ pub fn timeunits_declaration(s: Span) -> IResult { ))(s) } +#[trace] pub fn timeunits_declaration_timeunit(s: Span) -> IResult { let (s, a) = symbol("timeunit")(s)?; let (s, b) = time_literal(s)?; @@ -955,6 +994,7 @@ pub fn timeunits_declaration_timeunit(s: Span) -> IResult IResult { let (s, a) = symbol("timeprecision")(s)?; let (s, b) = time_literal(s)?; @@ -965,6 +1005,7 @@ pub fn timeunits_declaration_timeprecision(s: Span) -> IResult IResult { @@ -982,6 +1023,7 @@ pub fn timeunits_declaration_timeunit_timeprecision( )) } +#[trace] pub fn timeunits_declaration_timeprecision_timeunit( s: Span, ) -> IResult { diff --git a/src/parser/specify_section/specify_block_declaration.rs b/src/parser/specify_section/specify_block_declaration.rs index e860c8a..4d2e0a7 100644 --- a/src/parser/specify_section/specify_block_declaration.rs +++ b/src/parser/specify_section/specify_block_declaration.rs @@ -14,6 +14,7 @@ pub struct SpecifyBlock<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn specify_block(s: Span) -> IResult { Err(Err::Error(make_error(s, ErrorKind::Fix))) } diff --git a/src/parser/specify_section/specify_block_terminals.rs b/src/parser/specify_section/specify_block_terminals.rs index 71e52b7..4bfbae0 100644 --- a/src/parser/specify_section/specify_block_terminals.rs +++ b/src/parser/specify_section/specify_block_terminals.rs @@ -43,20 +43,24 @@ pub struct OutputIdentifierInterface<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn specify_input_terminal_descriptor(s: Span) -> IResult { Err(Err::Error(make_error(s, ErrorKind::Fix))) } +#[trace] pub fn specify_output_terminal_descriptor( s: Span, ) -> IResult { Err(Err::Error(make_error(s, ErrorKind::Fix))) } +#[trace] pub fn input_identifier(s: Span) -> IResult { Err(Err::Error(make_error(s, ErrorKind::Fix))) } +#[trace] pub fn output_identifier(s: Span) -> IResult { Err(Err::Error(make_error(s, ErrorKind::Fix))) } diff --git a/src/parser/specify_section/specify_path_delays.rs b/src/parser/specify_section/specify_path_delays.rs index b3aff1d..3c71a01 100644 --- a/src/parser/specify_section/specify_path_delays.rs +++ b/src/parser/specify_section/specify_path_delays.rs @@ -14,6 +14,7 @@ pub struct EdgeIdentifier<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn edge_identifier(s: Span) -> IResult { Err(Err::Error(make_error(s, ErrorKind::Fix))) } diff --git a/src/parser/udp_declaration_and_instantiation/udp_declaration.rs b/src/parser/udp_declaration_and_instantiation/udp_declaration.rs index a7175a4..fbf0c0a 100644 --- a/src/parser/udp_declaration_and_instantiation/udp_declaration.rs +++ b/src/parser/udp_declaration_and_instantiation/udp_declaration.rs @@ -14,6 +14,7 @@ pub struct UdpDeclaration<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn udp_declaration(s: Span) -> IResult { Err(Err::Error(make_error(s, ErrorKind::Fix))) } diff --git a/src/parser/udp_declaration_and_instantiation/udp_instantiation.rs b/src/parser/udp_declaration_and_instantiation/udp_instantiation.rs index 3a95d70..9a98732 100644 --- a/src/parser/udp_declaration_and_instantiation/udp_instantiation.rs +++ b/src/parser/udp_declaration_and_instantiation/udp_instantiation.rs @@ -36,6 +36,7 @@ pub struct UdpInstance<'a> { // ----------------------------------------------------------------------------- +#[trace] pub fn udp_instantiation(s: Span) -> IResult { let (s, a) = udp_identifier(s)?; let (s, b) = opt(drive_strength)(s)?; @@ -50,6 +51,7 @@ pub fn udp_instantiation(s: Span) -> IResult { )) } +#[trace] pub fn udp_instance(s: Span) -> IResult { let (s, a) = opt(name_of_instance)(s)?; let (s, b) = paren(tuple(( diff --git a/src/parser/utils.rs b/src/parser/utils.rs index a1c45d7..6c8a7b2 100644 --- a/src/parser/utils.rs +++ b/src/parser/utils.rs @@ -60,7 +60,19 @@ where } pub fn symbol<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult, Symbol<'a>> { - move |s: Span<'a>| map(ws(tag(t.clone())), |x| Symbol { nodes: x })(s) + move |s: Span<'a>| { + if cfg!(feature = "trace") { + println!( + "{:<48} : {:<4},{:>032x} : {}", + format!("symbol(\"{}\")", t), + s.offset, + s.extra, + s.fragment + ); + } + let (s, x) = map(ws(tag(t.clone())), |x| Symbol { nodes: x })(s)?; + Ok((clear_bit(s), x)) + } } pub fn paren<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult, Paren> @@ -68,6 +80,12 @@ where F: Fn(Span<'a>) -> IResult, O>, { move |s: Span<'a>| { + if cfg!(feature = "trace") { + println!( + "{:<48} : {:<4},{:>032x} : {}", + "paren", s.offset, s.extra, s.fragment + ); + } let (s, a) = symbol("(")(s)?; let (s, b) = f(s)?; let (s, c) = symbol(")")(s)?; @@ -80,6 +98,12 @@ where F: Fn(Span<'a>) -> IResult, O>, { move |s: Span<'a>| { + if cfg!(feature = "trace") { + println!( + "{:<48} : {:<4},{:>032x} : {}", + "bracket", s.offset, s.extra, s.fragment + ); + } let (s, a) = symbol("[")(s)?; let (s, b) = f(s)?; let (s, c) = symbol("]")(s)?; @@ -92,6 +116,12 @@ where F: Fn(Span<'a>) -> IResult, O>, { move |s: Span<'a>| { + if cfg!(feature = "trace") { + println!( + "{:<48} : {:<4},{:>032x} : {}", + "brace", s.offset, s.extra, s.fragment + ); + } let (s, a) = symbol("{")(s)?; let (s, b) = f(s)?; let (s, c) = symbol("}")(s)?; @@ -106,6 +136,12 @@ where F: Fn(Span<'a>) -> IResult, O>, { move |s: Span<'a>| { + if cfg!(feature = "trace") { + println!( + "{:<48} : {:<4},{:>032x} : {}", + "apostrophe_brace", s.offset, s.extra, s.fragment + ); + } let (s, a) = symbol("'{")(s)?; let (s, b) = f(s)?; let (s, c) = symbol("}")(s)?; @@ -135,20 +171,20 @@ where } } -pub fn rec<'a, O, F>(f: F, id: u32) -> impl Fn(Span<'a>) -> IResult, O> -where - F: Fn(Span<'a>) -> IResult, O>, -{ - move |s: Span<'a>| { - if check_bit(s, id) { - return Err(Err::Error(make_error(s, ErrorKind::Fix))); - } - let s = set_bit(s, id, true); - let (s, x) = f(s)?; - let s = set_bit(s, id, false); - Ok((s, x)) - } -} +//pub fn rec<'a, O, F>(f: F, id: u32) -> impl Fn(Span<'a>) -> IResult, O> +//where +// F: Fn(Span<'a>) -> IResult, O>, +//{ +// move |s: Span<'a>| { +// if check_bit(s, id) { +// return Err(Err::Error(make_error(s, ErrorKind::Fix))); +// } +// let s = set_bit(s, id, true); +// let (s, x) = f(s)?; +// let s = set_bit(s, id, false); +// Ok((s, x)) +// } +//} pub fn triple<'a, O1, O2, O3, F, G, H>( f: F, @@ -170,6 +206,7 @@ where // ----------------------------------------------------------------------------- +#[trace] pub fn white_space(s: Span) -> IResult { alt(( map(multispace1, |x| WhiteSpace::Space(x)), @@ -198,8 +235,8 @@ pub fn check_bit(s: Span, id: u32) -> bool { } pub fn set_bit(s: Span, id: u32, bit: bool) -> Span { - let val = if bit { 1u64 << id } else { 0u64 }; - let mask = !(1u64 << id); + let val = if bit { 1u128 << id } else { 0u128 }; + let mask = !(1u128 << id); let val = (s.extra & mask) | val; Span { offset: s.offset, @@ -209,6 +246,15 @@ pub fn set_bit(s: Span, id: u32, bit: bool) -> Span { } } +pub fn clear_bit(s: Span) -> Span { + Span { + offset: s.offset, + line: s.line, + fragment: s.fragment, + extra: 0, + } +} + // ----------------------------------------------------------------------------- #[cfg(test)] @@ -221,3 +267,14 @@ macro_rules! parser_test { } }; } + +//macro_rules! s { +// ( $x:expr ) => { +// Span { +// offset: $x.offset, +// line: $x.line, +// fragment: $x.fragment, +// extra: (file!(), line!(), column!()), +// } +// }; +//}