basic panic done

Author: FishingHacks

langref.md

@@ -24,6 +24,8 @@ You also include paths using strings, not identifiers, due to not having a `mod
 
 The use keyword also allows for importing multiple exported items using the familiar `"file"::{a, b, c, ...}` syntax. If you want to just include the module, you can use `"file" as <name>`.
 
+Also note that most primitive types (all integers, bools and strings) have a `.print` and `.println` function, `"Hello, World!".println();` would've had the same output.
+
 # Comments
 
 Mira supports the standard c-style comments of line-comments using `//` and multiline comments using `/* ... */`.

lib/mirastd/langitems.mr

@@ -0,0 +1,112 @@
+use "./lib.mr"::{print_str, print_char, print_newline};
+
+pub fn print_u64(val: u64) {
+    if (val == 0) {
+        return print_str("0");
+    }
+    let chars: [u8; 20] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    let char_idx = 0usize;
+
+    while (val > 0) {
+        chars[char_idx] = (val % 10) as u8 + 48; // 48 = '0'
+        val = val / 10;
+        char_idx += 1;
+    }
+
+    while (char_idx > 0) {
+        char_idx -= 1;
+        print_char(chars[char_idx]);
+    }
+}
+pub fn print_i64(val: i64) {
+    if (val == 0) {
+        return print_str("0");
+    }
+    let chars: [u8; 20] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    let char_idx = 0usize;
+    let is_neg = val < 0;
+    if (is_neg) val = -val;
+    while (val > 0) {
+        chars[char_idx] = (val % 10) as u8 + 48; // 48 = '0'
+        val = val / 10;
+        char_idx += 1;
+    }
+
+    if (is_neg) print_char(45); // b'-'
+    while (char_idx > 0) {
+        char_idx -= 1;
+        print_char(chars[char_idx]);
+    }
+}
+
+
+
+@lang("u8")
+struct u8_t {;
+    fn print(self: u8) = print_u64(self as u64);
+    fn println(self: u8) { print_u64(self as u64); print_newline(); }
+}
+@lang("u16")
+struct u16_t {;
+    fn print(self: u16) = print_u64(self as u64);
+    fn println(self: u16) { print_u64(self as u64); print_newline(); }
+}
+@lang("u32")
+struct u32_t {;
+    fn print(self: u32) = print_u64(self as u64);
+    fn println(self: u32) { print_u64(self as u64); print_newline(); }
+}
+@lang("u64")
+struct u64_t {;
+    fn print(self: u64) = print_u64(self);
+    fn println(self: u64) { print_u64(self); print_newline(); }
+}
+@lang("usize")
+struct usize_t {;
+    fn print(self: usize) = print_u64(self as u64);
+    fn println(self: usize) { print_u64(self as u64); print_newline(); }
+}
+
+@lang("i8")
+struct i8_t {;
+    fn print(self: i8) = print_i64(self as i64);
+    fn println(self: i8) { print_i64(self as i64); print_newline(); }
+}
+@lang("i16")
+struct i16_t {;
+    fn print(self: i16) = print_i64(self as i64);
+    fn println(self: i16) { print_i64(self as i64); print_newline(); }
+}
+@lang("i32")
+struct i32_t {;
+    fn print(self: i32) = print_i64(self as i64);
+    fn println(self: i32) { print_i64(self as i64); print_newline(); }
+}
+@lang("i64")
+struct i64_t {;
+    fn print(self: i64) = print_i64(self);
+    fn println(self: i64) { print_i64(self); print_newline(); }
+}
+@lang("isize")
+struct isize_t {;
+    fn print(self: isize) = print_i64(self as i64);
+    fn println(self: isize) { print_i64(self as i64); print_newline(); }
+}
+@lang("bool")
+struct bool_t {;
+    fn print(self: bool) { if (self) print_str("true"); else print_str("false"); }
+    fn println(self: bool) { if (self) print_str("true\n"); else print_str("false\n"); }
+}
+@lang("str")
+struct str_t {;
+    fn print(self: &str) = print_str(self);
+    fn println(self: &str) { print_str(self); print_newline(); }
+    fn len(self: &str) -> usize {
+        let strn_addr = &self as &void as usize;
+        return asm(
+            "movq 8(%[straddr]), %[out]"
+            : [out] "=r" (usize)
+            : [straddr] "r" (strn_addr)
+        );
+    }
+}

lib/mirastd/lib.mr

@@ -3,14 +3,28 @@ use "./os.mr"::write;
 export Clone;
 export Copy;
 
-pub fn print_str(string: &str) = write(1, string as &u8, strlen(string));
+pub fn print_str(string: &str) = write(1, string as &u8, string.len());
 pub fn print_char(c: u8) = write(1, &c, 1);
 pub fn print_newline() = print_char(0xa);
 pub fn print_str_newline(string: &str) {
     print_str(string);
     print_newline();
 }
-pub fn print_usize_hex(val: usize) {
+
+pub fn cstrlen(cstr: &u8) -> usize {
+    let len = 0usize;
+    while (*cstr != 0) {
+        len += 1;
+        cstr = (cstr as &void as usize + 1) as &void as &u8;
+    }
+    return len;
+}
+use "./langitems.mr"::{print_u64, print_i64};
+use "./panic.mr"::panic;
+export print_u64;
+export print_i64;
+export panic;
+pub fn print_u64_hex(val: u64) {
     print_str("0x");
     if (val == 0) {
         return print_str("0");
@@ -31,39 +45,3 @@ pub fn print_usize_hex(val: usize) {
         print_char(chars[char_idx]);
     }
 }
-pub fn print_usize(val: usize) {
-    if (val == 0) {
-        return print_str("0");
-    }
-    let chars: [u8; 20] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-    let char_idx = 0usize;
-
-    while (val > 0) {
-        chars[char_idx] = (val % 10) as u8 + 48; // 48 = '0'
-        val = val / 10;
-        char_idx += 1;
-    }
-
-    while (char_idx > 0) {
-        char_idx -= 1;
-        print_char(chars[char_idx]);
-    }
-}
-
-pub fn strlen(strn: &str) -> usize {
-    let strn_addr = &strn as &void as usize;
-    return asm(
-        "movq 8(%[straddr]), %[out]"
-        : [out] "=r" (usize)
-        : [straddr] "r" (strn_addr)
-    );
-}
-
-pub fn cstrlen(cstr: &u8) -> usize {
-    let len = 0usize;
-    while (*cstr != 0) {
-        len += 1;
-        cstr = (cstr as &void as usize + 1) as &void as &u8;
-    }
-    return len;
-}

lib/mirastd/panic.mr

@@ -0,0 +1,48 @@
+use "./lib.mr"::{print_u64_hex, cstrlen};
+use "./os.mr"::write;
+
+struct unw_cursor { inner: [u64; 127] }
+struct unw_context { inner: [u64; 121] }
+let UNW_REG_IP: u32 = 16;
+
+@alias("_Ux86_64_getcontext")
+extern fn unw_getcontext(v: &unw_context);
+@alias("_Ux86_64_init_local")
+extern fn unw_init_local(cursor: &unw_cursor, v: &unw_context);
+@alias("_Ux86_64_step")
+extern fn unw_step(cursor: &unw_cursor) -> i32;
+@alias("_Ux86_64_get_reg")
+extern fn unw_get_reg(cursor: &unw_cursor, register: u32, value: &usize);
+@alias("_Ux86_64_get_proc_name")
+extern fn unw_get_proc_name(cursor: &unw_cursor, name: &u8, name_size: usize, offset: &usize) -> i32;
+
+pub fn show_bt() {
+    let cursor = unw_cursor { inner: [0u64; 127] };
+    let context = unw_context { inner: [0u64; 121] };
+    let ip = 0usize;
+    let offset = 0usize;
+
+    unw_getcontext(&context);
+    unw_init_local(&cursor, &context);
+    let name_buf = [0u8; 4096];
+    while (unw_step(&cursor) > 0) {
+        unw_get_reg(&cursor, UNW_REG_IP, &ip);
+        print_u64_hex(ip as u64);
+        ": ".print();
+        name_buf[0] = 0;
+        if (unw_get_proc_name(&cursor, &name_buf as &[u8] as &u8, 4096, &offset) == 0) {
+            "(".print();
+            write(1, &name_buf as &[u8] as &u8, cstrlen(&name_buf as &[u8] as &u8));
+            "+".print();
+            print_u64_hex(offset as u64);
+            ")".println();
+        } else "-- no symbol name was found".println();
+    }
+}
+
+pub fn panic(message: &str) {
+    "panic: ".print();
+    message.println();
+    "".println();
+    show_bt();
+}

lib/mirastd/prelude.mr

@@ -1,3 +1,4 @@
 use "./start.mr";
 use "./allocate.mr";
 use "./clone_copy.mr";
+use "./langitems.mr";

meow.mr

@@ -1,3 +1,5 @@
-fn meow() -> usize = 3;
+use "std"::panic;
 
-export meow;
+pub fn main(argc: usize, argv: &&u8) {
+    "meow meow" |> panic();
+}

mira/src/codegen/mod.rs

@@ -376,6 +376,34 @@ impl<'ctx> TypedLiteral {
                     .const_named_struct(&[ptr, len_const])
                     .into()
             }
+
+            TypedLiteral::ArrayInit(ty, _, 0) => ty
+                .to_llvm_basic_type(default_types, structs, ctx)
+                .array_type(0)
+                .const_zero()
+                .into(),
+            TypedLiteral::ArrayInit(_, elem, amount) => {
+                let elem = elem.to_basic_value(
+                    scope_get_value,
+                    default_types,
+                    structs,
+                    builder,
+                    statics,
+                    functions,
+                    ext_functions,
+                    string_map,
+                    ctx,
+                );
+                let mut array_value = elem.get_type().array_type(*amount as u32).const_zero();
+                for i in 0..*amount {
+                    array_value = builder
+                        .build_insert_value(array_value, elem, i as u32, "")
+                        .expect("i should never be out of bounds")
+                        .into_array_value();
+                }
+
+                array_value.into()
+            }
             TypedLiteral::Array(ty, elements) => {
                 if elements.is_empty() {
                     return ty
@@ -1263,9 +1291,27 @@ impl TypecheckedExpression {
                 ctx.push_value(*dst, src.fn_ctx_to_basic_value(ctx));
                 Ok(())
             }
-            TypecheckedExpression::Neg(..) => todo!(),
-            TypecheckedExpression::LNot(..) => todo!(),
-            TypecheckedExpression::BNot(..) => todo!(),
+            TypecheckedExpression::Neg(_, dst, src) => {
+                let src = src.fn_ctx_to_basic_value(ctx);
+                let value = match src {
+                    BasicValueEnum::IntValue(int_value) => ctx
+                        .builder
+                        .build_int_neg(int_value, "")?
+                        .as_basic_value_enum(),
+                    BasicValueEnum::FloatValue(float_value) => ctx
+                        .builder
+                        .build_float_neg(float_value, "")?
+                        .as_basic_value_enum(),
+                    _ => unreachable!(),
+                };
+                ctx.push_value(*dst, value);
+                Ok(())
+            }
+            TypecheckedExpression::BNot(_, dst, src) | TypecheckedExpression::LNot(_, dst, src) => {
+                let src = src.fn_ctx_to_basic_value(ctx).into_int_value();
+                ctx.push_value(*dst, ctx.builder.build_not(src, "")?.as_basic_value_enum());
+                Ok(())
+            }
             TypecheckedExpression::Add(_, dst, lhs, rhs) => {
                 let lhs = lhs.fn_ctx_to_basic_value(ctx);
                 let rhs = rhs.fn_ctx_to_basic_value(ctx);

mira/src/globals.rs

@@ -98,6 +98,9 @@ impl PartialEq<&str> for GlobalStr {
 
 impl Clone for GlobalStr {
     fn clone(&self) -> Self {
+        if self.0 == 0 {
+            return Self(self.0);
+        }
         STRINGS.with_borrow_mut(|strings: &mut GlobalStrs| {
             if let Some(v) = strings.get_mut(self.0) {
                 v.refs += 1;
@@ -134,6 +137,9 @@ impl GlobalStr {
             for (idx, v) in strings.entries.iter_mut().enumerate() {
                 if let Some(v) = v {
                     if (*v.value).eq(value) {
+                        if idx == 0 {
+                            return Self(0);
+                        }
                         v.refs += 1;
                         return Self(idx);
                     }
@@ -151,6 +157,9 @@ impl GlobalStr {
             for (idx, v) in strings.entries.iter_mut().enumerate() {
                 if let Some(v) = v {
                     if (*v.value).eq(&*value) {
+                        if idx == 0 {
+                            return Self(0);
+                        }
                         v.refs += 1;
                         return Self(idx);
                     }

mira/src/linking.rs

@@ -647,7 +647,10 @@ pub fn run_full_compilation_pipeline(
         .link(LinkOptions {
             linker_path,
             object_files: &[obj_path],
-            inputs: &[],
+            inputs: &[
+                LinkerInput::LinkLibrary("unwind".into()),
+                LinkerInput::LinkLibrary("unwind-x86_64".into()),
+            ],
             output: &exec_path,
             args: opts.additional_linker_args,
             link_crt: opts.link_with_crt,

mira/src/parser.rs

@@ -8,7 +8,9 @@ use crate::{
     globals::GlobalStr,
     tokenizer::{Location, Token, TokenType},
 };
-pub use expression::{BinaryOp, Expression, LiteralValue, Path, PathWithoutGenerics, UnaryOp};
+pub use expression::{
+    ArrayLiteral, BinaryOp, Expression, LiteralValue, Path, PathWithoutGenerics, UnaryOp,
+};
 pub use statement::{Argument, BakableFunction, FunctionContract, Statement, Trait};
 pub use types::{Generic, Implementation, Struct, TypeRef, RESERVED_TYPE_NAMES};
 mod expression;