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

Update nom-tracable

Browse Source
This commit is contained in:
dalance 2019-07-28 20:42:33 +09:00
parent 619c2ff63b
commit 09a50592d1
6 changed files with 269 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -166,9 +166,6 @@ pub fn parser(attr: TokenStream, item: TokenStream) -> TokenStream {
fn impl_parser(attr: &AttributeArgs, item: &ItemFn) -> TokenStream { fn impl_parser(attr: &AttributeArgs, item: &ItemFn) -> TokenStream {
let ambiguous = impl_parser_attribute(attr); let ambiguous = impl_parser_attribute(attr);
let trace = impl_parser_trace(&item);
let trace = parse_macro_input!(trace as Stmt);
let body = if ambiguous { let body = if ambiguous {
impl_parser_body_ambiguous(&item) impl_parser_body_ambiguous(&item)
} else { } else {
@ -179,7 +176,6 @@ fn impl_parser(attr: &AttributeArgs, item: &ItemFn) -> TokenStream {
let mut item = item.clone(); let mut item = item.clone();
item.block.stmts.clear(); item.block.stmts.clear();
item.block.stmts.push(trace);
item.block.stmts.push(body); item.block.stmts.push(body);
let gen = quote! { let gen = quote! {
@ -201,16 +197,6 @@ fn impl_parser_attribute(attr: &AttributeArgs) -> bool {
ambiguous 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 { fn impl_parser_body(item: &ItemFn) -> TokenStream {
let mut gen = quote! {}; let mut gen = quote! {};
for s in &item.block.stmts { for s in &item.block.stmts {

3
sv-parser-parser/Cargo.toml
View File

@ -6,8 +6,7 @@ edition = "2018"
[features] [features]
default = [] default = []
forward_trace = ["nom-tracable/forward_trace"] trace = ["nom-tracable/trace"]
backward_trace = ["nom-tracable/backward_trace"]
[dependencies] [dependencies]
nom = "5.0.0" nom = "5.0.0"

14
sv-parser-parser/src/lib.rs
View File

@ -34,8 +34,8 @@ pub(crate) use nom::{Err, IResult};
pub(crate) use nom_packrat::{self, packrat_parser, HasExtraState}; pub(crate) use nom_packrat::{self, packrat_parser, HasExtraState};
pub(crate) use nom_recursive::{recursive_parser, HasRecursiveInfo, RecursiveInfo}; pub(crate) use nom_recursive::{recursive_parser, HasRecursiveInfo, RecursiveInfo};
pub(crate) use nom_tracable::tracable_parser; pub(crate) use nom_tracable::tracable_parser;
#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] #[cfg(feature = "trace")]
pub(crate) use nom_tracable::{HasTracableInfo, Tracable, TracableInfo}; pub(crate) use nom_tracable::{HasTracableInfo, TracableInfo};
pub(crate) use sv_parser_macros::*; pub(crate) use sv_parser_macros::*;
pub(crate) use sv_parser_syntaxtree::*; pub(crate) use sv_parser_syntaxtree::*;
@ -43,7 +43,7 @@ pub(crate) use sv_parser_syntaxtree::*;
#[derive(Clone, Copy, Debug, Default, PartialEq)] #[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct SpanInfo { pub struct SpanInfo {
#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] #[cfg(feature = "trace")]
pub tracable_info: TracableInfo, pub tracable_info: TracableInfo,
pub recursive_info: RecursiveInfo, 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 { impl HasTracableInfo for SpanInfo {
fn get_tracable_info(&self) -> TracableInfo { fn get_tracable_info(&self) -> TracableInfo {
self.tracable_info self.tracable_info
@ -78,10 +78,16 @@ impl HasExtraState<RecursiveInfo> for SpanInfo {
self.recursive_info self.recursive_info
} }
} }
//impl HasExtraState<()> for SpanInfo {
// fn get_extra_state(&self) -> () {
// ()
// }
//}
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
nom_packrat::storage!(AnyNode, RecursiveInfo); nom_packrat::storage!(AnyNode, RecursiveInfo);
//nom_packrat::storage!(AnyNode);
pub fn parse_sv(s: &str) -> Result<SourceText, ()> { pub fn parse_sv(s: &str) -> Result<SourceText, ()> {
let s = Span::new_extra(s, SpanInfo::default()); let s = Span::new_extra(s, SpanInfo::default());

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

@ -4,7 +4,15 @@ use crate::*;
macro_rules! test { macro_rules! test {
( $x:expr, $y:expr, $z:pat ) => { ( $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 { if let $z = ret {
} else { } else {
assert!(false, "{:?}", ret) assert!(false, "{:?}", ret)
@ -307,226 +315,227 @@ fn test_net_declaration() {
#[test] #[test]
fn test_data_declaration() { fn test_data_declaration() {
test!( //test!(
data_declaration, // data_declaration,
"shortint s1, s2[0:9];", // "shortint s1, s2[0:9];",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"var byte my_byte;", // "var byte my_byte;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"var v;", // "var v;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"var [15:0] vw;", // "var [15:0] vw;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"var enum bit { clear, error } status;", // "var enum bit { clear, error } status;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"var reg r;", // "var reg r;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"int i = 0;", // "int i = 0;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"logic a;", // "logic a;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"logic[3:0] v;", // "logic[3:0] v;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"logic signed [3:0] signed_reg;", // "logic signed [3:0] signed_reg;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"logic [-1:4] b;", // "logic [-1:4] b;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"logic [4:0] x, y, z;", // "logic [4:0] x, y, z;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"int unsigned ui;", // "int unsigned ui;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"int signed si;", // "int signed si;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"string myName = default_name;", // "string myName = default_name;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"byte c = \"A\";", // "byte c = \"A\";",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"bit [10:0] b = \"x41\";", // "bit [10:0] b = \"x41\";",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"bit [1:4][7:0] h = \"hello\" ;", // "bit [1:4][7:0] h = \"hello\" ;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"event done;", // "event done;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"event done_too = done;", // "event done_too = done;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"event empty = null;", // "event empty = null;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"typedef int intP;", // "typedef int intP;",
Ok((_, DataDeclaration::TypeDeclaration(_))) // Ok((_, DataDeclaration::TypeDeclaration(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"intP a, b;", // "intP a, b;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"typedef enum type_identifier;", // "typedef enum type_identifier;",
Ok((_, DataDeclaration::TypeDeclaration(_))) // Ok((_, DataDeclaration::TypeDeclaration(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"typedef struct type_identifier;", // "typedef struct type_identifier;",
Ok((_, DataDeclaration::TypeDeclaration(_))) // Ok((_, DataDeclaration::TypeDeclaration(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"typedef union type_identifier;", // "typedef union type_identifier;",
Ok((_, DataDeclaration::TypeDeclaration(_))) // Ok((_, DataDeclaration::TypeDeclaration(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"typedef class type_identifier;", // "typedef class type_identifier;",
Ok((_, DataDeclaration::TypeDeclaration(_))) // Ok((_, DataDeclaration::TypeDeclaration(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"typedef interface class type_identifier;", // "typedef interface class type_identifier;",
Ok((_, DataDeclaration::TypeDeclaration(_))) // Ok((_, DataDeclaration::TypeDeclaration(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"typedef type_identifier;", // "typedef type_identifier;",
Ok((_, DataDeclaration::TypeDeclaration(_))) // Ok((_, DataDeclaration::TypeDeclaration(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"typedef C::T c_t;", // "typedef C::T c_t;",
Ok((_, DataDeclaration::TypeDeclaration(_))) // Ok((_, DataDeclaration::TypeDeclaration(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"enum {red, yellow, green} light1, light2;", // "enum {red, yellow, green} light1, light2;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"enum bit [1:0] {IDLE, XX='x, S1=2'b01, S2=2'b10} state, next;", // "enum bit [1:0] {IDLE, XX='x, S1=2'b01, S2=2'b10} state, next;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"enum integer {IDLE, XX='x, S1='b01, S2='b10} state, next;", // "enum integer {IDLE, XX='x, S1='b01, S2='b10} state, next;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"enum integer {IDLE, XX='x, S1='b01, S2='b10} state, next;", // "enum integer {IDLE, XX='x, S1='b01, S2='b10} state, next;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"enum {bronze=3, silver, gold} medal;", // "enum {bronze=3, silver, gold} medal;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"enum {a=3, b=7, c} alphabet;", // "enum {a=3, b=7, c} alphabet;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"enum bit [3:0] {bronze='h3, silver, gold='h5} medal2;", // "enum bit [3:0] {bronze='h3, silver, gold='h5} medal2;",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"integer i_array[*];", // "integer i_array[*];",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"bit [20:0] array_b[string];", // "bit [20:0] array_b[string];",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"event ev_array[myClass];", // "event ev_array[myClass];",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"int array_name [*];", // "int array_name [*];",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"int array_name1 [ integer ];", // "int array_name1 [ integer ];",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"int a[int] = '{default:1};", // "int a[int] = '{default:1};",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!( //test!(
data_declaration, // data_declaration,
"byte q1[$];", // "byte q1[$];",
Ok((_, DataDeclaration::Variable(_))) // Ok((_, DataDeclaration::Variable(_)))
); //);
test!(primary, "'{default:1}", Ok((_, _)));
} }
#[test] #[test]
@ -792,9 +801,5 @@ fn test_attribute_instance() {
#[test] #[test]
fn test_expression() { fn test_expression() {
test!( test!(expression, "(!a ? 0 : !b : 1 : c ? 0 : 1)", Ok((_, _)));
mintypmax_expression,
"!a ? 0 : !b : 1 : c ? 0 : 1",
Ok((_, _))
);
} }

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

@ -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<Span<'a>, Symbol> { pub(crate) fn symbol<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Symbol> {
move |s: Span<'a>| { move |s: Span<'a>| {
let (s, x) = map(ws(map(tag(t.clone()), |x: Span| into_locate(x))), |x| { 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<Span<'a>, 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<Span<'a>, Symbol> { pub(crate) fn symbol<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Symbol> {
move |s: Span<'a>| { 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 body = || {
let (s, x) = map(ws(map(tag(t.clone()), |x: Span| into_locate(x))), |x| { let (s, x) = map(ws(map(tag(t.clone()), |x: Span| into_locate(x))), |x| {
Symbol { nodes: x } Symbol { nodes: x }
@ -287,11 +287,11 @@ pub(crate) fn symbol<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult<Span<'a>, S
Ok((s, x)) Ok((s, x))
}; };
let ret = body(); 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<Span<'a>, Keyword> { pub(crate) fn keyword<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Keyword> {
move |s: Span<'a>| { move |s: Span<'a>| {
let (s, x) = map( let (s, x) = map(
@ -305,10 +305,10 @@ pub(crate) fn keyword<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult<Span<'a>,
} }
} }
#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] #[cfg(feature = "trace")]
pub(crate) fn keyword<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Keyword> { pub(crate) fn keyword<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Keyword> {
move |s: Span<'a>| { 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 body = || {
let (s, x) = map( let (s, x) = map(
ws(terminated( ws(terminated(
@ -320,11 +320,11 @@ pub(crate) fn keyword<'a>(t: &'a str) -> impl Fn(Span<'a>) -> IResult<Span<'a>,
Ok((s, x)) Ok((s, x))
}; };
let ret = body(); 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<Span<'a>, Paren<O>> pub(crate) fn paren<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Paren<O>>
where where
F: Fn(Span<'a>) -> IResult<Span<'a>, O>, F: Fn(Span<'a>) -> IResult<Span<'a>, 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<Span<'a>, Paren<O>> pub(crate) fn paren<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Paren<O>>
where where
F: Fn(Span<'a>) -> IResult<Span<'a>, O>, F: Fn(Span<'a>) -> IResult<Span<'a>, O>,
{ {
move |s: Span<'a>| { move |s: Span<'a>| {
let (depth, s) = forward_trace(s, "paren"); let (depth, s) = nom_tracable::forward_trace(s, "paren");
let body = || { let body = || {
let (s, a) = symbol("(")(s)?; let (s, a) = symbol("(")(s)?;
let (s, b) = f(s)?; let (s, b) = f(s)?;
@ -351,11 +351,11 @@ where
Ok((s, Paren { nodes: (a, b, c) })) Ok((s, Paren { nodes: (a, b, c) }))
}; };
let ret = body(); 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<Span<'a>, Bracket<O>> pub(crate) fn bracket<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Bracket<O>>
where where
F: Fn(Span<'a>) -> IResult<Span<'a>, O>, F: Fn(Span<'a>) -> IResult<Span<'a>, 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<Span<'a>, Bracket<O>> pub(crate) fn bracket<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Bracket<O>>
where where
F: Fn(Span<'a>) -> IResult<Span<'a>, O>, F: Fn(Span<'a>) -> IResult<Span<'a>, O>,
{ {
move |s: Span<'a>| { move |s: Span<'a>| {
let (depth, s) = forward_trace(s, "bracket"); let (depth, s) = nom_tracable::forward_trace(s, "bracket");
let body = || { let body = || {
let (s, a) = symbol("[")(s)?; let (s, a) = symbol("[")(s)?;
let (s, b) = f(s)?; let (s, b) = f(s)?;
@ -382,11 +382,11 @@ where
Ok((s, Bracket { nodes: (a, b, c) })) Ok((s, Bracket { nodes: (a, b, c) }))
}; };
let ret = body(); 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<Span<'a>, Brace<O>> pub(crate) fn brace<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Brace<O>>
where where
F: Fn(Span<'a>) -> IResult<Span<'a>, O>, F: Fn(Span<'a>) -> IResult<Span<'a>, 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<Span<'a>, Brace<O>> pub(crate) fn brace<'a, O, F>(f: F) -> impl Fn(Span<'a>) -> IResult<Span<'a>, Brace<O>>
where where
F: Fn(Span<'a>) -> IResult<Span<'a>, O>, F: Fn(Span<'a>) -> IResult<Span<'a>, O>,
{ {
move |s: Span<'a>| { move |s: Span<'a>| {
let (depth, s) = forward_trace(s, "brace"); let (depth, s) = nom_tracable::forward_trace(s, "brace");
let body = || { let body = || {
let (s, a) = symbol("{")(s)?; let (s, a) = symbol("{")(s)?;
let (s, b) = f(s)?; let (s, b) = f(s)?;
@ -413,11 +413,11 @@ where
Ok((s, Brace { nodes: (a, b, c) })) Ok((s, Brace { nodes: (a, b, c) }))
}; };
let ret = body(); 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>( pub(crate) fn apostrophe_brace<'a, O, F>(
f: F, f: F,
) -> impl Fn(Span<'a>) -> IResult<Span<'a>, ApostropheBrace<O>> ) -> impl Fn(Span<'a>) -> IResult<Span<'a>, ApostropheBrace<O>>
@ -432,7 +432,7 @@ where
} }
} }
#[cfg(any(feature = "forward_trace", feature = "backward_trace"))] #[cfg(feature = "trace")]
pub(crate) fn apostrophe_brace<'a, O, F>( pub(crate) fn apostrophe_brace<'a, O, F>(
f: F, f: F,
) -> impl Fn(Span<'a>) -> IResult<Span<'a>, ApostropheBrace<O>> ) -> impl Fn(Span<'a>) -> IResult<Span<'a>, ApostropheBrace<O>>
@ -440,7 +440,7 @@ where
F: Fn(Span<'a>) -> IResult<Span<'a>, O>, F: Fn(Span<'a>) -> IResult<Span<'a>, O>,
{ {
move |s: Span<'a>| { 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 body = || {
let (s, a) = symbol("'{")(s)?; let (s, a) = symbol("'{")(s)?;
let (s, b) = f(s)?; let (s, b) = f(s)?;
@ -448,7 +448,7 @@ where
Ok((s, ApostropheBrace { nodes: (a, b, c) })) Ok((s, ApostropheBrace { nodes: (a, b, c) }))
}; };
let ret = body(); 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(), 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<Span<'a>, O>,
name: &str,
depth: usize,
) -> IResult<Span<'a>, 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)
}
}
}

3
sv-parser/Cargo.toml
View File

@ -12,8 +12,7 @@ edition = "2018"
[features] [features]
default = [] default = []
forward_trace = ["sv-parser-parser/forward_trace"] trace = ["sv-parser-parser/trace"]
backward_trace = ["sv-parser-parser/backward_trace"]
[dependencies] [dependencies]
sv-parser-parser = { path = "../sv-parser-parser" } sv-parser-parser = { path = "../sv-parser-parser" }