feat: pointer arithmetic

closes #60
MilkeeyCat · Oct 10, 2024 · d183aa6 · d183aa6
1 parent ab5b8a9
commit d183aa6
Show file tree

Hide file tree

Showing 3 changed files with 44 additions and 8 deletions.
diff --git a/src/codegen/codegen.rs b/src/codegen/codegen.rs
@@ -7,7 +7,7 @@ use crate::{
     parser::{
         BinOp, BitwiseOp, CmpOp, Expr, ExprArray, ExprArrayAccess, ExprBinary, ExprFunctionCall,
         ExprIdent, ExprLit, ExprStruct, ExprStructAccess, ExprStructMethod, ExprUnary, Expression,
-        Stmt, StmtFor, StmtFunction, StmtIf, StmtReturn, StmtVarDecl, StmtWhile, UnOp,
+        Stmt, StmtFor, StmtFunction, StmtIf, StmtReturn, StmtVarDecl, StmtWhile, UIntLitRepr, UnOp,
     },
     register::Register,
     scope::Scope,
@@ -364,17 +364,16 @@ impl CodeGen {
 
     fn bin_expr(
         &mut self,
-        expr: ExprBinary,
+        mut expr: ExprBinary,
         dest: Option<&Destination>,
         state: Option<&State>,
     ) -> Result<(), CodeGenError> {
-        let left_type = expr.left.type_(&self.scope)?;
-        let right_type = expr.right.type_(&self.scope)?;
-        let size = std::cmp::max(
-            self.arch.size(&left_type, &self.scope),
-            self.arch.size(&right_type, &self.scope),
+        let type_ = Type::common_type(
+            expr.left.type_(&self.scope)?,
+            expr.right.type_(&self.scope)?,
         );
-        let signed = left_type.signed() || right_type.signed();
+        let size = self.arch.size(&type_, &self.scope);
+        let signed = type_.signed();
 
         match &expr.op {
             BinOp::Assign => {
@@ -420,6 +419,23 @@ impl CodeGen {
                         })
                     };
 
+                    expr.canonicalize(&self.scope);
+
+                    match expr.op {
+                        BinOp::Add | BinOp::Sub => {
+                            if !expr.right.type_(&self.scope)?.ptr() {
+                                expr.right = Box::new(Expr::Binary(ExprBinary {
+                                    left: expr.right,
+                                    right: Box::new(Expr::Lit(ExprLit::UInt(UIntLitRepr::new(
+                                        self.arch.size(&type_.inner().unwrap(), &self.scope) as u64,
+                                    )))),
+                                    op: BinOp::Mul,
+                                }));
+                            }
+                        }
+                        _ => (),
+                    };
+
                     let (expr_dest, dest_r) = match dest {
                         Destination::Memory(_) => {
                             let r = self.arch.alloc()?;

diff --git a/src/parser/expr/expr.rs b/src/parser/expr/expr.rs
@@ -121,6 +121,25 @@ impl Expression for ExprBinary {
     }
 }
 
+impl ExprBinary {
+    pub fn canonicalize(&mut self, scope: &Scope) {
+        let type_ = self.type_(scope).unwrap();
+
+        match self {
+            ExprBinary {
+                left,
+                right,
+                op: BinOp::Add,
+            } => {
+                if type_.ptr() && right.type_(scope).unwrap().ptr() {
+                    std::mem::swap(left.as_mut(), right.as_mut());
+                }
+            }
+            _ => (),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum ExprLit {
     Int(IntLitRepr),

diff --git a/src/types/types.rs b/src/types/types.rs
@@ -170,6 +170,7 @@ impl Type {
 
     pub fn common_type(lhs: Type, rhs: Type) -> Type {
         match (lhs, rhs) {
+            (lhs, rhs) if lhs == rhs => lhs,
             (type_ @ Type::Ptr(_), int) | (int, type_ @ Type::Ptr(_)) if int.int() => type_,
             (Type::UInt(lhs), Type::UInt(rhs)) => {
                 if lhs > rhs {