Started working on parsing for C sizeof expressions

Author: IsaacShelton

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

@@ -550,3 +550,9 @@ pub struct EnumerationNamed {
     pub enum_type_specifier: Option<EnumTypeSpecifier>,
     pub source: Source,
 }
+
+#[derive(Clone, Debug)]
+pub struct TypeName {
+    pub specifier_qualifiers: SpecifierQualifierList,
+    pub abstract_declarator: Option<AbstractDeclarator>,
+}

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

@@ -46,7 +46,8 @@ pub enum ParseErrorKind {
     DuplicateEnumMember(String),
     MustBeConstantInteger,
     EnumMemberNameConflictsWithExistingSymbol { name: String },
-    UndefinedVariable(String),
+    UndeclaredVariable(String),
+    UndeclaredType(String),
     CannotContainNulInNullTerminatedString,
     Misc(&'static str),
 }
@@ -79,7 +80,8 @@ impl Display for ParseErrorKind {
                     "Enum member name conflicts with existing symbol '{name}'",
                 )
             }
-            ParseErrorKind::UndefinedVariable(name) => write!(f, "Undefined variable '{name}'"),
+            ParseErrorKind::UndeclaredVariable(name) => write!(f, "Undeclared variable '{name}'"),
+            ParseErrorKind::UndeclaredType(name) => write!(f, "Undeclared type '{name}'"),
             ParseErrorKind::CannotContainNulInNullTerminatedString => {
                 write!(f, "Cannot contain NUL byte in C-String'")
             }

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

@@ -3,7 +3,7 @@ use crate::{
     c::{
         ast::{
             BinaryOperation, BinaryOperator, Caster, CompoundLiteral, Expr, ExprKind, Field,
-            Subscript, Ternary,
+            Subscript, Ternary, TypeName,
         },
         parser::speculate::speculate,
         punctuator::Punctuator,
@@ -257,10 +257,17 @@ impl<'a> Parser<'a> {
                 let inner = self.parse_expr_primary()?;
                 return Ok(ExprKind::Not(Box::new(inner)).at(source));
             }
-            CTokenKind::Punctuator(Punctuator::Increment) => todo!(),
-            CTokenKind::Punctuator(Punctuator::Decrement) => todo!(),
-            CTokenKind::SizeofKeyword => todo!(),
-            CTokenKind::AlignofKeyword => todo!(),
+            CTokenKind::Punctuator(Punctuator::Increment) => todo!("parse increment expression"),
+            CTokenKind::Punctuator(Punctuator::Decrement) => todo!("parse decrement expression"),
+            CTokenKind::SizeofKeyword => {
+                if let Ok(_ty) = speculate!(self.input, self.parse_type_in_parens()) {
+                    return todo!("handle parsed sizeof(type)");
+                }
+
+                let _inner = self.parse_expr_primary_base()?;
+                todo!("parse sizeof expression")
+            }
+            CTokenKind::AlignofKeyword => todo!("parse alignof expression"),
             _ => (),
         }
 
@@ -283,12 +290,36 @@ impl<'a> Parser<'a> {
             }
 
             // Cast
-            return todo!("cast");
+            return todo!("parse cast expression");
         }
 
         self.parse_expr_atom()
     }
 
+    fn parse_type_in_parens(&mut self) -> Result<TypeName, ParseError> {
+        if !self.eat_open_paren() {
+            return Err(self.error("Expected '(' to begin type in parentheses"));
+        }
+
+        let type_name = self.parse_type_name()?;
+
+        if !self.eat_open_paren() {
+            return Err(self.error("Expected ')' after type in parentheses"));
+        }
+
+        return Ok(type_name);
+    }
+
+    pub fn parse_type_name(&mut self) -> Result<TypeName, ParseError> {
+        let specifier_qualifiers = self.parse_specifier_qualifier_list()?;
+        let abstract_declarator = self.parse_abstract_declarator().ok();
+
+        Ok(TypeName {
+            specifier_qualifiers,
+            abstract_declarator,
+        })
+    }
+
     fn parse_operator_expr(&mut self, precedence: usize, expr: Expr) -> Result<Expr, ParseError> {
         let mut lhs = expr;
 

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

@@ -14,9 +14,10 @@ use crate::{
     ast::{CInteger, FloatSize, IntegerSign, Param, Type, TypeKind},
     c::{
         ast::{
-            AlignmentSpecifierKind, DeclarationSpecifiers, Declarator, DeclaratorKind, Decorator,
-            Decorators, FunctionQualifier, FunctionSpecifier, ParameterDeclarationCore,
-            StorageClassSpecifier, TypeQualifierKind, TypeSpecifierKind, TypeSpecifierQualifier,
+            AbstractDeclarator, AbstractDeclaratorKind, AlignmentSpecifierKind,
+            DeclarationSpecifiers, Declarator, DeclaratorKind, Decorator, Decorators,
+            FunctionQualifier, FunctionSpecifier, ParameterDeclarationCore, StorageClassSpecifier,
+            TypeQualifierKind, TypeSpecifierKind, TypeSpecifierQualifier,
         },
         parser::{error::ParseErrorKind, ParseError},
     },
@@ -169,14 +170,12 @@ pub fn build_type_specifier_qualifier(
                 builder.concrete(make_anonymous_enum(ctx.ast_file, enumeration)?, ts.source)?
             }
             TypeSpecifierKind::TypedefName(typedef_name) => {
-                let ast_type = ctx
-                    .typedefs
-                    .get(&typedef_name.name)
-                    .expect("typedef exists")
-                    .ast_type
-                    .clone();
-
-                builder.concrete(ast_type.kind, typedef_name.source)?
+                let Some(typedef) = ctx.typedefs.get(&typedef_name.name) else {
+                    return Err(ParseErrorKind::UndeclaredType(typedef_name.name.clone())
+                        .at(typedef_name.source));
+                };
+
+                builder.concrete(typedef.ast_type.kind.clone(), typedef_name.source)?
             }
         },
         TypeSpecifierQualifier::TypeQualifier(tq) => match &tq.kind {
@@ -286,3 +285,56 @@ fn get_name_and_decorators(
         }
     }
 }
+
+fn get_decorators(
+    ctx: &mut TranslateCtx,
+    abstract_declarator: &AbstractDeclarator,
+) -> Result<Decorators, ParseError> {
+    match &abstract_declarator.kind {
+        AbstractDeclaratorKind::Nothing => Ok(Decorators::default()),
+        AbstractDeclaratorKind::Pointer(inner, pointer) => {
+            let mut decorators = get_decorators(ctx, inner)?;
+            decorators.then_pointer(pointer.clone());
+            Ok(decorators)
+        }
+        AbstractDeclaratorKind::Function(inner, parameter_type_list) => {
+            let mut decorators = get_decorators(ctx, inner)?;
+            let mut params = Vec::with_capacity(parameter_type_list.parameter_declarations.len());
+
+            if has_parameters(parameter_type_list) {
+                for parameter in parameter_type_list.parameter_declarations.iter() {
+                    let (param_name, param_type) = match &parameter.core {
+                        ParameterDeclarationCore::Declarator(declarator) => {
+                            let declarator_info = get_name_and_type(
+                                ctx,
+                                declarator,
+                                &parameter.declaration_specifiers,
+                                true,
+                            )?;
+                            (declarator_info.name, declarator_info.ast_type)
+                        }
+                        ParameterDeclarationCore::AbstractDeclarator(_) => todo!(),
+                        ParameterDeclarationCore::Nothing => {
+                            todo!()
+                        }
+                    };
+
+                    params.push(Param::named(param_name, param_type));
+                }
+            }
+
+            decorators.then_function(FunctionQualifier {
+                params,
+                source: abstract_declarator.source,
+                is_cstyle_variadic: parameter_type_list.is_variadic,
+            });
+
+            Ok(decorators)
+        }
+        AbstractDeclaratorKind::Array(inner, array_qualifier) => {
+            let mut decorators = get_decorators(ctx, inner)?;
+            decorators.then_array(array_qualifier.clone());
+            Ok(decorators)
+        }
+    }
+}