Made 32-bit ints assumption the default, and made it so string literals can be used inside of pragma directives instead of cstring literals

Author: IsaacShelton

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

@@ -51,12 +51,7 @@ impl<'a> AstWorkspace<'a> {
         let settings = AppendOnlyVec::new();
 
         assert_eq!(
-            settings.push(Settings {
-                adept_version: AdeptVersion::CURRENT,
-                debug_skip_merging_helper_exprs: false,
-                imported_namespaces: vec![],
-                assume_int_at_least_32_bits: false,
-            }),
+            settings.push(Settings::default()),
             Self::DEFAULT_SETTINGS_ID.0
         );
 
@@ -120,6 +115,17 @@ pub struct Settings {
     pub assume_int_at_least_32_bits: bool,
 }
 
+impl Default for Settings {
+    fn default() -> Settings {
+        Settings {
+            adept_version: AdeptVersion::CURRENT,
+            debug_skip_merging_helper_exprs: false,
+            imported_namespaces: vec![],
+            assume_int_at_least_32_bits: true,
+        }
+    }
+}
+
 impl Settings {
     pub fn c_integer_assumptions(&self) -> CIntegerAssumptions {
         CIntegerAssumptions {

Diff for: src/interpreter/syscall_handler.rs

@@ -28,7 +28,7 @@ pub enum ProjectKind {
     WindowedApp = 1,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct BuildSystemSyscallHandler {
     pub projects: Vec<Project>,
     pub version: Option<AdeptVersion>,
@@ -39,6 +39,20 @@ pub struct BuildSystemSyscallHandler {
     pub assume_int_at_least_32_bits: bool,
 }
 
+impl Default for BuildSystemSyscallHandler {
+    fn default() -> Self {
+        Self {
+            projects: vec![],
+            version: None,
+            link_filenames: HashSet::new(),
+            link_frameworks: HashSet::new(),
+            debug_skip_merging_helper_exprs: false,
+            imported_namespaces: vec![],
+            assume_int_at_least_32_bits: true,
+        }
+    }
+}
+
 fn read_cstring(memory: &Memory, value: &Value) -> String {
     let mut string = String::new();
     let mut address = value.as_u64().unwrap();
@@ -125,9 +139,9 @@ impl SyscallHandler for BuildSystemSyscallHandler {
                     .push(read_cstring(memory, &args[0]).into_boxed_str());
                 Value::Literal(ir::Literal::Void)
             }
-            ir::InterpreterSyscallKind::AssumeIntAtLeast32Bits => {
+            ir::InterpreterSyscallKind::DontAssumeIntAtLeast32Bits => {
                 assert_eq!(args.len(), 0);
-                self.assume_int_at_least_32_bits = true;
+                self.assume_int_at_least_32_bits = false;
                 Value::Literal(ir::Literal::Void)
             }
         }

Diff for: src/interpreter_env/mod.rs

@@ -180,8 +180,8 @@ pub fn setup_build_system_interpreter_symbols(file: &mut AstFile) {
     ));
 
     file.functions.push(thin_void_function(
-        "assumeIntAtLeast32Bits",
-        InterpreterSyscallKind::AssumeIntAtLeast32Bits,
+        "dontAssumeIntAtLeast32Bits",
+        InterpreterSyscallKind::DontAssumeIntAtLeast32Bits,
     ));
 
     file.functions.push(Function {

Diff for: src/ir/mod.rs

@@ -146,7 +146,7 @@ pub enum InterpreterSyscallKind {
     BuildLinkFrameworkName,
     Experimental,
     ImportNamespace,
-    AssumeIntAtLeast32Bits,
+    DontAssumeIntAtLeast32Bits,
 }
 
 #[derive(Clone, Debug)]

Diff for: src/parser/mod.rs

@@ -37,11 +37,22 @@ pub fn parse(
 
 pub struct Parser<'a, I: Inflow<Token>> {
     pub input: Input<'a, I>,
+    pub treat_string_literals_as_cstring_literals: bool,
 }
 
 impl<'a, I: Inflow<Token>> Parser<'a, I> {
     pub fn new(input: Input<'a, I>) -> Self {
-        Self { input }
+        Self {
+            input,
+            treat_string_literals_as_cstring_literals: false,
+        }
+    }
+
+    pub fn new_for_pragma(input: Input<'a, I>) -> Self {
+        Self {
+            input,
+            treat_string_literals_as_cstring_literals: true,
+        }
     }
 
     pub fn parse(&mut self) -> Result<AstFile, ParseError> {

Diff for: src/parser/parse_expr/primary/mod.rs

@@ -57,7 +57,14 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                 modifier: StringModifier::Normal,
                 ..
             }) => Ok(Expr::new(
-                ExprKind::String(self.input.advance().kind.unwrap_string().value),
+                if self.treat_string_literals_as_cstring_literals {
+                    ExprKind::NullTerminatedString(
+                        CString::new(self.input.advance().kind.unwrap_string().value)
+                            .expect("valid null-terminated string"),
+                    )
+                } else {
+                    ExprKind::String(self.input.advance().kind.unwrap_string().value)
+                },
                 source,
             )),
             TokenKind::OpenParen => {

Diff for: src/pragma_section/parse.rs

@@ -29,7 +29,7 @@ impl PragmaSection {
 
         input.ignore_newlines();
 
-        let mut parser = parser::Parser::new(input);
+        let mut parser = parser::Parser::new_for_pragma(input);
         let mut ast_file = AstFile::new();
 
         if parser.input.eat(TokenKind::OpenCurly) {

Diff for: tests/raylib/_.adept

@@ -1,11 +1,11 @@
 
 pragma => {
-    adept(c"3.0")
-    link(c"libraylib.a")
-    linkFramework(c"OpenGL")
-    linkFramework(c"Cocoa")
-    linkFramework(c"IOKit")
-    linkFramework(c"Foundation")
-    linkFramework(c"CoreFoundation")
+    adept("3.0")
+    link("libraylib.a")
+    linkFramework("OpenGL")
+    linkFramework("Cocoa")
+    linkFramework("IOKit")
+    linkFramework("Foundation")
+    linkFramework("CoreFoundation")
 }
 

Diff for: tests/raylib/main.adept

@@ -1,7 +1,7 @@
 
 func main {
-    screen_width int = 800
-    screen_height int = 450
+    screen_width := 800
+    screen_height := 450
 
     InitWindow(screen_width, screen_height, c"Example Window!")