Add Hexadecimal and Binary input support (#6)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "qcalc"
-version = "0.4.1"
+version = "0.5.0"
 edition = "2021"
 authors = ["ochir <ochir_erkhembayar@yahoo.com>"]
 description = """

README.md

@@ -21,6 +21,7 @@ The software is provided "as is," without warranty of any kind, express or impli
 - Built in functions
 - Clearing past expressions
 - Resetting variables
+- Binary and hexadecimal inputs eg. "0xff + 0b10 / 10"
 
 #### Feature requests / Bug reports
 - Feel free to open an issue and i'll look into it

src/app.rs

@@ -302,4 +302,12 @@ mod tests {
         input_and_evaluate(&mut app, "foo(2, 3)");
         assert_output(&app, 17.0);
     }
+
+    #[test]
+    fn test_bin_hex() {
+        let mut app = new_app();
+
+        input_and_evaluate(&mut app, "0x1f + 0b110 / 2");
+        assert_output(&app, 34.0);
+    }
 }

src/token.rs

@@ -85,17 +85,49 @@ impl<'a> Iterator for Tokenizer<'a> {
             ')' => Token::RParen,
             '^' => Token::Power,
             '0'..='9' => {
-                let mut num = next.to_string();
-                while self.input.peek().is_some_and(|c| c.is_ascii_digit()) {
-                    num.push(self.input.next().unwrap());
-                }
-                if self.input.peek().is_some_and(|c| *c == '.') {
-                    num.push(self.input.next().unwrap());
+                // Check if it's hex
+                if next == '0'
+                    && self
+                        .input
+                        .peek()
+                        .is_some_and(|c| matches!(c, 'x' | 'X' | 'b' | 'B'))
+                {
+                    match self.input.next().unwrap() {
+                        'x' | 'X' => {
+                            let mut hex = String::new();
+                            while self.input.peek().is_some_and(|c| {
+                                c.is_numeric() || matches!(c, 'a'..='f' | 'A'..='F')
+                            }) {
+                                hex.push(self.input.next().unwrap());
+                            }
+                            Token::Num(i32::from_str_radix(&hex, 16).unwrap() as f64)
+                        }
+                        'b' | 'B' => {
+                            let mut hex = String::new();
+                            while self
+                                .input
+                                .peek()
+                                .is_some_and(|c| c.is_numeric() || matches!(c, '0' | '1'))
+                            {
+                                hex.push(self.input.next().unwrap());
+                            }
+                            Token::Num(i32::from_str_radix(&hex, 2).unwrap() as f64)
+                        }
+                        _ => unreachable!(),
+                    }
+                } else {
+                    let mut num = next.to_string();
                     while self.input.peek().is_some_and(|c| c.is_ascii_digit()) {
                         num.push(self.input.next().unwrap());
                     }
+                    if self.input.peek().is_some_and(|c| *c == '.') {
+                        num.push(self.input.next().unwrap());
+                        while self.input.peek().is_some_and(|c| c.is_ascii_digit()) {
+                            num.push(self.input.next().unwrap());
+                        }
+                    }
+                    Token::Num(num.parse().unwrap())
                 }
-                Token::Num(num.parse().unwrap())
             }
             'A'..='Z' | 'a'..='z' => {
                 let mut func = next.to_string();
@@ -171,4 +203,20 @@ mod tests {
         let mut tokenizer = Tokenizer::new(str.chars().peekable());
         assert_eq!(tokenizer.next(), Some(Token::Num(10.0)));
     }
+
+    #[test]
+    fn test_hex() {
+        let str = "0x1ff";
+
+        let mut tokenizer = Tokenizer::new(str.chars().peekable());
+        assert_eq!(tokenizer.next(), Some(Token::Num(511.0)));
+    }
+
+    #[test]
+    fn test_bin() {
+        let str = "0b1100";
+
+        let mut tokenizer = Tokenizer::new(str.chars().peekable());
+        assert_eq!(tokenizer.next(), Some(Token::Num(12.0)));
+    }
 }