Implement bitwise operators

book/src/example-numbat_syntax.md

@@ -52,6 +52,9 @@ mod(17, 4)        # Modulo
 3 in -> cm        # Unit conversion, can also be → or ➞
 3 in to cm        # Unit conversion with the 'to' keyword
 
+0b011 ⊕ 0b110     # bitwise xor operator
+0b011 xor 0b110   # bitwise xor with the 'xor' keyword
+
 cos(pi/3 + pi)    # Call mathematical functions
 pi/3 + pi |> cos  # Same, 'arg |> f' is equivalent to 'f(arg)'
                   # The '|>' operator has the lowest precedence

book/src/operations.md

@@ -9,14 +9,20 @@ Numbat operators and other language constructs, ordered by precedence form *high
 | exponentiation            | `x^y`, `x**y`                        |
 | multiplication (implicit) | `x y` (*whitespace*)                 |
 | unary negation            | `-x`                                 |
+| bitwise 'not'             | `~x`                                 |
 | division                  | `x per y`                            |
 | division                  | `x / y`, `x ÷ y`                     |
 | multiplication (explicit) | `x * y`, `x · y`, `x × y`            |
 | subtraction               | `x - y`                              |
 | addition                  | `x + y`                              |
 | comparisons               | `x < y`, `x <= y`, `x ≤ y`, … `x == y`, `x != y` |
 | logical negation          | `!x`                                 |
+| bitwise shift right       | `x >> y`                             |
+| bitwise shift left        | `x << y`                             |
+| bitwise 'xor'             | `x ⨁ y`, `x xor y`                   |
+| bitwise 'and'             | `x & y`                              |
 | logical 'and'             | `x && y`                             |
+| bitwise 'or'              | <code>x &#124; y</code>              |
 | logical 'or'              | <code>x &#124;&#124; y</code>        |
 | unit conversion           | `x -> y`, `x → y`, `x ➞ y`, `x to y` |
 | conditionals              | `if x then y else z`                 |
@@ -28,6 +34,7 @@ Also, note that `per`-division has a higher precedence than `/`-division. This m
 
 If in doubt, you can always look at the pretty-printing output (second line in the snippet below)
 to make sure that your input was parsed correctly:
+
 ``` numbat
 >>> 1 / meter per second
 

examples/numbat_syntax.nbt

@@ -47,6 +47,9 @@ mod(17, 4)        # Modulo
 3 in -> cm        # Unit conversion, can also be → or ➞
 3 in to cm        # Unit conversion with the 'to' keyword
 
+0b011 ⊕ 0b110     # bitwise xor operator
+0b011 xor 0b110   # bitwise xor with the 'xor' keyword
+
 cos(pi/3 + pi)    # Call mathematical functions
 pi/3 + pi |> cos  # Same, 'arg |> f' is equivalent to 'f(arg)'
                   # The '|>' operator has the lowest precedence

examples/runtime_error/nonscalar_bitwise_not.nbt

@@ -0,0 +1 @@
+~2.2

examples/tests/bitwise.nbt

@@ -0,0 +1,36 @@
+# bitwise and truth table
+assert_eq(1 & 1, 1)
+assert_eq(1 & 0, 0)
+assert_eq(0 & 1, 0)
+assert_eq(0 & 0, 0)
+
+# bitwise or truth table
+assert_eq(1 | 1, 1)
+assert_eq(1 | 0, 1)
+assert_eq(0 | 1, 1)
+assert_eq(0 | 0, 0)
+
+# bitwise xor truth table
+assert_eq(0 ⨁ 0, 0)
+assert_eq(1 ⨁ 0, 1)
+assert_eq(0 ⨁ 1, 1)
+assert_eq(1 ⨁ 1, 0)
+
+assert_eq(0 xor 0, 0 ⨁ 0)
+assert_eq(1 xor 0, 1 ⨁ 0)
+assert_eq(0 xor 1, 0 ⨁ 1)
+assert_eq(1 xor 1, 1 ⨁ 1)
+
+# bitshift left checks
+assert_eq(0xFF << 2, 0x3FC)
+assert_eq(0xFF << 0, 0xFF)
+
+# bitshift right checks
+assert_eq(0xC7A5 >> 8, 0xC7)
+
+# bit flipping operation
+assert_eq(0xC700 ⨁ (0xC0 << 8), 0x700)
+assert_eq(0xC700 xor (0xC0 << 8), 0x700)
+
+# bit clearing operation
+assert_eq(0xC700 & ~(1 << 15), 0x4700)

numbat/src/ast.rs

@@ -16,6 +16,7 @@ pub enum UnaryOperator {
     Factorial(NonZeroUsize),
     Negate,
     LogicalNeg,
+    BitwiseNot,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -34,6 +35,11 @@ pub enum BinaryOperator {
     NotEqual,
     LogicalAnd,
     LogicalOr,
+    BitwiseOr,
+    BitwiseAnd,
+    BitwiseXor,
+    BitShiftLeft,
+    BitShiftRight,
 }
 
 impl PrettyPrint for BinaryOperator {
@@ -55,6 +61,11 @@ impl PrettyPrint for BinaryOperator {
             NotEqual => "≠",
             LogicalAnd => "&&",
             LogicalOr => "||",
+            BitwiseOr => "|",
+            BitwiseAnd => "&",
+            BitwiseXor => "⨁",
+            BitShiftLeft => "<<",
+            BitShiftRight => ">>",
         });
 
         match self {

numbat/src/bytecode_interpreter.rs

@@ -109,6 +109,10 @@ impl BytecodeInterpreter {
                 self.compile_expression(lhs);
                 self.vm.add_op(Op::LogicalNeg);
             }
+            Expression::UnaryOperator(_span, UnaryOperator::BitwiseNot, lhs, _type) => {
+                self.compile_expression(lhs);
+                self.vm.add_op(Op::BitwiseNot);
+            }
             Expression::BinaryOperator(_span, operator, lhs, rhs, _type) => {
                 self.compile_expression(lhs);
                 self.compile_expression(rhs);
@@ -128,6 +132,11 @@ impl BytecodeInterpreter {
                     BinaryOperator::NotEqual => Op::NotEqual,
                     BinaryOperator::LogicalAnd => Op::LogicalAnd,
                     BinaryOperator::LogicalOr => Op::LogicalOr,
+                    BinaryOperator::BitwiseOr => Op::BitwiseOr,
+                    BinaryOperator::BitwiseAnd => Op::BitwiseAnd,
+                    BinaryOperator::BitwiseXor => Op::BitwiseXor,
+                    BinaryOperator::BitShiftLeft => Op::BitShiftLeft,
+                    BinaryOperator::BitShiftRight => Op::BitShiftRight,
                 };
                 self.vm.add_op(op);
             }

numbat/src/diagnostic.rs

@@ -125,7 +125,8 @@ impl ErrorDiagnostic for TypeCheckError {
                 d.with_labels(labels).with_notes(vec![inner_error])
             }
             TypeCheckError::NonScalarExponent(span, type_)
-            | TypeCheckError::NonScalarFactorialArgument(span, type_) => d
+            | TypeCheckError::NonScalarFactorialArgument(span, type_)
+            | TypeCheckError::NonScalarBitwiseNotArgument(span, type_) => d
                 .with_labels(vec![span
                     .diagnostic_label(LabelStyle::Primary)
                     .with_message(format!("{type_}"))])

numbat/src/interpreter/mod.rs

@@ -27,6 +27,8 @@ pub enum RuntimeError {
     FactorialOfNegativeNumber,
     #[error("Expected factorial argument to be a finite integer number")]
     FactorialOfNonInteger,
+    #[error("Expected bitwise not argument to be a finite integer number")]
+    BitwiseNotOfNonInteger,
     #[error("{0}")]
     UnitRegistryError(UnitRegistryError), // TODO: can this even be triggered?
     #[error("{0}")]

numbat/src/keywords.rs

@@ -11,6 +11,7 @@ pub const KEYWORDS: &[&str] = &[
     "unit ",
     "use ",
     "struct ",
+    "xor ",
     // 'inline' keywords
     "long",
     "short",

numbat/src/number.rs

@@ -136,6 +136,46 @@ impl std::ops::Mul for Number {
     }
 }
 
+impl std::ops::BitOr for Number {
+    type Output = Number;
+
+    fn bitor(self, rhs: Self) -> Self::Output {
+        Number((self.0 as i64 | rhs.0 as i64) as f64)
+    }
+}
+
+impl std::ops::BitAnd for Number {
+    type Output = Number;
+
+    fn bitand(self, rhs: Self) -> Self::Output {
+        Number((self.0 as i64 & rhs.0 as i64) as f64)
+    }
+}
+
+impl std::ops::BitXor for Number {
+    type Output = Number;
+
+    fn bitxor(self, rhs: Self) -> Self::Output {
+        Number((self.0 as i64 ^ rhs.0 as i64) as f64)
+    }
+}
+
+impl std::ops::Shl for Number {
+    type Output = Number;
+
+    fn shl(self, rhs: Self) -> Self::Output {
+        Number(((self.0 as i64) << rhs.0 as i64) as f64)
+    }
+}
+
+impl std::ops::Shr for Number {
+    type Output = Number;
+
+    fn shr(self, rhs: Self) -> Self::Output {
+        Number(((self.0 as i64) >> (rhs.0 as i64)) as f64)
+    }
+}
+
 impl std::ops::Div for Number {
     type Output = Number;
 
@@ -152,6 +192,14 @@ impl std::ops::Neg for Number {
     }
 }
 
+impl std::ops::Not for Number {
+    type Output = Number;
+
+    fn not(self) -> Self::Output {
+        Number(!(self.0 as i64) as f64)
+    }
+}
+
 impl std::iter::Product for Number {
     fn product<I: Iterator<Item = Self>>(iter: I) -> Self {
         iter.fold(Number::from_f64(1.0), |acc, n| acc * n)

numbat/src/parser.rs

@@ -1139,6 +1139,15 @@ impl<'a> Parser<'a> {
             tokens,
             &[TokenKind::LogicalOr],
             |_| BinaryOperator::LogicalOr,
+            |parser| parser.bitwise_or(tokens),
+        )
+    }
+
+    fn bitwise_or(&mut self, tokens: &[Token<'a>]) -> Result<Expression<'a>> {
+        self.parse_binop(
+            tokens,
+            &[TokenKind::BitwiseOr],
+            |_| BinaryOperator::BitwiseOr,
             |parser| parser.logical_and(tokens),
         )
     }
@@ -1148,6 +1157,42 @@ impl<'a> Parser<'a> {
             tokens,
             &[TokenKind::LogicalAnd],
             |_| BinaryOperator::LogicalAnd,
+            |parser| parser.bitwise_and(tokens),
+        )
+    }
+
+    fn bitwise_and(&mut self, tokens: &[Token<'a>]) -> Result<Expression<'a>> {
+        self.parse_binop(
+            tokens,
+            &[TokenKind::BitwiseAnd],
+            |_| BinaryOperator::BitwiseAnd,
+            |parser| parser.bitwise_xor(tokens),
+        )
+    }
+
+    fn bitwise_xor(&mut self, tokens: &[Token<'a>]) -> Result<Expression<'a>> {
+        self.parse_binop(
+            tokens,
+            &[TokenKind::BitwiseXor],
+            |_| BinaryOperator::BitwiseXor,
+            |parser| parser.bitshift_left(tokens),
+        )
+    }
+
+    fn bitshift_left(&mut self, tokens: &[Token<'a>]) -> Result<Expression<'a>> {
+        self.parse_binop(
+            tokens,
+            &[TokenKind::BitShiftLeft],
+            |_| BinaryOperator::BitShiftLeft,
+            |parser| parser.bitshift_right(tokens),
+        )
+    }
+
+    fn bitshift_right(&mut self, tokens: &[Token<'a>]) -> Result<Expression<'a>> {
+        self.parse_binop(
+            tokens,
+            &[TokenKind::BitShiftRight],
+            |_| BinaryOperator::BitShiftRight,
             |parser| parser.logical_neg(tokens),
         )
     }
@@ -1239,6 +1284,15 @@ impl<'a> Parser<'a> {
                 expr: Box::new(rhs),
                 span_op: span,
             })
+        } else if self.match_exact(tokens, TokenKind::BitwiseNot).is_some() {
+            let span = self.last(tokens).unwrap().span;
+            let rhs = self.unary(tokens)?;
+
+            Ok(Expression::UnaryOperator {
+                op: UnaryOperator::BitwiseNot,
+                expr: Box::new(rhs),
+                span_op: span,
+            })
         } else if self.match_exact(tokens, TokenKind::Plus).is_some() {
             // A unary `+` is equivalent to nothing. We can get rid of the
             // symbol without inserting any nodes in the AST.
@@ -3189,6 +3243,8 @@ mod tests {
         "###);
     }
 
+    // TODO: Add test for bitwise operations
+
     #[test]
     fn logical_operation() {
         // basic

numbat/src/quantity.rs

@@ -306,6 +306,46 @@ impl std::ops::Mul for Quantity {
     }
 }
 
+impl std::ops::BitOr for Quantity {
+    type Output = Quantity;
+
+    fn bitor(self, rhs: Self) -> Self::Output {
+        Quantity::new(self.value | rhs.value, self.unit.clone())
+    }
+}
+
+impl std::ops::BitAnd for Quantity {
+    type Output = Quantity;
+
+    fn bitand(self, rhs: Self) -> Self::Output {
+        Quantity::new(self.value & rhs.value, self.unit.clone())
+    }
+}
+
+impl std::ops::BitXor for Quantity {
+    type Output = Quantity;
+
+    fn bitxor(self, rhs: Self) -> Self::Output {
+        Quantity::new(self.value ^ rhs.value, self.unit.clone())
+    }
+}
+
+impl std::ops::Shl for Quantity {
+    type Output = Quantity;
+
+    fn shl(self, rhs: Self) -> Self::Output {
+        Quantity::new(self.value << rhs.value, self.unit.clone())
+    }
+}
+
+impl std::ops::Shr for Quantity {
+    type Output = Quantity;
+
+    fn shr(self, rhs: Self) -> Self::Output {
+        Quantity::new(self.value >> rhs.value, self.unit.clone())
+    }
+}
+
 impl std::ops::Div for Quantity {
     type Output = Quantity;
 
@@ -314,6 +354,14 @@ impl std::ops::Div for Quantity {
     }
 }
 
+impl std::ops::Not for Quantity {
+    type Output = Quantity;
+
+    fn not(self) -> Self::Output {
+        Quantity::new(!self.value, self.unit)
+    }
+}
+
 impl std::ops::Neg for Quantity {
     type Output = Quantity;