Added basic support for function calls in C

Author: IsaacShelton

Diff for: src/c/parser/mod.rs

@@ -1222,11 +1222,13 @@ impl<'a> Parser<'a> {
         }
 
         let attributes = self.parse_attribute_specifier_sequence()?;
+        let expr = self.parse_expr_multiple()?;
 
-        return Ok(ExprStatement::Normal(
-            attributes,
-            self.parse_expr_multiple()?,
-        ));
+        if !self.eat_punctuator(Punctuator::Semicolon) {
+            return Err(self.error("Expected ';' after statement"));
+        }
+
+        return Ok(ExprStatement::Normal(attributes, expr));
     }
 
     fn parse_label(&mut self) -> Result<Label, ParseError> {

Diff for: src/c/translate/expr/mod.rs

@@ -11,9 +11,11 @@ use super::TranslateCtx;
 use crate::{
     ast,
     c::{
+        self,
         ast::expr::{BinaryOperator, Expr, ExprKind},
-        parser::{error::ParseErrorKind, ParseError},
+        parser::ParseError,
     },
+    name::Name,
 };
 
 pub fn translate_expr(ctx: &mut TranslateCtx, expr: &Expr) -> Result<ast::Expr, ParseError> {
@@ -91,7 +93,7 @@ pub fn translate_expr(ctx: &mut TranslateCtx, expr: &Expr) -> Result<ast::Expr,
         ExprKind::PostIncrement(_) => todo!(),
         ExprKind::PostDecrement(_) => todo!(),
         ExprKind::Identifier(name) => {
-            return Err(ParseErrorKind::UndefinedVariable(name.into()).at(expr.source));
+            return Ok(ast::ExprKind::Variable(Name::plain(name)).at(expr.source));
         }
         ExprKind::EnumConstant(_, _) => todo!(),
         ExprKind::CompoundLiteral(compound_literal) => {
@@ -128,6 +130,30 @@ pub fn translate_expr(ctx: &mut TranslateCtx, expr: &Expr) -> Result<ast::Expr,
             inner: translate_expr(ctx, inner)?,
         }))
         .at(expr.source),
-        ExprKind::Call(_target, _args) => todo!("translate C call expression"),
+        ExprKind::Call(target, c_args) => {
+            eprintln!("warning: c function call expression are not isolated yet to only call functions defined within then same file");
+            eprintln!("warning: c function call expression cannot call expression yet");
+
+            let c::ast::ExprKind::Identifier(target) = &target.as_ref().kind else {
+                return Err(ParseError::message(
+                    "Calling the result of expressions is not supported yet",
+                    expr.source,
+                ));
+            };
+
+            let args = c_args
+                .iter()
+                .map(|c_arg| translate_expr(ctx, c_arg))
+                .collect::<Result<Vec<ast::Expr>, ParseError>>()?;
+
+            ast::ExprKind::Call(Box::new(ast::Call {
+                name: Name::plain(target),
+                args,
+                expected_to_return: None,
+                generics: vec![],
+                using: vec![],
+            }))
+            .at(expr.source)
+        }
     })
 }

Diff for: src/c/translate/function.rs

@@ -114,7 +114,6 @@ pub fn declare_function(
     };
 
     ctx.ast_file.funcs.push(Func { head, stmts });
-
     Ok(())
 }