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 12:41:59 +09:00
parent 7b95c76fd4
commit 16e13ab20e
5 changed files with 77 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -12,3 +12,4 @@ edition = "2018"
[dependencies]
nom = "5.0.0"
str-concat = "*"

4
src/attributes.rs
View File

@ -55,14 +55,14 @@ mod tests {
"{:?}",
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!(
format!(
"{:?}",
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\")))))) }] }))"
);
}
}

14
src/lvalues.rs
View File

@ -177,15 +177,15 @@ mod tests {
);
assert_eq!(
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!(
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!(
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!(
format!("{:?}", all_consuming(variable_lvalue)("a")),
@ -193,15 +193,15 @@ mod tests {
);
assert_eq!(
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!(
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!(
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!(
format!("{:?}", all_consuming(nonrange_variable_lvalue)("a")),
@ -209,7 +209,7 @@ mod tests {
);
assert_eq!(
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 } }))"
);
}
}

150
src/numbers.rs
View File

@ -21,7 +21,7 @@ pub enum IntegralNumber<'a> {
OctalNumber(OctalNumber<'a>),
BinaryNumber(BinaryNumber<'a>),
HexNumber(HexNumber<'a>),
UnsignedNumber(Vec<&'a str>),
UnsignedNumber(&'a str),
}
#[derive(Debug)]
@ -32,45 +32,45 @@ pub enum RealNumber<'a> {
#[derive(Debug)]
pub struct DecimalNumber<'a> {
pub size: Option<Vec<&'a str>>,
pub size: Option<&'a str>,
pub decimal_base: &'a str,
pub decimal_value: Vec<&'a str>,
pub decimal_value: &'a str,
}
#[derive(Debug)]
pub struct BinaryNumber<'a> {
pub size: Option<Vec<&'a str>>,
pub size: Option<&'a str>,
pub binary_base: &'a str,
pub binary_value: Vec<&'a str>,
pub binary_value: &'a str,
}
#[derive(Debug)]
pub struct OctalNumber<'a> {
pub size: Option<Vec<&'a str>>,
pub size: Option<&'a str>,
pub octal_base: &'a str,
pub octal_value: Vec<&'a str>,
pub octal_value: &'a str,
}
#[derive(Debug)]
pub struct HexNumber<'a> {
pub size: Option<Vec<&'a str>>,
pub size: Option<&'a str>,
pub hex_base: &'a str,
pub hex_value: Vec<&'a str>,
pub hex_value: &'a str,
}
#[derive(Debug)]
pub struct FixedPointNumber<'a> {
pub integer_value: Vec<&'a str>,
pub fraction_value: Vec<&'a str>,
pub integer_value: &'a str,
pub fraction_value: &'a str,
}
#[derive(Debug)]
pub struct FloatingPointNumber<'a> {
pub integer_value: Vec<&'a str>,
pub fraction_value: Option<Vec<&'a str>>,
pub integer_value: &'a str,
pub fraction_value: Option<&'a str>,
pub exponent: &'a str,
pub sign: Option<&'a str>,
pub exponent_value: Vec<&'a str>,
pub exponent_value: &'a str,
}
// -----------------------------------------------------------------------------
@ -149,13 +149,11 @@ pub fn hex_number(s: &str) -> IResult<&str, IntegralNumber> {
))
}
pub fn size(s: &str) -> IResult<&str, Vec<&str>> {
pub fn size(s: &str) -> IResult<&str, &str> {
let (s, x) = is_a("123456789")(s)?;
let (s, x) = fold_many0(alt((tag("_"), digit1)), vec![x], |mut acc: Vec<_>, item| {
acc.push(item);
acc
})(s)?;
Ok((s, x))
fold_many0(alt((tag("_"), digit1)), x, |acc, item| {
str_concat::concat(acc, item).unwrap()
})(s)
}
pub fn real_number(s: &str) -> IResult<&str, Number> {
@ -196,47 +194,33 @@ pub fn floating_point_number(s: &str) -> IResult<&str, RealNumber> {
))
}
pub fn unsigned_number(s: &str) -> IResult<&str, Vec<&str>> {
pub fn unsigned_number(s: &str) -> IResult<&str, &str> {
let (s, x) = digit1(s)?;
fold_many0(alt((tag("_"), digit1)), vec![x], |mut acc: Vec<_>, item| {
acc.push(item);
acc
fold_many0(alt((tag("_"), digit1)), x, |acc, item| {
str_concat::concat(acc, item).unwrap()
})(s)
}
pub fn binary_value(s: &str) -> IResult<&str, Vec<&str>> {
pub fn binary_value(s: &str) -> IResult<&str, &str> {
let (s, x) = is_a("01xXzZ?")(s)?;
fold_many0(
alt((tag("_"), is_a("01xXzZ?"))),
vec![x],
|mut acc: Vec<_>, item| {
acc.push(item);
acc
},
)(s)
fold_many0(alt((tag("_"), is_a("01xXzZ?"))), x, |acc, item| {
str_concat::concat(acc, item).unwrap()
})(s)
}
pub fn octal_value(s: &str) -> IResult<&str, Vec<&str>> {
pub fn octal_value(s: &str) -> IResult<&str, &str> {
let (s, x) = is_a("01234567xXzZ?")(s)?;
fold_many0(
alt((tag("_"), is_a("01234567xXzZ?"))),
vec![x],
|mut acc: Vec<_>, item| {
acc.push(item);
acc
},
)(s)
fold_many0(alt((tag("_"), is_a("01234567xXzZ?"))), x, |acc, item| {
str_concat::concat(acc, item).unwrap()
})(s)
}
pub fn hex_value(s: &str) -> IResult<&str, Vec<&str>> {
pub fn hex_value(s: &str) -> IResult<&str, &str> {
let (s, x) = is_a("0123456789abcdefABCDEFxXzZ?")(s)?;
fold_many0(
alt((tag("_"), is_a("0123456789abcdefABCDEFxXzZ?"))),
vec![x],
|mut acc: Vec<_>, item| {
acc.push(item);
acc
},
x,
|acc, item| str_concat::concat(acc, item).unwrap(),
)(s)
}
@ -256,28 +240,18 @@ pub fn hex_base(s: &str) -> IResult<&str, &str> {
alt((tag_no_case("'h"), tag_no_case("'sh")))(s)
}
pub fn x_number(s: &str) -> IResult<&str, Vec<&str>> {
pub fn x_number(s: &str) -> IResult<&str, &str> {
let (s, x) = tag_no_case("x")(s)?;
fold_many0(
alt((tag("_"), is_a("_"))),
vec![x],
|mut acc: Vec<_>, item| {
acc.push(item);
acc
},
)(s)
fold_many0(alt((tag("_"), is_a("_"))), x, |acc, item| {
str_concat::concat(acc, item).unwrap()
})(s)
}
pub fn z_number(s: &str) -> IResult<&str, Vec<&str>> {
pub fn z_number(s: &str) -> IResult<&str, &str> {
let (s, x) = alt((tag_no_case("z"), tag("?")))(s)?;
fold_many0(
alt((tag("_"), is_a("_"))),
vec![x],
|mut acc: Vec<_>, item| {
acc.push(item);
acc
},
)(s)
fold_many0(alt((tag("_"), is_a("_"))), x, |acc, item| {
str_concat::concat(acc, item).unwrap()
})(s)
}
pub fn unbased_unsized_literal(s: &str) -> IResult<&str, &str> {
@ -294,15 +268,15 @@ mod tests {
fn test() {
assert_eq!(
format!("{:?}", all_consuming(number)("659")),
"Ok((\"\", IntegralNumber(UnsignedNumber([\"659\"]))))"
"Ok((\"\", IntegralNumber(UnsignedNumber(\"659\"))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("'h 837FF")),
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: None, hex_base: \"\\\'h\", hex_value: [\"837FF\"] }))))"
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: None, hex_base: \"\\\'h\", hex_value: \"837FF\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("'o7460")),
"Ok((\"\", IntegralNumber(OctalNumber(OctalNumber { size: None, octal_base: \"\\\'o\", octal_value: [\"7460\"] }))))"
"Ok((\"\", IntegralNumber(OctalNumber(OctalNumber { size: None, octal_base: \"\\\'o\", octal_value: \"7460\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("4af")),
@ -310,23 +284,23 @@ mod tests {
);
assert_eq!(
format!("{:?}", all_consuming(number)("4'b1001")),
"Ok((\"\", IntegralNumber(BinaryNumber(BinaryNumber { size: Some([\"4\"]), binary_base: \"\\\'b\", binary_value: [\"1001\"] }))))"
"Ok((\"\", IntegralNumber(BinaryNumber(BinaryNumber { size: Some(\"4\"), binary_base: \"\\\'b\", binary_value: \"1001\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("5 'D 3")),
"Ok((\"\", IntegralNumber(DecimalNumber(DecimalNumber { size: Some([\"5\"]), decimal_base: \"\\\'D\", decimal_value: [\"3\"] }))))"
"Ok((\"\", IntegralNumber(DecimalNumber(DecimalNumber { size: Some(\"5\"), decimal_base: \"\\\'D\", decimal_value: \"3\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("3'b01x")),
"Ok((\"\", IntegralNumber(BinaryNumber(BinaryNumber { size: Some([\"3\"]), binary_base: \"\\\'b\", binary_value: [\"01x\"] }))))"
"Ok((\"\", IntegralNumber(BinaryNumber(BinaryNumber { size: Some(\"3\"), binary_base: \"\\\'b\", binary_value: \"01x\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("12'hx")),
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some([\"12\"]), hex_base: \"\\\'h\", hex_value: [\"x\"] }))))"
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some(\"12\"), hex_base: \"\\\'h\", hex_value: \"x\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("16'hz")),
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some([\"16\"]), hex_base: \"\\\'h\", hex_value: [\"z\"] }))))"
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some(\"16\"), hex_base: \"\\\'h\", hex_value: \"z\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("8 'd -6")),
@ -334,59 +308,59 @@ mod tests {
);
assert_eq!(
format!("{:?}", all_consuming(number)("4 'shf")),
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some([\"4\"]), hex_base: \"\\\'sh\", hex_value: [\"f\"] }))))"
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some(\"4\"), hex_base: \"\\\'sh\", hex_value: \"f\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("16'sd?")),
"Ok((\"\", IntegralNumber(DecimalNumber(DecimalNumber { size: Some([\"16\"]), decimal_base: \"\\\'sd\", decimal_value: [\"?\"] }))))"
"Ok((\"\", IntegralNumber(DecimalNumber(DecimalNumber { size: Some(\"16\"), decimal_base: \"\\\'sd\", decimal_value: \"?\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("27_195_000")),
"Ok((\"\", IntegralNumber(UnsignedNumber([\"27\", \"_\", \"195\", \"_\", \"000\"]))))"
"Ok((\"\", IntegralNumber(UnsignedNumber(\"27_195_000\"))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("16'b0011_0101_0001_1111")),
"Ok((\"\", IntegralNumber(BinaryNumber(BinaryNumber { size: Some([\"16\"]), binary_base: \"\\\'b\", binary_value: [\"0011\", \"_\", \"0101\", \"_\", \"0001\", \"_\", \"1111\"] }))))"
"Ok((\"\", IntegralNumber(BinaryNumber(BinaryNumber { size: Some(\"16\"), binary_base: \"\\\'b\", binary_value: \"0011_0101_0001_1111\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("32 'h 12ab_f001")),
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some([\"32\"]), hex_base: \"\\\'h\", hex_value: [\"12ab\", \"_\", \"f001\"] }))))"
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some(\"32\"), hex_base: \"\\\'h\", hex_value: \"12ab_f001\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("1.2")),
"Ok((\"\", RealNumber(FixedPointNumber(FixedPointNumber { integer_value: [\"1\"], fraction_value: [\"2\"] }))))"
"Ok((\"\", RealNumber(FixedPointNumber(FixedPointNumber { integer_value: \"1\", fraction_value: \"2\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("0.1")),
"Ok((\"\", RealNumber(FixedPointNumber(FixedPointNumber { integer_value: [\"0\"], fraction_value: [\"1\"] }))))"
"Ok((\"\", RealNumber(FixedPointNumber(FixedPointNumber { integer_value: \"0\", fraction_value: \"1\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("2394.26331")),
"Ok((\"\", RealNumber(FixedPointNumber(FixedPointNumber { integer_value: [\"2394\"], fraction_value: [\"26331\"] }))))"
"Ok((\"\", RealNumber(FixedPointNumber(FixedPointNumber { integer_value: \"2394\", fraction_value: \"26331\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("1.2E12")),
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: [\"1\"], fraction_value: Some([\"2\"]), exponent: \"E\", sign: None, exponent_value: [\"12\"] }))))"
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"1\", fraction_value: Some(\"2\"), exponent: \"E\", sign: None, exponent_value: \"12\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("1.30e-2")),
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: [\"1\"], fraction_value: Some([\"30\"]), exponent: \"e\", sign: Some(\"-\"), exponent_value: [\"2\"] }))))"
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"1\", fraction_value: Some(\"30\"), exponent: \"e\", sign: Some(\"-\"), exponent_value: \"2\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("0.1e-0")),
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: [\"0\"], fraction_value: Some([\"1\"]), exponent: \"e\", sign: Some(\"-\"), exponent_value: [\"0\"] }))))"
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"0\", fraction_value: Some(\"1\"), exponent: \"e\", sign: Some(\"-\"), exponent_value: \"0\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("23E10")),
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: [\"23\"], fraction_value: None, exponent: \"E\", sign: None, exponent_value: [\"10\"] }))))"
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"23\", fraction_value: None, exponent: \"E\", sign: None, exponent_value: \"10\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("29E-2")),
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: [\"29\"], fraction_value: None, exponent: \"E\", sign: Some(\"-\"), exponent_value: [\"2\"] }))))"
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"29\", fraction_value: None, exponent: \"E\", sign: Some(\"-\"), exponent_value: \"2\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)("236.123_763_e-12")),
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: [\"236\"], fraction_value: Some([\"123\", \"_\", \"763\", \"_\"]), exponent: \"e\", sign: Some(\"-\"), exponent_value: [\"12\"] }))))"
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"236\", fraction_value: Some(\"123_763_\"), exponent: \"e\", sign: Some(\"-\"), exponent_value: \"12\" }))))"
);
assert_eq!(
format!("{:?}", all_consuming(number)(".12")),

10
src/primaries.rs
View File

@ -168,7 +168,7 @@ pub enum ImplicitClassHandle {
#[derive(Debug)]
pub struct UnsignedTimeLiteral<'a> {
number: Vec<&'a str>,
number: &'a str,
unit: TimeUnit,
}
@ -627,11 +627,11 @@ mod tests {
fn test() {
assert_eq!(
format!("{:?}", all_consuming(primary)("2.1ns")),
"Ok((\"\", PrimaryLiteral(TimeLiteral(FixedPointTimeLiteral(FixedPointTimeLiteral { number: FixedPointNumber(FixedPointNumber { integer_value: [\"2\"], fraction_value: [\"1\"] }), unit: NS })))))"
"Ok((\"\", PrimaryLiteral(TimeLiteral(FixedPointTimeLiteral(FixedPointTimeLiteral { number: FixedPointNumber(FixedPointNumber { integer_value: \"2\", fraction_value: \"1\" }), unit: NS })))))"
);
assert_eq!(
format!("{:?}", all_consuming(primary)("40 ps")),
"Ok((\"\", PrimaryLiteral(TimeLiteral(UnsignedTimeLiteral(UnsignedTimeLiteral { number: [\"40\"], unit: PS })))))"
"Ok((\"\", PrimaryLiteral(TimeLiteral(UnsignedTimeLiteral(UnsignedTimeLiteral { number: \"40\", unit: PS })))))"
);
assert_eq!(
format!("{:?}", all_consuming(primary)("'0")),
@ -639,7 +639,7 @@ mod tests {
);
assert_eq!(
format!("{:?}", all_consuming(primary)("10")),
"Ok((\"\", PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"10\"]))))))"
"Ok((\"\", PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"10\"))))))"
);
assert_eq!(
format!("{:?}", all_consuming(primary)("\"aaa\"")),
@ -663,7 +663,7 @@ mod tests {
);
assert_eq!(
format!("{:?}", all_consuming(module_path_primary)("10")),
"Ok((\"\", Number(IntegralNumber(UnsignedNumber([\"10\"])))))"
"Ok((\"\", Number(IntegralNumber(UnsignedNumber(\"10\")))))"
);
assert_eq!(
format!("{:?}", all_consuming(constant_primary)("null")),