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

Apply str-concat

Browse Source
This commit is contained in:
dalance 2019-07-04 15:11:42 +09:00
parent 16e13ab20e
commit 024f2f736f
5 changed files with 68 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/attributes.rs
View File

@ -48,21 +48,21 @@ mod tests {
"{:?}", "{:?}",
all_consuming(attribute_instance)("(* full_case, parallel_case *)") all_consuming(attribute_instance)("(* full_case, parallel_case *)")
), ),
"Ok((\"\", AttributeInstance { attr_spec: [AttrSpec { attr_name: Identifier { raw: [\"full_case\"] }, rvalue: None }, AttrSpec { attr_name: Identifier { raw: [\"parallel_case\"] }, rvalue: None }] }))" "Ok((\"\", AttributeInstance { attr_spec: [AttrSpec { attr_name: Identifier { raw: \"full_case\" }, rvalue: None }, AttrSpec { attr_name: Identifier { raw: \"parallel_case\" }, rvalue: None }] }))"
); );
assert_eq!( assert_eq!(
format!( format!(
"{:?}", "{:?}",
all_consuming(attribute_instance)("(* full_case=1 *)") all_consuming(attribute_instance)("(* full_case=1 *)")
), ),
"Ok((\"\", AttributeInstance { attr_spec: [AttrSpec { attr_name: Identifier { raw: [\"full_case\"] }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))) }] }))" "Ok((\"\", AttributeInstance { attr_spec: [AttrSpec { attr_name: Identifier { raw: \"full_case\" }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))) }] }))"
); );
assert_eq!( assert_eq!(
format!( format!(
"{:?}", "{:?}",
all_consuming(attribute_instance)("(* full_case=1, parallel_case = 0 *)") all_consuming(attribute_instance)("(* full_case=1, parallel_case = 0 *)")
), ),
"Ok((\"\", AttributeInstance { attr_spec: [AttrSpec { attr_name: Identifier { raw: [\"full_case\"] }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))) }, AttrSpec { attr_name: Identifier { raw: [\"parallel_case\"] }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"0\")))))) }] }))" "Ok((\"\", AttributeInstance { attr_spec: [AttrSpec { attr_name: Identifier { raw: \"full_case\" }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))) }, AttrSpec { attr_name: Identifier { raw: \"parallel_case\" }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"0\")))))) }] }))"
); );
} }
} }

47
src/identifiers.rs
View File

@ -16,7 +16,7 @@ const AZ09_DOLLAR: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0
#[derive(Debug)] #[derive(Debug)]
pub struct Identifier<'a> { pub struct Identifier<'a> {
pub raw: Vec<&'a str>, pub raw: &'a str,
} }
#[derive(Debug)] #[derive(Debug)]
@ -78,7 +78,11 @@ pub fn bin_identifier(s: &str) -> IResult<&str, Identifier> {
pub fn c_identifier(s: &str) -> IResult<&str, Identifier> { pub fn c_identifier(s: &str) -> IResult<&str, Identifier> {
let (s, x) = is_a(AZ_)(s)?; let (s, x) = is_a(AZ_)(s)?;
let (s, y) = opt(is_a(AZ09_))(s)?; let (s, y) = opt(is_a(AZ09_))(s)?;
let raw = if let Some(y) = y { vec![x, y] } else { vec![x] }; let raw = if let Some(y) = y {
str_concat::concat(x, y).unwrap()
} else {
x
};
Ok((s, Identifier { raw })) Ok((s, Identifier { raw }))
} }
@ -141,7 +145,12 @@ pub fn enum_identifier(s: &str) -> IResult<&str, Identifier> {
pub fn escaped_identifier(s: &str) -> IResult<&str, Identifier> { pub fn escaped_identifier(s: &str) -> IResult<&str, Identifier> {
let (s, x) = tag("\\")(s)?; let (s, x) = tag("\\")(s)?;
let (s, y) = is_not(" \t\r\n")(s)?; let (s, y) = is_not(" \t\r\n")(s)?;
Ok((s, Identifier { raw: vec![x, y] })) Ok((
s,
Identifier {
raw: str_concat::concat(x, y).unwrap(),
},
))
} }
pub fn formal_identifier(s: &str) -> IResult<&str, Identifier> { pub fn formal_identifier(s: &str) -> IResult<&str, Identifier> {
@ -201,7 +210,7 @@ pub fn hierarchical_identifier(s: &str) -> IResult<&str, HierarchicalIdentifier>
hierarchy.insert( hierarchy.insert(
0, 0,
Hierarchy { Hierarchy {
identifier: Identifier { raw: vec![x] }, identifier: Identifier { raw: x },
constant_bit_select: None, constant_bit_select: None,
}, },
); );
@ -307,10 +316,7 @@ pub fn package_identifier(s: &str) -> IResult<&str, Identifier> {
pub fn package_scope(s: &str) -> IResult<&str, Scope> { pub fn package_scope(s: &str) -> IResult<&str, Scope> {
let (s, x) = alt(( let (s, x) = alt((
terminated(package_identifier, sp(tag("::"))), terminated(package_identifier, sp(tag("::"))),
terminated( terminated(map(tag("$unit"), |x| Identifier { raw: x }), sp(tag("::"))),
map(tag("$unit"), |x| Identifier { raw: vec![x] }),
sp(tag("::")),
),
))(s)?; ))(s)?;
Ok((s, Scope::PackageScope(x))) Ok((s, Scope::PackageScope(x)))
} }
@ -462,7 +468,11 @@ pub fn signal_identifier(s: &str) -> IResult<&str, Identifier> {
pub fn simple_identifier(s: &str) -> IResult<&str, Identifier> { pub fn simple_identifier(s: &str) -> IResult<&str, Identifier> {
let (s, x) = is_a(AZ_)(s)?; let (s, x) = is_a(AZ_)(s)?;
let (s, y) = opt(is_a(AZ09_DOLLAR))(s)?; let (s, y) = opt(is_a(AZ09_DOLLAR))(s)?;
let raw = if let Some(y) = y { vec![x, y] } else { vec![x] }; let raw = if let Some(y) = y {
str_concat::concat(x, y).unwrap()
} else {
x
};
Ok((s, Identifier { raw })) Ok((s, Identifier { raw }))
} }
@ -473,7 +483,12 @@ pub fn specparam_identifier(s: &str) -> IResult<&str, Identifier> {
pub fn system_tf_identifier(s: &str) -> IResult<&str, Identifier> { pub fn system_tf_identifier(s: &str) -> IResult<&str, Identifier> {
let (s, x) = tag("$")(s)?; let (s, x) = tag("$")(s)?;
let (s, y) = is_a(AZ09_DOLLAR)(s)?; let (s, y) = is_a(AZ09_DOLLAR)(s)?;
Ok((s, Identifier { raw: vec![x, y] })) Ok((
s,
Identifier {
raw: str_concat::concat(x, y).unwrap(),
},
))
} }
pub fn task_identifier(s: &str) -> IResult<&str, Identifier> { pub fn task_identifier(s: &str) -> IResult<&str, Identifier> {
@ -514,27 +529,27 @@ mod tests {
fn test() { fn test() {
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(identifier)("shiftreg_a")), format!("{:?}", all_consuming(identifier)("shiftreg_a")),
"Ok((\"\", Identifier { raw: [\"shiftreg_a\"] }))" "Ok((\"\", Identifier { raw: \"shiftreg_a\" }))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(identifier)("_bus3")), format!("{:?}", all_consuming(identifier)("_bus3")),
"Ok((\"\", Identifier { raw: [\"_bus\", \"3\"] }))" "Ok((\"\", Identifier { raw: \"_bus3\" }))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(identifier)("n$657")), format!("{:?}", all_consuming(identifier)("n$657")),
"Ok((\"\", Identifier { raw: [\"n\", \"$657\"] }))" "Ok((\"\", Identifier { raw: \"n$657\" }))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(identifier)("\\busa+index")), format!("{:?}", all_consuming(identifier)("\\busa+index")),
"Ok((\"\", Identifier { raw: [\"\\\\\", \"busa+index\"] }))" "Ok((\"\", Identifier { raw: \"\\\\busa+index\" }))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(identifier)("\\-clock")), format!("{:?}", all_consuming(identifier)("\\-clock")),
"Ok((\"\", Identifier { raw: [\"\\\\\", \"-clock\"] }))" "Ok((\"\", Identifier { raw: \"\\\\-clock\" }))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(system_tf_identifier)("$display")), format!("{:?}", all_consuming(system_tf_identifier)("$display")),
"Ok((\"\", Identifier { raw: [\"$\", \"display\"] }))" "Ok((\"\", Identifier { raw: \"$display\" }))"
); );
} }
} }

20
src/lvalues.rs
View File

@ -173,43 +173,43 @@ mod tests {
fn test() { fn test() {
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(net_lvalue)("a")), format!("{:?}", all_consuming(net_lvalue)("a")),
"Ok((\"\", Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } } }, select: ConstantSelect { member: None, bit_select: [], part_select_range: None } })))" "Ok((\"\", Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } } }, select: ConstantSelect { member: None, bit_select: [], part_select_range: None } })))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(net_lvalue)("a[1][2]")), format!("{:?}", all_consuming(net_lvalue)("a[1][2]")),
"Ok((\"\", Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"2\")))))], part_select_range: None } })))" "Ok((\"\", Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"2\")))))], part_select_range: None } })))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(net_lvalue)("a[1][10:5]")), format!("{:?}", all_consuming(net_lvalue)("a[1][10:5]")),
"Ok((\"\", Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: Some(Range((Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"10\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"5\")))))))) } })))" "Ok((\"\", Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: Some(Range((Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"10\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"5\")))))))) } })))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(net_lvalue)("{a, b[1], c}")), format!("{:?}", all_consuming(net_lvalue)("{a, b[1], c}")),
"Ok((\"\", Lvalue([Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } } }, select: ConstantSelect { member: None, bit_select: [], part_select_range: None } }), Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"b\"] } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: None } }), Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"c\"] } } }, select: ConstantSelect { member: None, bit_select: [], part_select_range: None } })])))" "Ok((\"\", Lvalue([Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } } }, select: ConstantSelect { member: None, bit_select: [], part_select_range: None } }), Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"b\" } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: None } }), Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"c\" } } }, select: ConstantSelect { member: None, bit_select: [], part_select_range: None } })])))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(variable_lvalue)("a")), format!("{:?}", all_consuming(variable_lvalue)("a")),
"Ok((\"\", Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [], part_select_range: None } })))" "Ok((\"\", Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } }, select: Select { member: None, bit_select: [], part_select_range: None } })))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(variable_lvalue)("a[1][2]")), format!("{:?}", all_consuming(variable_lvalue)("a[1][2]")),
"Ok((\"\", Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"2\")))))], part_select_range: None } })))" "Ok((\"\", Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"2\")))))], part_select_range: None } })))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(variable_lvalue)("a[1][10:5]")), format!("{:?}", all_consuming(variable_lvalue)("a[1][10:5]")),
"Ok((\"\", Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: Some(Range((Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"10\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"5\")))))))) } })))" "Ok((\"\", Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: Some(Range((Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"10\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"5\")))))))) } })))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(variable_lvalue)("{a, b[1], c}")), format!("{:?}", all_consuming(variable_lvalue)("{a, b[1], c}")),
"Ok((\"\", Lvalue([Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [], part_select_range: None } }), Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"b\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: None } }), Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"c\"] } }, select: Select { member: None, bit_select: [], part_select_range: None } })])))" "Ok((\"\", Lvalue([Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } }, select: Select { member: None, bit_select: [], part_select_range: None } }), Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"b\" } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: None } }), Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"c\" } }, select: Select { member: None, bit_select: [], part_select_range: None } })])))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(nonrange_variable_lvalue)("a")), format!("{:?}", all_consuming(nonrange_variable_lvalue)("a")),
"Ok((\"\", NonrangeVariableLvalue { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [], part_select_range: None } }))" "Ok((\"\", NonrangeVariableLvalue { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } }, select: Select { member: None, bit_select: [], part_select_range: None } }))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(nonrange_variable_lvalue)("a[1][2]")), format!("{:?}", all_consuming(nonrange_variable_lvalue)("a[1][2]")),
"Ok((\"\", NonrangeVariableLvalue { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"2\")))))], part_select_range: None } }))" "Ok((\"\", NonrangeVariableLvalue { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"2\")))))], part_select_range: None } }))"
); );
} }
} }

4
src/primaries.rs
View File

@ -643,7 +643,7 @@ mod tests {
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(primary)("\"aaa\"")), format!("{:?}", all_consuming(primary)("\"aaa\"")),
"Ok((\"\", PrimaryLiteral(StringLiteral(StringLiteral { raw: [\"aaa\"] }))))" "Ok((\"\", PrimaryLiteral(StringLiteral(StringLiteral { raw: \"aaa\" }))))"
); );
//assert_eq!( //assert_eq!(
// format!("{:?}", all_consuming(primary)("this")), // format!("{:?}", all_consuming(primary)("this")),
@ -659,7 +659,7 @@ mod tests {
//); //);
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(primary)("this . super.a")), format!("{:?}", all_consuming(primary)("this . super.a")),
"Ok((\"\", Hierarchical(PrimaryHierarchical { qualifier: Some(ClassQualifier(ClassQualifier { local: false, scope: Some(ImplicitClassHandle(ThisSuper)) })), identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [], part_select_range: None } })))" "Ok((\"\", Hierarchical(PrimaryHierarchical { qualifier: Some(ClassQualifier(ClassQualifier { local: false, scope: Some(ImplicitClassHandle(ThisSuper)) })), identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: \"a\" } }, select: Select { member: None, bit_select: [], part_select_range: None } })))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(module_path_primary)("10")), format!("{:?}", all_consuming(module_path_primary)("10")),

30
src/strings.rs
View File

@ -8,7 +8,7 @@ use nom::IResult;
#[derive(Debug)] #[derive(Debug)]
pub struct StringLiteral<'a> { pub struct StringLiteral<'a> {
pub raw: Vec<&'a str>, pub raw: &'a str,
} }
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
@ -18,15 +18,29 @@ pub fn string_literal(s: &str) -> IResult<&str, StringLiteral> {
let (s, x) = many1(pair(is_not("\\\""), opt(pair(tag("\\"), take(1usize)))))(s)?; let (s, x) = many1(pair(is_not("\\\""), opt(pair(tag("\\"), take(1usize)))))(s)?;
let (s, _) = tag("\"")(s)?; let (s, _) = tag("\"")(s)?;
let mut raw = Vec::new(); let mut raw = None;
for (x, y) in x { for (x, y) in x {
raw.push(x); raw = if let Some(raw) = raw {
Some(str_concat::concat(raw, x).unwrap())
} else {
Some(x)
};
if let Some((y, z)) = y { if let Some((y, z)) = y {
raw.push(y); raw = if let Some(raw) = raw {
raw.push(z); Some(str_concat::concat(raw, y).unwrap())
} else {
Some(y)
};
raw = if let Some(raw) = raw {
Some(str_concat::concat(raw, z).unwrap())
} else {
Some(z)
};
} }
} }
let raw = raw.unwrap();
Ok((s, StringLiteral { raw })) Ok((s, StringLiteral { raw }))
} }
@ -40,15 +54,15 @@ mod tests {
fn test() { fn test() {
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(string_literal)("\"aaa aaaa\"")), format!("{:?}", all_consuming(string_literal)("\"aaa aaaa\"")),
"Ok((\"\", StringLiteral { raw: [\"aaa aaaa\"] }))" "Ok((\"\", StringLiteral { raw: \"aaa aaaa\" }))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(string_literal)(r#""aaa\" aaaa""#)), format!("{:?}", all_consuming(string_literal)(r#""aaa\" aaaa""#)),
"Ok((\"\", StringLiteral { raw: [\"aaa\", \"\\\\\", \"\\\"\", \" aaaa\"] }))" "Ok((\"\", StringLiteral { raw: \"aaa\\\\\\\" aaaa\" }))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(string_literal)(r#""aaa\"""#)), format!("{:?}", all_consuming(string_literal)(r#""aaa\"""#)),
"Ok((\"\", StringLiteral { raw: [\"aaa\", \"\\\\\", \"\\\"\"] }))" "Ok((\"\", StringLiteral { raw: \"aaa\\\\\\\"\" }))"
); );
} }
} }