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] [dependencies]
nom = "5.0.0" 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 *)") 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\")))))) }] }))"
); );
} }
} }

14
src/lvalues.rs
View File

@ -177,15 +177,15 @@ mod tests {
); );
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")),
@ -193,15 +193,15 @@ mod tests {
); );
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")),
@ -209,7 +209,7 @@ mod tests {
); );
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 } }))"
); );
} }
} }

150
src/numbers.rs
View File

@ -21,7 +21,7 @@ pub enum IntegralNumber<'a> {
OctalNumber(OctalNumber<'a>), OctalNumber(OctalNumber<'a>),
BinaryNumber(BinaryNumber<'a>), BinaryNumber(BinaryNumber<'a>),
HexNumber(HexNumber<'a>), HexNumber(HexNumber<'a>),
UnsignedNumber(Vec<&'a str>), UnsignedNumber(&'a str),
} }
#[derive(Debug)] #[derive(Debug)]
@ -32,45 +32,45 @@ pub enum RealNumber<'a> {
#[derive(Debug)] #[derive(Debug)]
pub struct DecimalNumber<'a> { pub struct DecimalNumber<'a> {
pub size: Option<Vec<&'a str>>, pub size: Option<&'a str>,
pub decimal_base: &'a str, pub decimal_base: &'a str,
pub decimal_value: Vec<&'a str>, pub decimal_value: &'a str,
} }
#[derive(Debug)] #[derive(Debug)]
pub struct BinaryNumber<'a> { pub struct BinaryNumber<'a> {
pub size: Option<Vec<&'a str>>, pub size: Option<&'a str>,
pub binary_base: &'a str, pub binary_base: &'a str,
pub binary_value: Vec<&'a str>, pub binary_value: &'a str,
} }
#[derive(Debug)] #[derive(Debug)]
pub struct OctalNumber<'a> { pub struct OctalNumber<'a> {
pub size: Option<Vec<&'a str>>, pub size: Option<&'a str>,
pub octal_base: &'a str, pub octal_base: &'a str,
pub octal_value: Vec<&'a str>, pub octal_value: &'a str,
} }
#[derive(Debug)] #[derive(Debug)]
pub struct HexNumber<'a> { pub struct HexNumber<'a> {
pub size: Option<Vec<&'a str>>, pub size: Option<&'a str>,
pub hex_base: &'a str, pub hex_base: &'a str,
pub hex_value: Vec<&'a str>, pub hex_value: &'a str,
} }
#[derive(Debug)] #[derive(Debug)]
pub struct FixedPointNumber<'a> { pub struct FixedPointNumber<'a> {
pub integer_value: Vec<&'a str>, pub integer_value: &'a str,
pub fraction_value: Vec<&'a str>, pub fraction_value: &'a str,
} }
#[derive(Debug)] #[derive(Debug)]
pub struct FloatingPointNumber<'a> { pub struct FloatingPointNumber<'a> {
pub integer_value: Vec<&'a str>, pub integer_value: &'a str,
pub fraction_value: Option<Vec<&'a str>>, pub fraction_value: Option<&'a str>,
pub exponent: &'a str, pub exponent: &'a str,
pub sign: Option<&'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) = is_a("123456789")(s)?;
let (s, x) = fold_many0(alt((tag("_"), digit1)), vec![x], |mut acc: Vec<_>, item| { fold_many0(alt((tag("_"), digit1)), x, |acc, item| {
acc.push(item); str_concat::concat(acc, item).unwrap()
acc })(s)
})(s)?;
Ok((s, x))
} }
pub fn real_number(s: &str) -> IResult<&str, Number> { 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)?; let (s, x) = digit1(s)?;
fold_many0(alt((tag("_"), digit1)), vec![x], |mut acc: Vec<_>, item| { fold_many0(alt((tag("_"), digit1)), x, |acc, item| {
acc.push(item); str_concat::concat(acc, item).unwrap()
acc
})(s) })(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)?; let (s, x) = is_a("01xXzZ?")(s)?;
fold_many0( fold_many0(alt((tag("_"), is_a("01xXzZ?"))), x, |acc, item| {
alt((tag("_"), is_a("01xXzZ?"))), str_concat::concat(acc, item).unwrap()
vec![x], })(s)
|mut acc: Vec<_>, item| {
acc.push(item);
acc
},
)(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)?; let (s, x) = is_a("01234567xXzZ?")(s)?;
fold_many0( fold_many0(alt((tag("_"), is_a("01234567xXzZ?"))), x, |acc, item| {
alt((tag("_"), is_a("01234567xXzZ?"))), str_concat::concat(acc, item).unwrap()
vec![x], })(s)
|mut acc: Vec<_>, item| {
acc.push(item);
acc
},
)(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)?; let (s, x) = is_a("0123456789abcdefABCDEFxXzZ?")(s)?;
fold_many0( fold_many0(
alt((tag("_"), is_a("0123456789abcdefABCDEFxXzZ?"))), alt((tag("_"), is_a("0123456789abcdefABCDEFxXzZ?"))),
vec![x], x,
|mut acc: Vec<_>, item| { |acc, item| str_concat::concat(acc, item).unwrap(),
acc.push(item);
acc
},
)(s) )(s)
} }
@ -256,28 +240,18 @@ pub fn hex_base(s: &str) -> IResult<&str, &str> {
alt((tag_no_case("'h"), tag_no_case("'sh")))(s) 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)?; let (s, x) = tag_no_case("x")(s)?;
fold_many0( fold_many0(alt((tag("_"), is_a("_"))), x, |acc, item| {
alt((tag("_"), is_a("_"))), str_concat::concat(acc, item).unwrap()
vec![x], })(s)
|mut acc: Vec<_>, item| {
acc.push(item);
acc
},
)(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)?; let (s, x) = alt((tag_no_case("z"), tag("?")))(s)?;
fold_many0( fold_many0(alt((tag("_"), is_a("_"))), x, |acc, item| {
alt((tag("_"), is_a("_"))), str_concat::concat(acc, item).unwrap()
vec![x], })(s)
|mut acc: Vec<_>, item| {
acc.push(item);
acc
},
)(s)
} }
pub fn unbased_unsized_literal(s: &str) -> IResult<&str, &str> { pub fn unbased_unsized_literal(s: &str) -> IResult<&str, &str> {
@ -294,15 +268,15 @@ mod tests {
fn test() { fn test() {
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(number)("659")), format!("{:?}", all_consuming(number)("659")),
"Ok((\"\", IntegralNumber(UnsignedNumber([\"659\"]))))" "Ok((\"\", IntegralNumber(UnsignedNumber(\"659\"))))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(number)("'h 837FF")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("'o7460")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("4af")), format!("{:?}", all_consuming(number)("4af")),
@ -310,23 +284,23 @@ mod tests {
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(number)("4'b1001")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("5 'D 3")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("3'b01x")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("12'hx")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("16'hz")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("8 'd -6")), format!("{:?}", all_consuming(number)("8 'd -6")),
@ -334,59 +308,59 @@ mod tests {
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(number)("4 'shf")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("16'sd?")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("27_195_000")), format!("{:?}", all_consuming(number)("27_195_000")),
"Ok((\"\", IntegralNumber(UnsignedNumber([\"27\", \"_\", \"195\", \"_\", \"000\"]))))" "Ok((\"\", IntegralNumber(UnsignedNumber(\"27_195_000\"))))"
); );
assert_eq!( assert_eq!(
format!("{:?}", all_consuming(number)("16'b0011_0101_0001_1111")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("32 'h 12ab_f001")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("1.2")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("0.1")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("2394.26331")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("1.2E12")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("1.30e-2")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("0.1e-0")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("23E10")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("29E-2")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)("236.123_763_e-12")), 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!( assert_eq!(
format!("{:?}", all_consuming(number)(".12")), format!("{:?}", all_consuming(number)(".12")),

10
src/primaries.rs
View File

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