added: panic builtin procedure

onyx-lang · May 8, 2024 · a64e3ea · a64e3ea
1 parent ff0b89a
commit a64e3ea
Show file tree

Hide file tree

Showing 10 changed files with 33 additions and 28 deletions.
diff --git a/core/alloc/pool.onyx b/core/alloc/pool.onyx
@@ -29,7 +29,7 @@ pool_allocator_proc :: (pool: &PoolAllocator($Elem), aa: AllocationAction, size:
         }
 
         case .Resize {
-            assert(false, "Cannot resize in a pool allocator!");
+            panic("Cannot resize in a pool allocator!");
             return null;
         }
 

diff --git a/core/builtin.onyx b/core/builtin.onyx
@@ -148,7 +148,7 @@ OnyxContext.get_user_data :: macro (c: &OnyxContext, $T: type_expr) -> &T {
 
 
 // CLEANUP: Does assert() need to be in the builtin file?
-// It uses context.assert_handler, but does it needt to be here?
+// It uses context.assert_handler, but does it need to be here?
 
 /// Checks if the condition is true. If not, invoke the context's
 /// assert handler.
@@ -158,6 +158,11 @@ assert :: (cond: bool, msg: str, site := #callsite) {
     }
 }
 
+/// Causes a runtime panic with the specified error message.
+panic :: (msg: str, site := #callsite) {
+    context.assert_handler(msg, site);
+}
+
 
 //
 // Basic logging

diff --git a/core/container/optional.onyx b/core/container/optional.onyx
@@ -98,7 +98,7 @@ Optional.unwrap :: (o: ?$T) -> T {
     switch o {
         case .Some as v do return v;
         case _ {
-            assert(false, "Unwrapping empty Optional.");
+            panic("Unwrapping empty Optional.");
             return .{};
         }
     }
@@ -111,7 +111,7 @@ Optional.unwrap_ptr :: (o: & ?$T) -> &T {
     switch o {
         case .Some as &v do return v;
         case _ {
-            assert(false, "Unwrapping empty Optional.");
+            panic("Unwrapping empty Optional.");
             return .{};
         }
     }
@@ -124,7 +124,7 @@ Optional.expect :: (o: ?$T, message: str) -> T {
     switch o {
         case .Some as v do return v;
         case _ {
-            assert(false, message);
+            panic(message);
             return .{};
         }
     }
@@ -137,7 +137,7 @@ Optional.expect_ptr :: (o: & ?$T, message: str) -> &T {
     switch o {
         case .Some as &v do return v;
         case _ {
-            assert(false, message);
+            panic(message);
             return .{};
         }
     }

diff --git a/core/container/result.onyx b/core/container/result.onyx
@@ -61,7 +61,7 @@ Result.unwrap :: (r: #Self) -> r.Ok_Type {
         case .Ok as v do return v;
         case .Err as err {
             msg := tprintf("Unwrapping Result with error '{}'.", err);
-            assert(false, msg);
+            panic(msg);
             return .{};
         }
     }
@@ -82,7 +82,7 @@ Result.expect :: (r: #Self, msg: str) -> r.Ok_Type {
     switch r {
         case .Ok as v do return v;
         case _ {
-            assert(false, msg);
+            panic(msg);
             return .{};
         }
     }

diff --git a/core/conv/format.onyx b/core/conv/format.onyx
@@ -678,7 +678,7 @@ format_any :: (output: &Format_Output, formatting: &Format, v: any) {
                     case i16, u16 do value = cast(u64) *(cast(&u16) v.data);
                     case i32, u32 do value = cast(u64) *(cast(&u32) v.data);
                     case i64, u64 do value = cast(u64) *(cast(&u64) v.data);
-                    case _ do assert(false, "Bad enum backing type");
+                    case _ do panic("Bad enum backing type");
                 }
 
                 if !formatting.interpret_numbers {
@@ -736,7 +736,7 @@ format_any :: (output: &Format_Output, formatting: &Format, v: any) {
                     case i16, u16 do tag_value = cast(u64) *(cast(&u16) v.data);
                     case i32, u32 do tag_value = cast(u64) *(cast(&u32) v.data);
                     case i64, u64 do tag_value = cast(u64) *(cast(&u64) v.data);
-                    case _ do assert(false, "Bad union backing type");
+                    case _ do panic("Bad union backing type");
                 }
 
                 variant := array.first(u.variants, [x](x.tag_value == ~~tag_value));

diff --git a/core/encoding/osad.onyx b/core/encoding/osad.onyx
@@ -127,7 +127,7 @@ serialize :: (v: any, w: &io.Writer) -> bool {
                 case i16, u16 do tag_value = cast(u64) *(cast(&u16) v.data);
                 case i32, u32 do tag_value = cast(u64) *(cast(&u32) v.data);
                 case i64, u64 do tag_value = cast(u64) *(cast(&u64) v.data);
-                case _ do assert(false, "Bad union backing type");
+                case _ do panic("Bad union backing type");
             }
 
             variant := array.first(u_info.variants, [x](x.tag_value == ~~tag_value));
@@ -264,7 +264,7 @@ deserialize :: (target: rawptr, type: type_expr, r: &io.Reader, allocator := con
                 case i16, u16 do *(cast(&u16) target) = ~~variant_value;
                 case i32, u32 do *(cast(&u32) target) = ~~variant_value;
                 case i64, u64 do *(cast(&u64) target) = ~~variant_value;
-                case _ do assert(false, "Bad union backing type");
+                case _ do panic("Bad union backing type");
             }
 
             try(deserialize(base + u_info.alignment, variant.type, r));

diff --git a/core/io/binary.onyx b/core/io/binary.onyx
@@ -22,7 +22,7 @@ binary_write :: (use bw: &BinaryWriter, $T: type_expr, v: &T) {
 }
 
 binary_write_slice :: (use bw: &BinaryWriter, sl: [] $T, output_size := false) {
-    assert(false, "binary_write_slice is not working at the moment");
+    panic("binary_write_slice is not working at the moment");
     if output_size do binary_write(bw, i32, sl.count);
 
     bytes := ([] u8).{
@@ -64,7 +64,7 @@ binary_read_slice :: (use br: &BinaryReader,
     size := 0, read_size := false,
     allocator := context.allocator) -> [] T {
 
-    assert(false, "binary_write_slice is not working at the moment");
+    panic("binary_write_slice is not working at the moment");
 
     if size == 0 && read_size {
         size = binary_read(br, i32);

diff --git a/core/math/math.onyx b/core/math/math.onyx
@@ -65,22 +65,22 @@ cos :: (t: f32) -> f32 {
 }
 
 asin :: (t: f32) -> f32 {
-    assert(false, "asin is not implemented yet!");
+    panic("asin is not implemented yet!");
     return 0;
 }
 
 acos :: (t: f32) -> f32 {
-    assert(false, "acos is not implemented yet!");
+    panic("acos is not implemented yet!");
     return 0;
 }
 
 atan :: (t: f32) -> f32 {
-    assert(false, "atan is not implemented yet!");
+    panic("atan is not implemented yet!");
     return 0;
 }
 
 atan2 :: (t: f32) -> f32 {
-    assert(false, "atan2 is not implemented yet!");
+    panic("atan2 is not implemented yet!");
     return 0;
 }
 

diff --git a/core/onyx/cbindgen.onyx b/core/onyx/cbindgen.onyx
@@ -335,7 +335,7 @@ compile_c_file :: (
                             if is_pointer(p) {
                                 string.append(call_signature, "p");
                             } else {
-                                assert(false, tprintf("Unsupported type in function pointer: {}", p));
+                                panic(tprintf("Unsupported type in function pointer: {}", p));
                             }
                         }
                     }
@@ -373,7 +373,7 @@ compile_c_file :: (
         if last_arg_is_return_value {
             return_type := slice.get(method_info.parameter_types, -1);
             if return_type->info().kind != .Pointer {
-                assert(false, tprintf("last_arg_is_return_value requires last parameter to be a pointer. ({} in {})", method_info.parameter_types, method_name));
+                panic(tprintf("last_arg_is_return_value requires last parameter to be a pointer. ({} in {})", method_info.parameter_types, method_name));
             }
 
             return_type = return_type->info()->as_pointer().to;
@@ -432,8 +432,8 @@ compile_c_file :: (
             case .Multi_Pointer do return "ptr"; 
             case .Array do return "ptr";
 
-            case .Function do return "i32"; // assert(false, "Passing functions between wasm and c is not yet supported.");
-            case .Slice do assert(false, "Passing a slice from c to wasm is not yet supported.");
+            case .Function do return "i32"; // panic("Passing functions between wasm and c is not yet supported.");
+            case .Slice do panic("Passing a slice from c to wasm is not yet supported.");
             case .Enum do return type_to_wasm_type((cast(&Type_Info_Enum) param_info).backing_type);
             case .Distinct do return type_to_wasm_type((cast(&Type_Info_Distinct) param_info).base_type);
 
@@ -448,11 +448,11 @@ compile_c_file :: (
                     return type_to_wasm_type(s_info.members[0].type);
                 }
 
-                assert(false, "Passing structures between wasm and c is not yet supported.");
+                panic("Passing structures between wasm and c is not yet supported.");
             }
 
             case .Union {
-                assert(false, "Passing unions between wasm and c is not yet supported.");
+                panic("Passing unions between wasm and c is not yet supported.");
             }
         }
 
@@ -487,7 +487,7 @@ compile_c_file :: (
 
             case .Pointer do return "WASM_I32"; // This will also have to depend on the pointer size...
             case .Multi_Pointer do return "WASM_I32"; // This will also have to depend on the pointer size...
-            case .Function do return "WASM_I32, WASM_I32, WASM_I32"; // assert(false, "Passing functions between wasm and c is not yet supported.");
+            case .Function do return "WASM_I32, WASM_I32, WASM_I32"; // panic("Passing functions between wasm and c is not yet supported.");
             case .Array do return "WASM_I32";
             case .Slice do return "WASM_I32,WASM_I32";
             case .Enum do return type_encoding((cast(&Type_Info_Enum) param_info).backing_type);
@@ -499,7 +499,7 @@ compile_c_file :: (
                     return type_encoding(s_info.members[0].type);
                 }
 
-                // assert(false, "Passing structures between wasm and c is not yet supported.");
+                // panic("Passing structures between wasm and c is not yet supported.");
                 return "WASM_I32";
             }
         }

diff --git a/core/os/tty.onyx b/core/os/tty.onyx
@@ -42,11 +42,11 @@ tty_set :: (state: &TTY_State) -> bool {
 } else {
 
 tty_get :: () -> TTY_State {
-    assert(false, "core.os.tty_get not supported on this platform.");
+    panic("core.os.tty_get not supported on this platform.");
 }
 
 tty_set :: (state: &TTY_State) -> bool {
-    assert(false, "core.os.tty_get not supported on this platform.");
+    panic("core.os.tty_get not supported on this platform.");
     return false;
 }