Implemented parsing for C alignof expressions and pre-increment/decrement expressions

IsaacShelton · IsaacShelton · commit ed71b15f195b · 2025-03-26T23:37:30.000-05:00
diff --git a/src/asg/datatype/kind/mod.rs b/src/asg/datatype/kind/mod.rs
@@ -66,7 +66,7 @@ impl TypeKind {
             TypeKind::AnonymousUnion() => false,
             TypeKind::AnonymousEnum(_) => false,
             TypeKind::FixedArray(fixed_array) => fixed_array.inner.kind.contains_polymorph(),
-            TypeKind::FuncPtr(_) => todo!(),
+            TypeKind::FuncPtr(_) => todo!("contains_polymorph FuncPtr"),
             TypeKind::Enum(_, _) => false,
             TypeKind::Structure(_, _, parameters)
             | TypeKind::Trait(_, _, parameters)
@@ -213,7 +213,7 @@ impl TypeKind {
                     inner: inner.into_owned(),
                 }))))
             }
-            TypeKind::FuncPtr(_) => todo!(),
+            TypeKind::FuncPtr(_) => todo!("map_type_params FuncPtr"),
             TypeKind::Enum(_, _) => Ok(Cow::Borrowed(self)),
             TypeKind::Structure(human_name, struct_ref, type_args) => {
                 if type_args.is_empty() {
diff --git a/src/c/ast/expr.rs b/src/c/ast/expr.rs
@@ -33,6 +33,8 @@ pub enum ExprKind {
     Cast(Box<Cast>),
     Subscript(Box<Subscript>),
     Field(Box<Field>),
+    PreIncrement(Box<Expr>),
+    PreDecrement(Box<Expr>),
     PostIncrement(Box<Expr>),
     PostDecrement(Box<Expr>),
     Identifier(String),
@@ -46,6 +48,7 @@ pub enum ExprKind {
     Call(Box<Expr>, Vec<Expr>),
     SizeOf(ast::Type),
     SizeOfValue(Box<Expr>),
+    AlignOf(ast::Type),
     IntegerPromote(Box<Expr>),
 }
 
diff --git a/src/c/parser/expr.rs b/src/c/parser/expr.rs
@@ -120,7 +120,7 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
 
         // Generic Selection
         if self.eat(CTokenKind::GenericKeyword) {
-            todo!()
+            todo!("parse _Generic");
         }
 
         Err(ParseErrorKind::Misc("Expected expression").at(source))
@@ -267,8 +267,16 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
                 let inner = self.parse_expr_primary()?;
                 return Ok(ExprKind::Not(Box::new(inner)).at(source));
             }
-            CTokenKind::Punctuator(Punctuator::Increment) => todo!("parse increment expression"),
-            CTokenKind::Punctuator(Punctuator::Decrement) => todo!("parse decrement expression"),
+            CTokenKind::Punctuator(Punctuator::Increment) => {
+                self.input.advance();
+                let inner = self.parse_expr_primary_base()?;
+                return Ok(ExprKind::PreIncrement(Box::new(inner)).at(source));
+            }
+            CTokenKind::Punctuator(Punctuator::Decrement) => {
+                self.input.advance();
+                let inner = self.parse_expr_primary_base()?;
+                return Ok(ExprKind::PreDecrement(Box::new(inner)).at(source));
+            }
             CTokenKind::SizeofKeyword => {
                 self.input.advance();
 
@@ -292,7 +300,23 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
                 let inner = self.parse_expr_primary_base()?;
                 return Ok(ExprKind::SizeOfValue(Box::new(inner)).at(source));
             }
-            CTokenKind::AlignofKeyword => todo!("parse alignof expression"),
+            CTokenKind::AlignofKeyword => {
+                self.input.advance();
+
+                let type_name = self.parse_type_in_parens()?;
+                let mut ctx =
+                    TranslateCtx::new(&mut self.ast_file, &mut self.typedefs, self.diagnostics);
+                let specifier_qualifiers = &type_name.specifier_qualifiers;
+
+                let abstract_declarator_info = get_type(
+                    &mut ctx,
+                    type_name.abstract_declarator.as_ref(),
+                    &specifier_qualifiers.into(),
+                    false,
+                )?;
+
+                return Ok(ExprKind::AlignOf(abstract_declarator_info.ast_type).at(source));
+            }
             _ => (),
         }
 
diff --git a/src/c/parser/mod.rs b/src/c/parser/mod.rs
@@ -277,7 +277,7 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
 
         #[allow(clippy::redundant_pattern_matching)]
         if let Ok(..) = speculate!(self.input, self.parse_atomic_type_specifier()) {
-            return Ok(todo!());
+            return Ok(todo!("parse atomic type specifier"));
         }
 
         if let Ok(composite) = speculate!(self.input, self.parse_struct_or_union_specifier()) {
@@ -303,7 +303,7 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
 
         #[allow(clippy::redundant_pattern_matching)]
         if let Ok(..) = speculate!(self.input, self.parse_typeof_specifier()) {
-            return Ok(todo!());
+            return Ok(todo!("parse c typeof"));
         }
 
         Err(self.error("Failed to parse type specifier"))
@@ -884,8 +884,8 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
 
     fn parse_typeof_specifier(&mut self) -> Result<(), ParseError> {
         match self.input.advance().kind {
-            CTokenKind::TypeofKeyword => todo!(),
-            CTokenKind::TypeofUnqualKeyword => todo!(),
+            CTokenKind::TypeofKeyword => todo!("parse c typeof keyword"),
+            CTokenKind::TypeofUnqualKeyword => todo!("parse c typeof_unqual keyword"),
             _ => Err(self.error("Failed to parse typeof specifier")),
         }
     }
diff --git a/src/c/translate/eval.rs b/src/c/translate/eval.rs
@@ -41,6 +41,8 @@ pub fn evaluate_to_const_integer(expr: &Expr) -> Result<BigInt, ParseError> {
         ExprKind::Float(_, _)
         | ExprKind::StringLiteral(_, _)
         | ExprKind::Compound(_)
+        | ExprKind::PreIncrement(_)
+        | ExprKind::PreDecrement(_)
         | ExprKind::PostIncrement(_)
         | ExprKind::PostDecrement(_)
         | ExprKind::CompoundLiteral(_)
@@ -52,6 +54,7 @@ pub fn evaluate_to_const_integer(expr: &Expr) -> Result<BigInt, ParseError> {
         | ExprKind::Call(_, _)
         | ExprKind::SizeOf(_)
         | ExprKind::SizeOfValue(_)
+        | ExprKind::AlignOf(_)
         | ExprKind::IntegerPromote(_) => (),
     }
 
diff --git a/src/c/translate/expr/mod.rs b/src/c/translate/expr/mod.rs
@@ -21,14 +21,14 @@ use crate::{
 pub fn translate_expr(ctx: &mut TranslateCtx, expr: &Expr) -> Result<ast::Expr, ParseError> {
     Ok(match &expr.kind {
         ExprKind::Integer(integer) => translate_expr_integer(integer, expr.source)?,
-        ExprKind::Float(_, _) => todo!(),
+        ExprKind::Float(_, _) => todo!("translate_expr float"),
         ExprKind::StringLiteral(encoding, content) => {
             translate_expr_string(encoding, content, expr.source)?
         }
         ExprKind::Bool(x) => ast::ExprKind::Boolean(*x).at(expr.source),
-        ExprKind::Nullptr => todo!(),
-        ExprKind::Character(_, _) => todo!(),
-        ExprKind::Compound(_) => todo!(),
+        ExprKind::Nullptr => todo!("translate_expr nullptr"),
+        ExprKind::Character(_, _) => todo!("translate_expr character"),
+        ExprKind::Compound(_) => todo!("translate_expr compound"),
         ExprKind::BinaryOperation(operation) => {
             let left = translate_expr(ctx, &operation.left)?;
             let right = translate_expr(ctx, &operation.right)?;
@@ -55,17 +55,17 @@ pub fn translate_expr(ctx: &mut TranslateCtx, expr: &Expr) -> Result<ast::Expr,
                 BinaryOperator::Multiply => ast::BasicBinaryOperator::Multiply.into(),
                 BinaryOperator::Divide => ast::BasicBinaryOperator::Divide.into(),
                 BinaryOperator::Modulus => ast::BasicBinaryOperator::Modulus.into(),
-                BinaryOperator::Assign => todo!(),
-                BinaryOperator::AddAssign => todo!(),
-                BinaryOperator::SubtractAssign => todo!(),
-                BinaryOperator::MultiplyAssign => todo!(),
-                BinaryOperator::DivideAssign => todo!(),
-                BinaryOperator::ModulusAssign => todo!(),
-                BinaryOperator::LeftShiftAssign => todo!(),
-                BinaryOperator::RightShiftAssign => todo!(),
-                BinaryOperator::BitAndAssign => todo!(),
-                BinaryOperator::BitXorAssign => todo!(),
-                BinaryOperator::BitOrAssign => todo!(),
+                BinaryOperator::Assign => todo!("translate_expr assign"),
+                BinaryOperator::AddAssign => todo!("translate_expr add assign"),
+                BinaryOperator::SubtractAssign => todo!("translate_expr subtract assign"),
+                BinaryOperator::MultiplyAssign => todo!("translate_expr multiply assign"),
+                BinaryOperator::DivideAssign => todo!("translate_expr divide assign"),
+                BinaryOperator::ModulusAssign => todo!("translate_expr modulus assign"),
+                BinaryOperator::LeftShiftAssign => todo!("translate_expr left shift assign"),
+                BinaryOperator::RightShiftAssign => todo!("translate_expr right shift assign"),
+                BinaryOperator::BitAndAssign => todo!("translate_expr bitwise-and assign"),
+                BinaryOperator::BitXorAssign => todo!("translate_expr bitwise-xor assign"),
+                BinaryOperator::BitOrAssign => todo!("translate_expr bitwise-ox assign"),
             };
 
             match operator {
@@ -93,6 +93,8 @@ pub fn translate_expr(ctx: &mut TranslateCtx, expr: &Expr) -> Result<ast::Expr,
         ExprKind::Cast(_) => todo!(),
         ExprKind::Subscript(_) => todo!(),
         ExprKind::Field(_) => todo!(),
+        ExprKind::PreIncrement(_) => todo!(),
+        ExprKind::PreDecrement(_) => todo!(),
         ExprKind::PostIncrement(_) => todo!(),
         ExprKind::PostDecrement(_) => todo!(),
         ExprKind::Identifier(name) => {
@@ -165,6 +167,7 @@ pub fn translate_expr(ctx: &mut TranslateCtx, expr: &Expr) -> Result<ast::Expr,
         ExprKind::SizeOfValue(value) => {
             ast::ExprKind::SizeOfValue(Box::new(translate_expr(ctx, value)?)).at(expr.source)
         }
+        ExprKind::AlignOf(_) => todo!("translate_expr AlignOf"),
         ExprKind::IntegerPromote(value) => {
             ast::ExprKind::IntegerPromote(Box::new(translate_expr(ctx, value)?)).at(expr.source)
         }
diff --git a/src/c/translate/function.rs b/src/c/translate/function.rs
@@ -124,7 +124,7 @@ fn translate_compound_statement(
     let mut stmts = vec![];
 
     for block_item in &compound_statement.statements {
-        stmts.push(translate_block_item(ctx, block_item)?);
+        stmts.extend(translate_block_item(ctx, block_item)?);
     }
 
     Ok(stmts)
@@ -133,21 +133,23 @@ fn translate_compound_statement(
 fn translate_block_item(
     ctx: &mut TranslateCtx,
     block_item: &BlockItem,
-) -> Result<ast::Stmt, ParseError> {
+) -> Result<Option<ast::Stmt>, ParseError> {
     match &block_item.kind {
         BlockItemKind::Declaration(declaration) => match declaration {
             Declaration::Common(_) => todo!("translate_block_item common declaration"),
-            Declaration::StaticAssert(static_assert) => Ok(ast::ExprKind::StaticAssert(
-                Box::new(translate_expr(ctx, &static_assert.condition.value)?),
-                static_assert.message.clone(),
-            )
-            .at(block_item.source)
-            .stmt()),
+            Declaration::StaticAssert(static_assert) => Ok(Some(
+                ast::ExprKind::StaticAssert(
+                    Box::new(translate_expr(ctx, &static_assert.condition.value)?),
+                    static_assert.message.clone(),
+                )
+                .at(block_item.source)
+                .stmt(),
+            )),
             Declaration::Attribute(_) => todo!("translate_block_item attribute declaration"),
         },
-        BlockItemKind::UnlabeledStatement(unlabeled_statement) => {
-            translate_unlabeled_statement(ctx, unlabeled_statement, block_item.source)
-        }
+        BlockItemKind::UnlabeledStatement(unlabeled_statement) => Ok(
+            translate_unlabeled_statement(ctx, unlabeled_statement, block_item.source)?,
+        ),
         BlockItemKind::Label(_) => todo!("translate_block_item label"),
     }
 }
@@ -156,7 +158,7 @@ fn translate_unlabeled_statement(
     ctx: &mut TranslateCtx,
     unlabeled_statement: &UnlabeledStatement,
     source: Source,
-) -> Result<ast::Stmt, ParseError> {
+) -> Result<Option<ast::Stmt>, ParseError> {
     match unlabeled_statement {
         UnlabeledStatement::ExprStatement(expr_statement) => {
             translate_expr_statement(ctx, expr_statement)
@@ -172,7 +174,7 @@ fn translate_unlabeled_statement(
                 ));
             }
 
-            translate_jump_statement(ctx, jump_statement, source)
+            Ok(Some(translate_jump_statement(ctx, jump_statement, source)?))
         }
     }
 }
@@ -200,9 +202,9 @@ fn translate_jump_statement(
 fn translate_expr_statement(
     ctx: &mut TranslateCtx,
     expr_statement: &ExprStatement,
-) -> Result<ast::Stmt, ParseError> {
+) -> Result<Option<ast::Stmt>, ParseError> {
     match expr_statement {
-        ExprStatement::Empty => todo!(),
+        ExprStatement::Empty => Ok(None),
         ExprStatement::Normal(attributes, expr) => {
             if !attributes.is_empty() {
                 return Err(ParseError::message(
@@ -211,7 +213,9 @@ fn translate_expr_statement(
                 ));
             }
 
-            Ok(ast::StmtKind::Expr(translate_expr(ctx, expr)?).at(expr.source))
+            Ok(Some(
+                ast::StmtKind::Expr(translate_expr(ctx, expr)?).at(expr.source),
+            ))
         }
     }
 }
diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
@@ -206,7 +206,9 @@ impl<'a, S: SyscallHandler> Interpreter<'a, S> {
                     let subject_pointer = self.eval(&registers, subject_pointer).as_u64().unwrap();
                     Value::Literal(ir::Literal::Unsigned64(subject_pointer + offset))
                 }
-                ir::Instr::ArrayAccess { .. } => todo!(),
+                ir::Instr::ArrayAccess { .. } => {
+                    todo!("Interpreter / ir::Instruction::ArrayAccess")
+                }
                 ir::Instr::StructLiteral(ty, values) => {
                     let mut field_values = Vec::with_capacity(values.len());
 
diff --git a/src/interpreter/size_of.rs b/src/interpreter/size_of.rs
@@ -32,8 +32,8 @@ pub fn size_of(ir_type: &ir::Type, ir_module: &ir::Module) -> u64 {
                 .iter()
                 .fold(0, |acc, field| acc + size_of(&field.ir_type, ir_module))
         }
-        ir::Type::FuncPtr => todo!(),
-        ir::Type::FixedArray(_) => todo!(),
+        ir::Type::FuncPtr => todo!("size_of ir::FuncPtr"),
+        ir::Type::FixedArray(_) => todo!("size_of ir::FixedArray"),
         ir::Type::Vector(_) => todo!("interpreting vector types not supported yet"),
         ir::Type::Complex(_) => todo!("interpreting complex numeric types not support yet"),
         ir::Type::Atomic(inner) => size_of(inner, ir_module),

Original file line number	Diff line number	Diff line change
`@@ -277,7 +277,7 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {`
`277`	`277`
`278`	`278`	`#[allow(clippy::redundant_pattern_matching)]`
`279`	`279`	`if let Ok(..) = speculate!(self.input, self.parse_atomic_type_specifier()) {`
`280`		`- return Ok(todo!());`
	`280`	`+ return Ok(todo!("parse atomic type specifier"));`
`281`	`281`	`}`
`282`	`282`
`283`	`283`	`if let Ok(composite) = speculate!(self.input, self.parse_struct_or_union_specifier()) {`
`@@ -303,7 +303,7 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {`
`303`	`303`
`304`	`304`	`#[allow(clippy::redundant_pattern_matching)]`
`305`	`305`	`if let Ok(..) = speculate!(self.input, self.parse_typeof_specifier()) {`
`306`		`- return Ok(todo!());`
	`306`	`+ return Ok(todo!("parse c typeof"));`
`307`	`307`	`}`
`308`	`308`
`309`	`309`	`Err(self.error("Failed to parse type specifier"))`
`@@ -884,8 +884,8 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {`
`884`	`884`
`885`	`885`	`fn parse_typeof_specifier(&mut self) -> Result<(), ParseError> {`
`886`	`886`	`match self.input.advance().kind {`
`887`		`- CTokenKind::TypeofKeyword => todo!(),`
`888`		`- CTokenKind::TypeofUnqualKeyword => todo!(),`
	`887`	`+ CTokenKind::TypeofKeyword => todo!("parse c typeof keyword"),`
	`888`	`+ CTokenKind::TypeofUnqualKeyword => todo!("parse c typeof_unqual keyword"),`
`889`	`889`	`_ => Err(self.error("Failed to parse typeof specifier")),`
`890`	`890`	`}`
`891`	`891`	`}`