hblang/README.md

@@ -544,18 +544,3 @@ sqrt := fn(x: int): int {
 	return g
 }
 ```
-
-#### hex_octal_binary_literals
-```hb
-main := fn(): int {
-	hex := 0xFF
-	decimal := 255
-	octal := 0o377
-	binary := 0b11111111
-
-	if hex == decimal & octal == decimal & binary == decimal {
-		return 0
-	}
-	return 1
-}
-```

hblang/src/codegen.rs

@@ -3340,6 +3340,5 @@ mod tests {
         struct_return_from_module_function => README;
         //comptime_pointers => README;
         sort_something_viredly => README;
-        hex_octal_binary_literals => README;
     }
 }

hblang/src/lexer.rs

@@ -290,24 +290,6 @@ impl<'a> Lexer<'a> {
 
             let kind = match c {
                 ..=b' ' => continue,
-                b'0' if self.advance_if(b'x') => {
-                    while let Some(b'0'..=b'9' | b'A'..=b'F' | b'a'..=b'f') = self.peek() {
-                        self.advance();
-                    }
-                    T::Number
-                }
-                b'0' if self.advance_if(b'b') => {
-                    while let Some(b'0' | b'1') = self.peek() {
-                        self.advance();
-                    }
-                    T::Number
-                }
-                b'0' if self.advance_if(b'o') => {
-                    while let Some(b'0'..=b'7') = self.peek() {
-                        self.advance();
-                    }
-                    T::Number
-                }
                 b'0'..=b'9' => {
                     while let Some(b'0'..=b'9') = self.peek() {
                         self.advance();

hblang/src/parser.rs

@@ -389,23 +389,13 @@ impl<'a, 'b> Parser<'a, 'b> {
                 pos: token.start,
                 stmts: self.collect_list(T::Semi, T::RBrace, Self::expr),
             },
-            T::Number => {
+            T::Number => E::Number {
-                let slice = self.lexer.slice(token.range());
-                let (slice, radix) = match &slice.get(0..2) {
-                    Some("0x") => (slice.trim_start_matches("0x"), Radix::Hex),
-                    Some("0b") => (slice.trim_start_matches("0b"), Radix::Binary),
-                    Some("0o") => (slice.trim_start_matches("0o"), Radix::Octal),
-                    _ => (slice, Radix::Decimal),
-                };
-                E::Number {
                 pos: token.start,
-                    value: match u64::from_str_radix(slice, radix as u32) {
+                value: match self.lexer.slice(token.range()).parse() {
                     Ok(value) => value,
                     Err(e) => self.report(format_args!("invalid number: {e}")),
                 },
-                    radix,
+            },
-                }
-            }
             T::LParen => {
                 let expr = self.expr();
                 self.expect_advance(T::RParen);
@@ -630,15 +620,6 @@ macro_rules! generate_expr {
     (@last ($($last:tt)*),) => { $($last)* };
 }
 
-#[repr(u32)]
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum Radix {
-    Hex = 16,
-    Octal = 8,
-    Binary = 2,
-    Decimal = 10,
-}
-
 // it would be real nice if we could use relative pointers and still pattern match easily
 generate_expr! {
     #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -690,7 +671,6 @@ generate_expr! {
         Number {
             pos:   Pos,
             value: u64,
-            radix: Radix,
         },
         BinOp {
             left:  &'a Self,
@@ -1012,12 +992,7 @@ impl<'a> std::fmt::Display for Expr<'a> {
                 write!(f, "}}")?;
                 res
             }
-            Self::Number { value, radix, .. } => match radix {
+            Self::Number { value, .. } => write!(f, "{value}"),
-                Radix::Decimal => write!(f, "{value}"),
-                Radix::Hex => write!(f, "{value:#X}"),
-                Radix::Octal => write!(f, "{value:#o}"),
-                Radix::Binary => write!(f, "{value:#b}"),
-            },
             Self::Bool { value, .. } => write!(f, "{value}"),
             Self::BinOp {
                 left,

hblang/tests/codegen_tests_hex_octal_binary_literals.txt

@@ -1,3 +0,0 @@
-code size: 210
-ret: 0
-status: Ok(())