feat: hexadecimal & binary number (#389)

* feat: hexadecimal & binary number

* fix: clippy

* feat: octal number

* tests: add some tests

Author: CjiW

src/nomparser/constval.rs

@@ -1,5 +1,6 @@
 use nom::{
     branch::alt,
+    bytes::complete::tag,
     character::complete::{one_of, space0},
     combinator::{map_res, opt, recognize},
     multi::{many0, many1},
@@ -13,18 +14,39 @@ use internal_macro::{test_parser, test_parser_error};
 use nom::character::complete::char;
 
 use super::*;
-#[test_parser_error("_10")]
 #[test_parser(".10")]
 #[test_parser("10.10")]
 #[test_parser("10")]
-#[test_parser("10_00_3")]
+#[test_parser("10_00__3")]
+#[test_parser("0X1a")]
+#[test_parser("0o17")]
+#[test_parser("0b101")]
+#[test_parser_error("_10")]
 #[test_parser_error("10.")]
+#[test_parser_error("0x12g3")]
+#[test_parser_error("0o12.3")]
+#[test_parser_error("0b123")]
 pub fn number(input: Span) -> IResult<Span, Box<NodeEnum>> {
     let (input, _) = space0(input)?;
     let (re, value) = alt((
         map_res(float, |out| {
             Ok::<Num, ()>(Num::Float(out.fragment().parse::<f64>().unwrap()))
         }),
+        map_res(hexadecimal, |out| {
+            let res =
+                u64::from_str_radix(out.fragment().replace('_', "").get(2..).unwrap(), 16).unwrap();
+            Ok::<Num, ()>(Num::Int(res))
+        }),
+        map_res(octal, |out| {
+            let res =
+                u64::from_str_radix(out.fragment().replace('_', "").get(2..).unwrap(), 8).unwrap();
+            Ok::<Num, ()>(Num::Int(res))
+        }),
+        map_res(binary, |out| {
+            let res =
+                u64::from_str_radix(out.fragment().replace('_', "").get(2..).unwrap(), 2).unwrap();
+            Ok::<Num, ()>(Num::Int(res))
+        }),
         map_res(decimal, |out| {
             // TODO:err tolerate
             Ok::<Num, ()>(Num::Int(
@@ -73,6 +95,44 @@ fn decimal(input: Span) -> IResult<Span, Span> {
     recognize(many1(terminated(one_of("0123456789"), many0(char('_')))))(input)
 }
 
+#[test_parser("0x10")]
+#[test_parser("0X1a3")]
+#[test_parser("0x1_2__3")]
+#[test_parser_error("x123")]
+#[test_parser_error("0x12g3")]
+fn hexadecimal(input: Span) -> IResult<Span, Span> {
+    recognize(preceded(
+        alt((tag("0x"), tag("0X"))),
+        many1(terminated(
+            one_of("0123456789abcdefABCDEF"),
+            many0(char('_')),
+        )),
+    ))(input)
+}
+
+#[test_parser("0o10")]
+#[test_parser("0O173")]
+#[test_parser("0o1_2__3")]
+#[test_parser_error("o123")]
+#[test_parser_error("0o1283")]
+fn octal(input: Span) -> IResult<Span, Span> {
+    recognize(preceded(
+        alt((tag("0o"), tag("0O"))),
+        many1(terminated(one_of("01234567"), many0(char('_')))),
+    ))(input)
+}
+
+#[test_parser("0b101")]
+#[test_parser("0B0_01_")]
+#[test_parser_error("B001")]
+#[test_parser_error("0b0201")]
+fn binary(input: Span) -> IResult<Span, Span> {
+    recognize(preceded(
+        alt((tag("0b"), tag("0B"))),
+        many1(terminated(one_of("01"), many0(char('_')))),
+    ))(input)
+}
+
 #[test_parser(".12")]
 #[test_parser(".1_2")]
 #[test_parser(".12e1")]

test/test/simple.pi

@@ -15,8 +15,17 @@ pub fn test_primitives() void {
     let utest: u8 = 1;
     utest = utest + 2;
     test = 127;
+    panic::assert(test == 0x7f);
+    panic::assert(test == 0o177);
+    panic::assert(test == 0b0111_1111);
     test = -test - 1;
+    panic::assert(test == 0x80);
+    panic::assert(test == 0o200);
+    panic::assert(test == 0b1000_0000);
     panic::assert(test as i64 == -128);
+    panic::assert(test as i64 == 0xffff_ffff_ffff_ff80);
+    panic::assert(test as i64 == 0o1777777777777777777600);
+    panic::assert(test as i64 == 0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_10000000);
     let b = test | 1;
     panic::assert(b as i64 == -127);
     let c = test & 1;