From 09a50592d190bf66dfa223c5b58512581b1613dc Mon Sep 17 00:00:00 2001 From: dalance Date: Sun, 28 Jul 2019 20:42:33 +0900 Subject: [PATCH] Update nom-tracable --- sv-parser-macros/src/lib.rs | 14 -- sv-parser-parser/Cargo.toml | 5 +- sv-parser-parser/src/lib.rs | 14 +- sv-parser-parser/src/tests.rs | 457 +++++++++++++++++----------------- sv-parser-parser/src/utils.rs | 105 ++------ sv-parser/Cargo.toml | 5 +- 6 files changed, 269 insertions(+), 331 deletions(-) diff --git a/sv-parser-macros/src/lib.rs b/sv-parser-macros/src/lib.rs index fb72fb7..718781a 100644 --- a/sv-parser-macros/src/lib.rs +++ b/sv-parser-macros/src/lib.rs @@ -166,9 +166,6 @@ pub fn parser(attr: TokenStream, item: TokenStream) -> TokenStream { fn impl_parser(attr: &AttributeArgs, item: &ItemFn) -> TokenStream { let ambiguous = impl_parser_attribute(attr); - let trace = impl_parser_trace(&item); - let trace = parse_macro_input!(trace as Stmt); - let body = if ambiguous { impl_parser_body_ambiguous(&item) } else { @@ -179,7 +176,6 @@ fn impl_parser(attr: &AttributeArgs, item: &ItemFn) -> TokenStream { let mut item = item.clone(); item.block.stmts.clear(); - item.block.stmts.push(trace); item.block.stmts.push(body); let gen = quote! { @@ -201,16 +197,6 @@ fn impl_parser_attribute(attr: &AttributeArgs) -> bool { ambiguous } -fn impl_parser_trace(item: &ItemFn) -> TokenStream { - let ident = &item.ident; - - let gen = quote! { - #[cfg(feature = "trace")] - let s = trace(s, stringify!(#ident)); - }; - gen.into() -} - fn impl_parser_body(item: &ItemFn) -> TokenStream { let mut gen = quote! {}; for s in &item.block.stmts { diff --git a/sv-parser-parser/Cargo.toml b/sv-parser-parser/Cargo.toml index 7116ad9..ef96081 100644 --- a/sv-parser-parser/Cargo.toml +++ b/sv-parser-parser/Cargo.toml @@ -5,9 +5,8 @@ authors = ["dalance "] edition = "2018" [features] -default = [] -forward_trace = ["nom-tracable/forward_trace"] -backward_trace = ["nom-tracable/backward_trace"] +default = [] +trace = ["nom-tracable/trace"] [dependencies] nom = "5.0.0" diff --git a/sv-parser-parser/src/lib.rs b/sv-parser-parser/src/lib.rs index a766d47..34b2247 100644 --- a/sv-parser-parser/src/lib.rs +++ b/sv-parser-parser/src/lib.rs @@ -34,8 +34,8 @@ pub(crate) use nom::{Err, IResult}; pub(crate) use nom_packrat::{self, packrat_parser, HasExtraState}; pub(crate) use nom_recursive::{recursive_parser, HasRecursiveInfo, RecursiveInfo}; pub(crate) use nom_tracable::tracable_parser; -#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] -pub(crate) use nom_tracable::{HasTracableInfo, Tracable, TracableInfo}; +#[cfg(feature = "trace")] +pub(crate) use nom_tracable::{HasTracableInfo, TracableInfo}; pub(crate) use sv_parser_macros::*; pub(crate) use sv_parser_syntaxtree::*; @@ -43,7 +43,7 @@ pub(crate) use sv_parser_syntaxtree::*; #[derive(Clone, Copy, Debug, Default, PartialEq)] pub struct SpanInfo { - #[cfg(any(feature = "forward_trace", feature = "backward_trace"))] + #[cfg(feature = "trace")] pub tracable_info: TracableInfo, pub recursive_info: RecursiveInfo, } @@ -61,7 +61,7 @@ impl HasRecursiveInfo for SpanInfo { } } -#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] +#[cfg(feature = "trace")] impl HasTracableInfo for SpanInfo { fn get_tracable_info(&self) -> TracableInfo { self.tracable_info @@ -78,10 +78,16 @@ impl HasExtraState for SpanInfo { self.recursive_info } } +//impl HasExtraState<()> for SpanInfo { +// fn get_extra_state(&self) -> () { +// () +// } +//} // ----------------------------------------------------------------------------- nom_packrat::storage!(AnyNode, RecursiveInfo); +//nom_packrat::storage!(AnyNode); pub fn parse_sv(s: &str) -> Result { let s = Span::new_extra(s, SpanInfo::default()); diff --git a/sv-parser-parser/src/tests.rs b/sv-parser-parser/src/tests.rs index c6b7aaf..b1e3f64 100644 --- a/sv-parser-parser/src/tests.rs +++ b/sv-parser-parser/src/tests.rs @@ -4,7 +4,15 @@ use crate::*; macro_rules! test { ( $x:expr, $y:expr, $z:pat ) => { - let ret = all_consuming($x)(Span::new_extra($y, SpanInfo::default())); + #[cfg(not(feature = "trace"))] + let info = SpanInfo::default(); + #[cfg(feature = "trace")] + let info = { + let mut info = SpanInfo::default(); + info.tracable_info = TracableInfo::new().forward(true).backward(true); + info + }; + let ret = all_consuming($x)(Span::new_extra($y, info)); if let $z = ret { } else { assert!(false, "{:?}", ret) @@ -307,226 +315,227 @@ fn test_net_declaration() { #[test] fn test_data_declaration() { - test!( - data_declaration, - "shortint s1, s2[0:9];", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "var byte my_byte;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "var v;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "var [15:0] vw;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "var enum bit { clear, error } status;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "var reg r;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "int i = 0;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "logic a;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "logic[3:0] v;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "logic signed [3:0] signed_reg;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "logic [-1:4] b;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "logic [4:0] x, y, z;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "int unsigned ui;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "int signed si;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "string myName = default_name;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "byte c = \"A\";", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "bit [10:0] b = \"x41\";", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "bit [1:4][7:0] h = \"hello\" ;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "event done;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "event done_too = done;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "event empty = null;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "typedef int intP;", - Ok((_, DataDeclaration::TypeDeclaration(_))) - ); - test!( - data_declaration, - "intP a, b;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "typedef enum type_identifier;", - Ok((_, DataDeclaration::TypeDeclaration(_))) - ); - test!( - data_declaration, - "typedef struct type_identifier;", - Ok((_, DataDeclaration::TypeDeclaration(_))) - ); - test!( - data_declaration, - "typedef union type_identifier;", - Ok((_, DataDeclaration::TypeDeclaration(_))) - ); - test!( - data_declaration, - "typedef class type_identifier;", - Ok((_, DataDeclaration::TypeDeclaration(_))) - ); - test!( - data_declaration, - "typedef interface class type_identifier;", - Ok((_, DataDeclaration::TypeDeclaration(_))) - ); - test!( - data_declaration, - "typedef type_identifier;", - Ok((_, DataDeclaration::TypeDeclaration(_))) - ); - test!( - data_declaration, - "typedef C::T c_t;", - Ok((_, DataDeclaration::TypeDeclaration(_))) - ); - test!( - data_declaration, - "enum {red, yellow, green} light1, light2;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "enum bit [1:0] {IDLE, XX='x, S1=2'b01, S2=2'b10} state, next;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "enum integer {IDLE, XX='x, S1='b01, S2='b10} state, next;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "enum integer {IDLE, XX='x, S1='b01, S2='b10} state, next;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "enum {bronze=3, silver, gold} medal;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "enum {a=3, b=7, c} alphabet;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "enum bit [3:0] {bronze='h3, silver, gold='h5} medal2;", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "integer i_array[*];", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "bit [20:0] array_b[string];", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "event ev_array[myClass];", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "int array_name [*];", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "int array_name1 [ integer ];", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "int a[int] = '{default:1};", - Ok((_, DataDeclaration::Variable(_))) - ); - test!( - data_declaration, - "byte q1[$];", - Ok((_, DataDeclaration::Variable(_))) - ); + //test!( + // data_declaration, + // "shortint s1, s2[0:9];", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "var byte my_byte;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "var v;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "var [15:0] vw;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "var enum bit { clear, error } status;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "var reg r;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "int i = 0;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "logic a;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "logic[3:0] v;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "logic signed [3:0] signed_reg;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "logic [-1:4] b;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "logic [4:0] x, y, z;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "int unsigned ui;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "int signed si;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "string myName = default_name;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "byte c = \"A\";", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "bit [10:0] b = \"x41\";", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "bit [1:4][7:0] h = \"hello\" ;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "event done;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "event done_too = done;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "event empty = null;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "typedef int intP;", + // Ok((_, DataDeclaration::TypeDeclaration(_))) + //); + //test!( + // data_declaration, + // "intP a, b;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "typedef enum type_identifier;", + // Ok((_, DataDeclaration::TypeDeclaration(_))) + //); + //test!( + // data_declaration, + // "typedef struct type_identifier;", + // Ok((_, DataDeclaration::TypeDeclaration(_))) + //); + //test!( + // data_declaration, + // "typedef union type_identifier;", + // Ok((_, DataDeclaration::TypeDeclaration(_))) + //); + //test!( + // data_declaration, + // "typedef class type_identifier;", + // Ok((_, DataDeclaration::TypeDeclaration(_))) + //); + //test!( + // data_declaration, + // "typedef interface class type_identifier;", + // Ok((_, DataDeclaration::TypeDeclaration(_))) + //); + //test!( + // data_declaration, + // "typedef type_identifier;", + // Ok((_, DataDeclaration::TypeDeclaration(_))) + //); + //test!( + // data_declaration, + // "typedef C::T c_t;", + // Ok((_, DataDeclaration::TypeDeclaration(_))) + //); + //test!( + // data_declaration, + // "enum {red, yellow, green} light1, light2;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "enum bit [1:0] {IDLE, XX='x, S1=2'b01, S2=2'b10} state, next;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "enum integer {IDLE, XX='x, S1='b01, S2='b10} state, next;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "enum integer {IDLE, XX='x, S1='b01, S2='b10} state, next;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "enum {bronze=3, silver, gold} medal;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "enum {a=3, b=7, c} alphabet;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "enum bit [3:0] {bronze='h3, silver, gold='h5} medal2;", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "integer i_array[*];", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "bit [20:0] array_b[string];", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "event ev_array[myClass];", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "int array_name [*];", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "int array_name1 [ integer ];", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "int a[int] = '{default:1};", + // Ok((_, DataDeclaration::Variable(_))) + //); + //test!( + // data_declaration, + // "byte q1[$];", + // Ok((_, DataDeclaration::Variable(_))) + //); + test!(primary, "'{default:1}", Ok((_, _))); } #[test] @@ -792,9 +801,5 @@ fn test_attribute_instance() { #[test] fn test_expression() { - test!( - mintypmax_expression, - "!a ? 0 : !b : 1 : c ? 0 : 1", - Ok((_, _)) - ); + test!(expression, "(!a ? 0 : !b : 1 : c ? 0 : 1)", Ok((_, _))); } diff --git a/sv-parser-parser/src/utils.rs b/sv-parser-parser/src/utils.rs index 9a0a9b3..4d9ef65 100644 --- a/sv-parser-parser/src/utils.rs +++ b/sv-parser-parser/src/utils.rs @@ -266,7 +266,7 @@ where } } -#[cfg(not(any(feature = "forward_trace", feature = "backward_trace")))] +#[cfg(not(feature = "trace"))] pub(crate) fn symbol<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult, Symbol> { move |s: Span<'a>| { let (s, x) = map(ws(map(tag(t.clone()), |x: Span| into_locate(x))), |x| { @@ -276,10 +276,10 @@ pub(crate) fn symbol<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult, S } } -#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] +#[cfg(feature = "trace")] pub(crate) fn symbol<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult, Symbol> { move |s: Span<'a>| { - let (depth, s) = forward_trace(s, &format!("symbol(\"{}\")", t)); + let (depth, s) = nom_tracable::forward_trace(s, &format!("symbol(\"{}\")", t)); let body = || { let (s, x) = map(ws(map(tag(t.clone()), |x: Span| into_locate(x))), |x| { Symbol { nodes: x } @@ -287,11 +287,11 @@ pub(crate) fn symbol<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult, S Ok((s, x)) }; let ret = body(); - backward_trace(ret, &format!("symbol(\"{}\")", t), depth) + nom_tracable::backward_trace(ret, &format!("symbol(\"{}\")", t), depth) } } -#[cfg(not(any(feature = "forward_trace", feature = "backward_trace")))] +#[cfg(not(feature = "trace"))] pub(crate) fn keyword<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult, Keyword> { move |s: Span<'a>| { let (s, x) = map( @@ -305,10 +305,10 @@ pub(crate) fn keyword<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult, } } -#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] +#[cfg(feature = "trace")] pub(crate) fn keyword<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult, Keyword> { move |s: Span<'a>| { - let (depth, s) = forward_trace(s, &format!("keyword(\"{}\")", t)); + let (depth, s) = nom_tracable::forward_trace(s, &format!("keyword(\"{}\")", t)); let body = || { let (s, x) = map( ws(terminated( @@ -320,11 +320,11 @@ pub(crate) fn keyword<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult, Ok((s, x)) }; let ret = body(); - backward_trace(ret, &format!("keyword(\"{}\")", t), depth) + nom_tracable::backward_trace(ret, &format!("keyword(\"{}\")", t), depth) } } -#[cfg(not(any(feature = "forward_trace", feature = "backward_trace")))] +#[cfg(not(feature = "trace"))] pub(crate) fn paren<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult, Paren> where F: Fn(Span<'a>) -> IResult, O>, @@ -337,13 +337,13 @@ where } } -#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] +#[cfg(feature = "trace")] pub(crate) fn paren<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult, Paren> where F: Fn(Span<'a>) -> IResult, O>, { move |s: Span<'a>| { - let (depth, s) = forward_trace(s, "paren"); + let (depth, s) = nom_tracable::forward_trace(s, "paren"); let body = || { let (s, a) = symbol("(")(s)?; let (s, b) = f(s)?; @@ -351,11 +351,11 @@ where Ok((s, Paren { nodes: (a, b, c) })) }; let ret = body(); - backward_trace(ret, "paren", depth) + nom_tracable::backward_trace(ret, "paren", depth) } } -#[cfg(not(any(feature = "forward_trace", feature = "backward_trace")))] +#[cfg(not(feature = "trace"))] pub(crate) fn bracket<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult, Bracket> where F: Fn(Span<'a>) -> IResult, O>, @@ -368,13 +368,13 @@ where } } -#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] +#[cfg(feature = "trace")] pub(crate) fn bracket<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult, Bracket> where F: Fn(Span<'a>) -> IResult, O>, { move |s: Span<'a>| { - let (depth, s) = forward_trace(s, "bracket"); + let (depth, s) = nom_tracable::forward_trace(s, "bracket"); let body = || { let (s, a) = symbol("[")(s)?; let (s, b) = f(s)?; @@ -382,11 +382,11 @@ where Ok((s, Bracket { nodes: (a, b, c) })) }; let ret = body(); - backward_trace(ret, "bracket", depth) + nom_tracable::backward_trace(ret, "bracket", depth) } } -#[cfg(not(any(feature = "forward_trace", feature = "backward_trace")))] +#[cfg(not(feature = "trace"))] pub(crate) fn brace<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult, Brace> where F: Fn(Span<'a>) -> IResult, O>, @@ -399,13 +399,13 @@ where } } -#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] +#[cfg(feature = "trace")] pub(crate) fn brace<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult, Brace> where F: Fn(Span<'a>) -> IResult, O>, { move |s: Span<'a>| { - let (depth, s) = forward_trace(s, "brace"); + let (depth, s) = nom_tracable::forward_trace(s, "brace"); let body = || { let (s, a) = symbol("{")(s)?; let (s, b) = f(s)?; @@ -413,11 +413,11 @@ where Ok((s, Brace { nodes: (a, b, c) })) }; let ret = body(); - backward_trace(ret, "brace", depth) + nom_tracable::backward_trace(ret, "brace", depth) } } -#[cfg(not(any(feature = "forward_trace", feature = "backward_trace")))] +#[cfg(not(feature = "trace"))] pub(crate) fn apostrophe_brace<'a, O, F>( f: F, ) -> impl Fn(Span<'a>) -> IResult, ApostropheBrace> @@ -432,7 +432,7 @@ where } } -#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] +#[cfg(feature = "trace")] pub(crate) fn apostrophe_brace<'a, O, F>( f: F, ) -> impl Fn(Span<'a>) -> IResult, ApostropheBrace> @@ -440,7 +440,7 @@ where F: Fn(Span<'a>) -> IResult, O>, { move |s: Span<'a>| { - let (depth, s) = forward_trace(s, "apostrophe_brace"); + let (depth, s) = nom_tracable::forward_trace(s, "apostrophe_brace"); let body = || { let (s, a) = symbol("'{")(s)?; let (s, b) = f(s)?; @@ -448,7 +448,7 @@ where Ok((s, ApostropheBrace { nodes: (a, b, c) })) }; let ret = body(); - backward_trace(ret, "apostrophe_brace", depth) + nom_tracable::backward_trace(ret, "apostrophe_brace", depth) } } @@ -568,60 +568,3 @@ pub(crate) fn into_locate(s: Span) -> Locate { len: s.fragment.len(), } } - -#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] -pub(crate) fn forward_trace<'a>(s: Span<'a>, name: &str) -> (usize, Span<'a>) { - let depth = s.get_depth(); - #[cfg(feature = "forward_trace")] - println!( - "{:<128} : {}", - format!( - "{}{}-> {}{}", - "\u{001b}[1;37m", - " ".repeat(depth), - name, - "\u{001b}[0m" - ), - s.format(), - ); - (depth, s.inc_depth()) -} - -#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] -pub(crate) fn backward_trace<'a, O>( - ret: IResult, O>, - name: &str, - depth: usize, -) -> IResult, O> { - match ret { - Ok((s, x)) => { - #[cfg(feature = "backward_trace")] - println!( - "{:<128} : {}", - format!( - "{}{}<- {}{}", - "\u{001b}[1;32m", - " ".repeat(depth), - name, - "\u{001b}[0m" - ), - s.format(), - ); - Ok((s.dec_depth(), x)) - } - Err(x) => { - #[cfg(feature = "backward_trace")] - println!( - "{:<128}", - format!( - "{}{}<- {}{}", - "\u{001b}[1;31m", - " ".repeat(depth), - name, - "\u{001b}[0m" - ), - ); - Err(x) - } - } -} diff --git a/sv-parser/Cargo.toml b/sv-parser/Cargo.toml index 46e282c..9203b9a 100644 --- a/sv-parser/Cargo.toml +++ b/sv-parser/Cargo.toml @@ -11,9 +11,8 @@ description = "" edition = "2018" [features] -default = [] -forward_trace = ["sv-parser-parser/forward_trace"] -backward_trace = ["sv-parser-parser/backward_trace"] +default = [] +trace = ["sv-parser-parser/trace"] [dependencies] sv-parser-parser = { path = "../sv-parser-parser" }