Started working on support for C global variable declarations

IsaacShelton · IsaacShelton · commit ef4ffdc3766f · 2025-02-18T00:28:17.000-06:00
diff --git a/src/c/parser/mod.rs b/src/c/parser/mod.rs
@@ -21,7 +21,7 @@ use crate::{
     diagnostics::{Diagnostics, WarningDiagnostic},
     source_files::source::Source,
 };
-use derive_more::IsVariant;
+use derive_more::{From, IsVariant};
 use itertools::Itertools;
 use std::collections::HashMap;
 
@@ -202,17 +202,50 @@ impl From<TypeSpecifierQualifier> for DeclarationSpecifier {
     }
 }
 
-#[derive(Clone, Debug)]
-pub enum DeclarationSpecifierKind {
+#[derive(Copy, Clone, Debug, IsVariant)]
+pub enum StorageClassSpecifier {
     Auto,
     Constexpr,
     Extern,
     Register,
     Static,
     ThreadLocal,
     Typedef,
+}
+
+impl StorageClassSpecifier {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            StorageClassSpecifier::Auto => "auto",
+            StorageClassSpecifier::Constexpr => "constexpr",
+            StorageClassSpecifier::Extern => "extern",
+            StorageClassSpecifier::Register => "register",
+            StorageClassSpecifier::Static => "static",
+            StorageClassSpecifier::ThreadLocal => "thread_local",
+            StorageClassSpecifier::Typedef => "typedef",
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, IsVariant)]
+pub enum FunctionSpecifier {
     Inline,
     Noreturn,
+}
+
+impl FunctionSpecifier {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            FunctionSpecifier::Inline => "inline",
+            FunctionSpecifier::Noreturn => "_Noreturn",
+        }
+    }
+}
+
+#[derive(Clone, Debug, From)]
+pub enum DeclarationSpecifierKind {
+    StorageClassSpecifier(StorageClassSpecifier),
+    FunctionSpecifier(FunctionSpecifier),
     TypeSpecifierQualifier(TypeSpecifierQualifier),
 }
 
@@ -565,16 +598,16 @@ impl<'a> Parser<'a> {
         let CToken { kind, source } = self.input.peek();
         let source = *source;
 
-        let result = match kind {
-            CTokenKind::AutoKeyword => DeclarationSpecifierKind::Auto,
-            CTokenKind::ConstexprKeyword => DeclarationSpecifierKind::Constexpr,
-            CTokenKind::ExternKeyword => DeclarationSpecifierKind::Extern,
-            CTokenKind::RegisterKeyword => DeclarationSpecifierKind::Register,
-            CTokenKind::StaticKeyword => DeclarationSpecifierKind::Static,
-            CTokenKind::ThreadLocalKeyword => DeclarationSpecifierKind::ThreadLocal,
-            CTokenKind::TypedefKeyword => DeclarationSpecifierKind::Typedef,
-            CTokenKind::InlineKeyword => DeclarationSpecifierKind::Inline,
-            CTokenKind::NoreturnKeyword => DeclarationSpecifierKind::Noreturn,
+        let result: DeclarationSpecifierKind = match kind {
+            CTokenKind::AutoKeyword => StorageClassSpecifier::Auto.into(),
+            CTokenKind::ConstexprKeyword => StorageClassSpecifier::Constexpr.into(),
+            CTokenKind::ExternKeyword => StorageClassSpecifier::Extern.into(),
+            CTokenKind::RegisterKeyword => StorageClassSpecifier::Register.into(),
+            CTokenKind::StaticKeyword => StorageClassSpecifier::Static.into(),
+            CTokenKind::ThreadLocalKeyword => StorageClassSpecifier::ThreadLocal.into(),
+            CTokenKind::TypedefKeyword => StorageClassSpecifier::Typedef.into(),
+            CTokenKind::InlineKeyword => FunctionSpecifier::Inline.into(),
+            CTokenKind::NoreturnKeyword => FunctionSpecifier::Noreturn.into(),
             _ => {
                 return Ok(DeclarationSpecifierKind::TypeSpecifierQualifier(
                     self.parse_type_specifier_qualifier()?,
diff --git a/src/c/translation/expr/caster.rs b/src/c/translation/expr/caster.rs
@@ -34,8 +34,18 @@ pub fn get_caster_type(
 
     let base = builder.build()?;
 
-    if base.is_typedef {
-        todo!("error message for typedef base in caster");
+    if base.storage_class.is_some() {
+        return Err(ParseError::message(
+            "Storage class specifier cannot be used on cast",
+            caster.source,
+        ));
+    }
+
+    if base.function_specifier.is_some() {
+        return Err(ParseError::message(
+            "Storage class specifier cannot be used on cast",
+            caster.source,
+        ));
     }
 
     Ok(base.ast_type)
diff --git a/src/c/translation/function.rs b/src/c/translation/function.rs
@@ -4,7 +4,7 @@ use crate::{
     ast::{self, AstFile, Func, FuncHead, Param, Params, Privacy},
     c::parser::{
         error::ParseErrorKind, CTypedef, DeclarationSpecifiers, Declarator,
-        ParameterDeclarationCore, ParameterTypeList, ParseError,
+        ParameterDeclarationCore, ParameterTypeList, ParseError, StorageClassSpecifier,
     },
     diagnostics::Diagnostics,
 };
@@ -20,7 +20,7 @@ pub fn declare_function(
     diagnostics: &Diagnostics,
 ) -> Result<(), ParseError> {
     let source = declarator.source;
-    let (name, return_type, is_typedef) = get_name_and_type(
+    let (name, return_type, storage_class, function_specifier) = get_name_and_type(
         ast_file,
         typedefs,
         declarator,
@@ -30,9 +30,13 @@ pub fn declare_function(
     )?;
     let mut required = vec![];
 
+    if function_specifier.is_some() {
+        return Err(ParseErrorKind::Misc("Function specifiers are not supported yet").at(source));
+    }
+
     if has_parameters(parameter_type_list) {
         for param in parameter_type_list.parameter_declarations.iter() {
-            let (name, ast_type, is_typedef) = match &param.core {
+            let (name, ast_type, storage_class, function_specifier) = match &param.core {
                 ParameterDeclarationCore::Declarator(declarator) => get_name_and_type(
                     ast_file,
                     typedefs,
@@ -45,26 +49,41 @@ pub fn declare_function(
                 ParameterDeclarationCore::Nothing => todo!(),
             };
 
-            if is_typedef {
+            if storage_class.is_some() {
+                return Err(
+                    ParseErrorKind::Misc("Storage classes not support on typedef").at(param.source),
+                );
+            }
+
+            if function_specifier.is_some() {
                 return Err(
-                    ParseErrorKind::Misc("Parameter type cannot be typedef").at(param.source)
+                    ParseErrorKind::Misc("Function specifiers cannot be used on typedef")
+                        .at(source),
                 );
             }
 
             required.push(Param { name, ast_type });
         }
     }
 
-    if is_typedef {
-        let ast_type = ast::TypeKind::FuncPtr(ast::FuncPtr {
-            parameters: required,
-            return_type: Box::new(return_type),
-            is_cstyle_variadic: parameter_type_list.is_variadic,
-        })
-        .at(declarator.source);
+    match storage_class {
+        Some(StorageClassSpecifier::Typedef) => {
+            let ast_type = ast::TypeKind::FuncPtr(ast::FuncPtr {
+                parameters: required,
+                return_type: Box::new(return_type),
+                is_cstyle_variadic: parameter_type_list.is_variadic,
+            })
+            .at(declarator.source);
 
-        typedefs.insert(name, CTypedef { ast_type });
-        return Ok(());
+            typedefs.insert(name, CTypedef { ast_type });
+            return Ok(());
+        }
+        Some(_) => {
+            return Err(
+                ParseErrorKind::Misc("Unsupported storage class here").at(declarator.source)
+            );
+        }
+        None => (),
     }
 
     let head = FuncHead {
diff --git a/src/c/translation/mod.rs b/src/c/translation/mod.rs
@@ -9,8 +9,8 @@ pub use self::{expr::translate_expr, function::declare_function};
 use crate::{
     asg::TypeParams,
     ast::{self, AstFile, Privacy},
-    c::parser::{CTypedef, DeclarationSpecifiers, Declarator, ParseError},
-    diagnostics::Diagnostics,
+    c::parser::{CTypedef, DeclarationSpecifiers, Declarator, ParseError, StorageClassSpecifier},
+    diagnostics::{Diagnostics, WarningDiagnostic},
 };
 use std::collections::HashMap;
 
@@ -22,7 +22,7 @@ pub fn declare_named_declaration(
     typedefs: &mut HashMap<String, CTypedef>,
     diagnostics: &Diagnostics,
 ) -> Result<(), ParseError> {
-    let (name, ast_type, is_typedef) = get_name_and_type(
+    let (name, ast_type, storage_class, function_specifier) = get_name_and_type(
         ast_file,
         typedefs,
         declarator,
@@ -31,7 +31,17 @@ pub fn declare_named_declaration(
         diagnostics,
     )?;
 
-    if is_typedef {
+    if let Some(StorageClassSpecifier::Typedef) = storage_class {
+        if let Some(function_specifier) = function_specifier {
+            diagnostics.push(WarningDiagnostic::new(
+                format!(
+                    "Function specifier '{}' does nothing on typedef",
+                    function_specifier.as_str()
+                ),
+                declarator.source,
+            ));
+        }
+
         ast_file.type_aliases.push(ast::TypeAlias {
             name: name.clone(),
             params: TypeParams::default(),
diff --git a/src/c/translation/types/composite.rs b/src/c/translation/types/composite.rs
@@ -54,18 +54,28 @@ pub fn make_composite(
                         for member_declarator in member.member_declarators.iter() {
                             match member_declarator {
                                 MemberDeclarator::Declarator(declarator) => {
-                                    let (name, ast_type, is_typedef) = get_name_and_type(
-                                        ast_file,
-                                        typedefs,
-                                        declarator,
-                                        &DeclarationSpecifiers::from(&member.specifier_qualifiers),
-                                        false,
-                                        diagnostics,
-                                    )?;
+                                    let (name, ast_type, storage_class, function_specifier) =
+                                        get_name_and_type(
+                                            ast_file,
+                                            typedefs,
+                                            declarator,
+                                            &DeclarationSpecifiers::from(
+                                                &member.specifier_qualifiers,
+                                            ),
+                                            false,
+                                            diagnostics,
+                                        )?;
 
-                                    if is_typedef {
+                                    if storage_class.is_some() {
                                         return Err(ParseErrorKind::Misc(
-                                            "Cannot typedef a composite's member",
+                                            "Storage classes not supported here",
+                                        )
+                                        .at(declarator.source));
+                                    }
+
+                                    if function_specifier.is_some() {
+                                        return Err(ParseErrorKind::Misc(
+                                            "Function specifiers cannot be used here",
                                         )
                                         .at(declarator.source));
                                     }
diff --git a/src/c/translation/types/get_type_base.rs b/src/c/translation/types/get_type_base.rs
@@ -25,55 +25,13 @@ pub fn get_type_base(
 
     for specifier in declaration_specifiers.specifiers.iter() {
         match &specifier.kind {
-            DeclarationSpecifierKind::Auto => {
-                return Err(ParseError::message(
-                    "'auto' not supported yet",
-                    specifier.source,
-                ))
+            DeclarationSpecifierKind::StorageClassSpecifier(storage_class) => {
+                builder.storage_class = Some(*storage_class);
             }
-            DeclarationSpecifierKind::Constexpr => {
-                return Err(ParseError::message(
-                    "'constexpr' not supported yet",
-                    specifier.source,
-                ))
-            }
-            DeclarationSpecifierKind::Extern => {
-                return Err(ParseError::message(
-                    "'extern' not supported yet",
-                    specifier.source,
-                ))
-            }
-            DeclarationSpecifierKind::Register => {
-                return Err(ParseError::message(
-                    "'register' declaration specifier not supported yet",
-                    specifier.source,
-                ))
-            }
-            DeclarationSpecifierKind::Static => {
-                return Err(ParseError::message(
-                    "'static' declaration specifier not supported yet",
-                    specifier.source,
-                ))
-            }
-            DeclarationSpecifierKind::ThreadLocal => {
-                return Err(ParseError::message(
-                    "'thread_local' declaration specifier not supported yet",
-                    specifier.source,
-                ))
-            }
-            DeclarationSpecifierKind::Typedef => builder.is_typedef = true,
-            DeclarationSpecifierKind::Inline => {
-                return Err(ParseError::message(
-                    "'inline' declaration specifier not supported yet",
-                    specifier.source,
-                ))
-            }
-            DeclarationSpecifierKind::Noreturn => {
-                return Err(ParseError::message(
-                    "'_Noreturn' declaration specifier not supported yet",
-                    specifier.source,
-                ))
+            DeclarationSpecifierKind::FunctionSpecifier(function_specifier) => {
+                builder.function_specifier = Some(*function_specifier);
             }
+
             DeclarationSpecifierKind::TypeSpecifierQualifier(tsq) => {
                 build_type_specifier_qualifier(ast_file, &mut builder, typedefs, tsq, diagnostics)?
             }
diff --git a/src/c/translation/types/mod.rs b/src/c/translation/types/mod.rs
