Added support for C global variable definitions

Author: IsaacShelton

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

@@ -20,6 +20,7 @@ use crate::{
     ast::{AstFile, Param, Type, TypeKind},
     diagnostics::{Diagnostics, WarningDiagnostic},
     source_files::source::Source,
+    workspace::compile::header::CFileType,
 };
 use derive_more::{From, IsVariant};
 use itertools::Itertools;
@@ -30,6 +31,7 @@ pub struct Parser<'a> {
     typedefs: HashMap<String, CTypedef>,
     enum_constants: HashMap<String, Integer>,
     diagnostics: &'a Diagnostics<'a>,
+    c_file_type: CFileType,
 }
 
 impl Parser<'_> {
@@ -476,7 +478,7 @@ pub struct EnumerationNamed {
 }
 
 impl<'a> Parser<'a> {
-    pub fn new(input: Input<'a>, diagnostics: &'a Diagnostics<'a>) -> Self {
+    pub fn new(input: Input<'a>, diagnostics: &'a Diagnostics<'a>, c_file_type: CFileType) -> Self {
         let mut typedefs = HashMap::default();
 
         diagnostics.push(WarningDiagnostic::new(
@@ -499,6 +501,7 @@ impl<'a> Parser<'a> {
             typedefs,
             enum_constants: HashMap::default(),
             diagnostics,
+            c_file_type,
         }
     }
 
@@ -526,6 +529,7 @@ impl<'a> Parser<'a> {
                                     &declaration.declaration_specifiers,
                                     &mut self.typedefs,
                                     self.diagnostics,
+                                    self.c_file_type,
                                 )?,
                                 DeclaratorKind::Function(declarator, parameter_type_list) => {
                                     declare_function(
@@ -536,6 +540,7 @@ impl<'a> Parser<'a> {
                                         declarator,
                                         parameter_type_list,
                                         self.diagnostics,
+                                        self.c_file_type,
                                     )?;
                                 }
                             }

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

@@ -1,12 +1,13 @@
 use super::{parameters::has_parameters, types::get_name_and_type};
 use crate::{
     asg::TypeParams,
-    ast::{self, AstFile, Func, FuncHead, Param, Params, Privacy},
+    ast::{self, AstFile, Func, FuncHead, Param, Params},
     c::parser::{
         error::ParseErrorKind, CTypedef, DeclarationSpecifiers, Declarator,
         ParameterDeclarationCore, ParameterTypeList, ParseError, StorageClassSpecifier,
     },
     diagnostics::Diagnostics,
+    workspace::compile::header::CFileType,
 };
 use std::collections::HashMap;
 
@@ -18,6 +19,7 @@ pub fn declare_function(
     declarator: &Declarator,
     parameter_type_list: &ParameterTypeList,
     diagnostics: &Diagnostics,
+    c_file_type: CFileType,
 ) -> Result<(), ParseError> {
     let source = declarator.source;
     let (name, return_type, storage_class, function_specifier, _is_thread_local) =
@@ -100,7 +102,7 @@ pub fn declare_function(
         source,
         abide_abi: true,
         tag: None,
-        privacy: Privacy::Public,
+        privacy: c_file_type.privacy(),
     };
 
     ast_file.funcs.push(Func {

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

@@ -8,9 +8,10 @@ use self::types::get_name_and_type;
 pub use self::{expr::translate_expr, function::declare_function};
 use crate::{
     asg::TypeParams,
-    ast::{self, AstFile, Privacy},
+    ast::{self, AstFile},
     c::parser::{CTypedef, DeclarationSpecifiers, Declarator, ParseError, StorageClassSpecifier},
     diagnostics::{Diagnostics, WarningDiagnostic},
+    workspace::compile::header::CFileType,
 };
 use std::collections::HashMap;
 
@@ -21,6 +22,7 @@ pub fn declare_named_declaration(
     declaration_specifiers: &DeclarationSpecifiers,
     typedefs: &mut HashMap<String, CTypedef>,
     diagnostics: &Diagnostics,
+    c_file_type: CFileType,
 ) -> Result<(), ParseError> {
     let (name, ast_type, storage_class, function_specifier, is_thread_local) = get_name_and_type(
         ast_file,
@@ -47,14 +49,16 @@ pub fn declare_named_declaration(
             params: TypeParams::default(),
             value: ast_type.clone(),
             source: declarator.source,
-            privacy: Privacy::Public,
+            privacy: c_file_type.privacy(),
         });
 
         typedefs.insert(name, CTypedef { ast_type });
         return Ok(());
     }
 
-    if let Some(StorageClassSpecifier::Extern) = storage_class {
+    if let None | Some(StorageClassSpecifier::Extern) = storage_class {
+        let is_foreign = storage_class.is_some();
+
         if let Some(function_specifier) = function_specifier {
             diagnostics.push(WarningDiagnostic::new(
                 format!(
@@ -69,9 +73,9 @@ pub fn declare_named_declaration(
             name,
             ast_type,
             source: declarator.source,
-            is_foreign: true,
+            is_foreign,
             is_thread_local,
-            privacy: Privacy::Public,
+            privacy: c_file_type.privacy(),
             exposure: ast::Exposure::Exposed,
         });
         return Ok(());

Diff for: src/workspace/compile/header.rs

@@ -12,10 +12,26 @@ use crate::{
     text::Text,
 };
 
-pub fn header(
+#[derive(Copy, Clone, Debug)]
+pub enum CFileType {
+    Header,
+    Source,
+}
+
+impl CFileType {
+    pub fn privacy(&self) -> Privacy {
+        match self {
+            CFileType::Header => Privacy::Protected,
+            CFileType::Source => Privacy::Private,
+        }
+    }
+}
+
+pub fn c_code(
     compiler: &Compiler,
     text: impl Text,
     key: SourceFileKey,
+    c_file_type: CFileType,
 ) -> Result<AstFile, Box<(dyn Show + 'static)>> {
     let Preprocessed {
         document,
@@ -28,6 +44,7 @@ pub fn header(
     let mut parser = c::parser::Parser::new(
         c::parser::Input::new(lexed, compiler.source_files, key),
         compiler.diagnostics,
+        c_file_type,
     );
 
     let mut ast_file = parser.parse().map_err(into_show)?;

Diff for: src/workspace/compile/normal.rs

@@ -1,4 +1,4 @@
-use super::header::header;
+use super::header::{c_code, CFileType};
 use crate::{
     ast::AstFile,
     compiler::Compiler,
@@ -47,10 +47,16 @@ pub fn compile_normal_file(
                 Source::new(key, Location { line: 1, column: 1 }),
             ));
 
-            out_ast_files.push((normal_file.fs_node_id, header(compiler, text, key)?));
+            out_ast_files.push((
+                normal_file.fs_node_id,
+                c_code(compiler, text, key, CFileType::Source)?,
+            ));
         }
         NormalFileKind::CHeader => {
-            out_ast_files.push((normal_file.fs_node_id, header(compiler, text, key)?));
+            out_ast_files.push((
+                normal_file.fs_node_id,
+                c_code(compiler, text, key, CFileType::Header)?,
+            ));
         }
     }
 

Diff for: tests/success/c_global_variable/_.adept

@@ -0,0 +1,14 @@
+
+pragma => adept("3.0")
+
+#[foreign]
+func printf(format ptr#char, ...) int
+
+#[foreign]
+special_value int
+
+func main {
+    special_value = 1234
+    printf(c"special_value = %d\n", special_value)
+}
+

Diff for: tests/success/c_global_variable/special_value.c

@@ -0,0 +1,2 @@
+
+int special_value;