Replace assert with bsp_error_t for bsp_array_t.

Author: BenBrock

examples/simple_read.c

@@ -19,7 +19,7 @@ int main(int argc, char** argv) {
     printf("%lu: %d\n", i, values[i]);
   }
 
-  bsp_destroy_array_t(array);
+  bsp_destroy_array_t(&array);
   H5Fclose(f);
 
   return 0;

examples/simple_write.c

@@ -11,7 +11,13 @@ int main(int argc, char** argv) {
 
   hid_t f = H5Fcreate(file_name, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
-  bsp_array_t array = bsp_construct_array_t(1000, BSP_INT32);
+  bsp_array_t array;
+  bsp_error_t error = bsp_construct_array_t(&array, 1000, BSP_INT32);
+  if (error != BSP_SUCCESS) {
+    printf("Error: Failed to allocate array\n");
+    H5Fclose(f);
+    return 1;
+  }
 
   int* values = (int*) array.data;
 
@@ -22,7 +28,7 @@ int main(int argc, char** argv) {
   bsp_write_array(f, "test", array, 0);
 
   H5Fclose(f);
-  bsp_destroy_array_t(array);
+  bsp_destroy_array_t(&array);
 
   return 0;
 }

include/binsparse/array.h

@@ -6,9 +6,9 @@
 
 #pragma once
 
-#include <assert.h>
 #include <binsparse/detail/allocator.h>
 #include <binsparse/detail/shm_tools.h>
+#include <binsparse/error.h>
 #include <binsparse/types.h>
 #include <stdlib.h>
 #include <string.h>
@@ -28,63 +28,70 @@ static inline bsp_array_t bsp_construct_default_array_t() {
   return array;
 }
 
-static inline bsp_array_t bsp_construct_array_t(size_t size, bsp_type_t type) {
+static inline bsp_error_t bsp_construct_array_t(bsp_array_t* array, size_t size,
+                                                bsp_type_t type) {
   size_t byte_size = size * bsp_type_size(type);
 
-  bsp_array_t array;
-  array.allocator = bsp_default_allocator;
-  array.data = array.allocator.malloc(byte_size);
-  assert(array.data != NULL);
-  array.size = size;
-  array.type = type;
+  array->allocator = bsp_default_allocator;
+  array->data = array->allocator.malloc(byte_size);
 
-  return array;
+  if (array->data == NULL) {
+    return BSP_ERROR_MEMORY;
+  }
+
+  array->size = size;
+  array->type = type;
+
+  return BSP_SUCCESS;
 }
 
-static inline bsp_array_t bsp_copy_construct_array_t(bsp_array_t other) {
-  bsp_array_t array = bsp_construct_array_t(other.size, other.type);
-  memcpy(array.data, other.data, other.size * bsp_type_size(other.type));
+static inline bsp_error_t bsp_copy_construct_array_t(bsp_array_t* array,
+                                                     bsp_array_t other) {
+  bsp_error_t error = bsp_construct_array_t(array, other.size, other.type);
+  if (error != BSP_SUCCESS) {
+    return error;
+  }
+
+  memcpy(array->data, other.data, other.size * bsp_type_size(other.type));
 
-  return array;
+  return BSP_SUCCESS;
 }
 
-static inline bsp_array_t bsp_complex_array_to_fp(bsp_array_t other) {
-  assert(other.type == BSP_COMPLEX_FLOAT32 ||
-         other.type == BSP_COMPLEX_FLOAT64);
+static inline bsp_error_t bsp_complex_array_to_fp(bsp_array_t* array) {
+  if (array->type != BSP_COMPLEX_FLOAT32 &&
+      array->type != BSP_COMPLEX_FLOAT64) {
+    return BSP_ERROR_TYPE;
+  }
 
-  bsp_array_t array;
-  array.data = other.data;
-  array.size = other.size * 2;
-  array.allocator = other.allocator;
+  array->size = array->size * 2;
 
-  if (other.type == BSP_COMPLEX_FLOAT32) {
-    array.type = BSP_FLOAT32;
+  if (array->type == BSP_COMPLEX_FLOAT32) {
+    array->type = BSP_FLOAT32;
   } else {
-    array.type = BSP_FLOAT64;
+    array->type = BSP_FLOAT64;
   }
 
-  return array;
+  return BSP_SUCCESS;
 }
 
-static inline bsp_array_t bsp_fp_array_to_complex(bsp_array_t other) {
-  assert(other.type == BSP_FLOAT32 || other.type == BSP_FLOAT64);
-
-  bsp_array_t array;
-  array.data = other.data;
-  array.size = other.size / 2;
-  array.allocator = other.allocator;
+static inline bsp_error_t bsp_fp_array_to_complex(bsp_array_t* array) {
+  if (array->type != BSP_FLOAT32 && array->type != BSP_FLOAT64) {
+    return BSP_ERROR_TYPE;
+  }
 
-  if (other.type == BSP_FLOAT32) {
-    array.type = BSP_COMPLEX_FLOAT32;
+  if (array->type == BSP_FLOAT32) {
+    array->type = BSP_COMPLEX_FLOAT32;
   } else {
-    array.type = BSP_COMPLEX_FLOAT64;
+    array->type = BSP_COMPLEX_FLOAT64;
   }
 
-  return array;
+  array->size = array->size / 2;
+
+  return BSP_SUCCESS;
 }
 
-static inline void bsp_destroy_array_t(bsp_array_t array) {
-  array.allocator.free(array.data);
+static inline void bsp_destroy_array_t(bsp_array_t* array) {
+  array->allocator.free(array->data);
 }
 
 static inline bool bsp_array_equal(bsp_array_t x, bsp_array_t y) {

include/binsparse/binsparse.h

@@ -11,6 +11,7 @@
 #include <binsparse/array.h>
 #include <binsparse/convert_matrix.h>
 #include <binsparse/detail/detail.h>
+#include <binsparse/error.h>
 #include <binsparse/generate.h>
 #include <binsparse/hdf5_wrapper.h>
 #include <binsparse/matrix.h>

include/binsparse/convert_matrix.h

@@ -37,25 +37,43 @@ static inline bsp_matrix_t bsp_convert_matrix(bsp_matrix_t matrix,
 
       bsp_type_t index_type = bsp_pick_integer_type(max_dim);
 
-      result.values = bsp_copy_construct_array_t(matrix.values);
+      bsp_error_t error =
+          bsp_copy_construct_array_t(&result.values, matrix.values);
+      if (error != BSP_SUCCESS) {
+        return bsp_construct_default_matrix_t();
+      }
 
       // There is a corner case with tall and skinny matrices where we need a
       // higher width for rowind.  In order to keep rowind/colind the same type,
       // we might upcast.
 
       if (index_type == matrix.indices_1.type) {
-        result.indices_1 = bsp_copy_construct_array_t(matrix.indices_1);
+        error = bsp_copy_construct_array_t(&result.indices_1, matrix.indices_1);
+        if (error != BSP_SUCCESS) {
+          bsp_destroy_array_t(&result.values);
+          return bsp_construct_default_matrix_t();
+        }
       } else {
-        result.indices_1 =
-            bsp_construct_array_t(matrix.indices_1.size, index_type);
+        error = bsp_construct_array_t(&result.indices_1, matrix.indices_1.size,
+                                      index_type);
+        if (error != BSP_SUCCESS) {
+          bsp_destroy_array_t(&result.values);
+          return bsp_construct_default_matrix_t();
+        }
+
         for (size_t i = 0; i < matrix.indices_1.size; i++) {
           size_t index;
           bsp_array_read(matrix.indices_1, i, index);
           bsp_array_write(result.indices_1, i, index);
         }
       }
 
-      result.indices_0 = bsp_construct_array_t(matrix.nnz, index_type);
+      error = bsp_construct_array_t(&result.indices_0, matrix.nnz, index_type);
+      if (error != BSP_SUCCESS) {
+        bsp_destroy_array_t(&result.values);
+        bsp_destroy_array_t(&result.indices_1);
+        return bsp_construct_default_matrix_t();
+      }
 
       for (size_t i = 0; i < matrix.nrows; i++) {
         size_t row_begin, row_end;
@@ -109,12 +127,26 @@ static inline bsp_matrix_t bsp_convert_matrix(bsp_matrix_t matrix,
         // indices can be copied exactly.  Values' type will not change, but
         // column indices might, thus the extra branch.
 
-        result.values = bsp_copy_construct_array_t(matrix.values);
+        bsp_error_t error =
+            bsp_copy_construct_array_t(&result.values, matrix.values);
+        if (error != BSP_SUCCESS) {
+          return bsp_construct_default_matrix_t();
+        }
 
         if (index_type == matrix.indices_1.type) {
-          result.indices_1 = bsp_copy_construct_array_t(matrix.indices_1);
+          error =
+              bsp_copy_construct_array_t(&result.indices_1, matrix.indices_1);
+          if (error != BSP_SUCCESS) {
+            bsp_destroy_array_t(&result.values);
+            return bsp_construct_default_matrix_t();
+          }
         } else {
-          result.indices_1 = bsp_construct_array_t(matrix.nnz, index_type);
+          error =
+              bsp_construct_array_t(&result.indices_1, matrix.nnz, index_type);
+          if (error != BSP_SUCCESS) {
+            bsp_destroy_array_t(&result.values);
+            return bsp_construct_default_matrix_t();
+          }
 
           for (size_t i = 0; i < matrix.nnz; i++) {
             size_t index;
@@ -123,8 +155,13 @@ static inline bsp_matrix_t bsp_convert_matrix(bsp_matrix_t matrix,
           }
         }
 
-        result.pointers_to_1 =
-            bsp_construct_array_t(matrix.nrows + 1, index_type);
+        error = bsp_construct_array_t(&result.pointers_to_1, matrix.nrows + 1,
+                                      index_type);
+        if (error != BSP_SUCCESS) {
+          bsp_destroy_array_t(&result.values);
+          bsp_destroy_array_t(&result.indices_1);
+          return bsp_construct_default_matrix_t();
+        }
 
         bsp_array_t rowptr = result.pointers_to_1;
 

include/binsparse/error.h

@@ -0,0 +1,62 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Binsparse Developers
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#pragma once
+
+typedef enum bsp_error_t {
+  BSP_SUCCESS = 0,
+
+  // Memory-related failures (malloc, array allocation, etc.)
+  BSP_ERROR_MEMORY = 1,
+
+  // File I/O failures (file not found, read/write errors, HDF5 operations)
+  BSP_ERROR_IO = 2,
+
+  // JSON parsing and metadata errors
+  BSP_ERROR_FORMAT = 3,
+
+  // Invalid input parameters, dimensions, types, etc.
+  BSP_ERROR_INVALID_INPUT = 4,
+
+  // Unsupported operations or not-yet-implemented features
+  BSP_ERROR_UNSUPPORTED = 5,
+
+  // Type-related errors (invalid types, type mismatches)
+  BSP_ERROR_TYPE = 6,
+
+  // Generic internal errors (should-never-happen cases)
+  BSP_ERROR_INTERNAL = 7
+
+} bsp_error_t;
+
+/**
+ * Get a human-readable error message for a bsp_error_t code.
+ *
+ * @param error The error code
+ * @return A constant string describing the error
+ */
+static inline const char* bsp_get_error_string(bsp_error_t error) {
+  switch (error) {
+  case BSP_SUCCESS:
+    return "Success";
+  case BSP_ERROR_MEMORY:
+    return "Memory allocation or management error";
+  case BSP_ERROR_IO:
+    return "File I/O or HDF5 operation error";
+  case BSP_ERROR_FORMAT:
+    return "JSON parsing or metadata format error";
+  case BSP_ERROR_INVALID_INPUT:
+    return "Invalid input parameters or data";
+  case BSP_ERROR_UNSUPPORTED:
+    return "Unsupported operation or feature";
+  case BSP_ERROR_TYPE:
+    return "Data type error or type mismatch";
+  case BSP_ERROR_INTERNAL:
+    return "Internal library error";
+  default:
+    return "Unknown error";
+  }
+}

include/binsparse/generate.h

@@ -74,9 +74,27 @@ static inline bsp_matrix_t bsp_generate_coo(size_t m, size_t n, size_t nnz,
   matrix.nrows = m;
   matrix.ncols = n;
   matrix.nnz = nnz;
-  matrix.values = bsp_construct_array_t(nnz, value_type);
-  matrix.indices_0 = bsp_construct_array_t(nnz, index_type);
-  matrix.indices_1 = bsp_construct_array_t(nnz, index_type);
+
+  bsp_error_t error;
+  error = bsp_construct_array_t(&matrix.values, nnz, value_type);
+  if (error != BSP_SUCCESS) {
+    // Return empty matrix on error
+    return matrix;
+  }
+
+  error = bsp_construct_array_t(&matrix.indices_0, nnz, index_type);
+  if (error != BSP_SUCCESS) {
+    bsp_destroy_array_t(&matrix.values);
+    return matrix;
+  }
+
+  error = bsp_construct_array_t(&matrix.indices_1, nnz, index_type);
+  if (error != BSP_SUCCESS) {
+    bsp_destroy_array_t(&matrix.values);
+    bsp_destroy_array_t(&matrix.indices_0);
+    return matrix;
+  }
+
   matrix.format = BSP_COO;
 
   bsp_array_fill_random(matrix.values, 100);

include/binsparse/hdf5_wrapper.h

@@ -24,7 +24,10 @@
 static inline int bsp_write_array(hid_t f, const char* label, bsp_array_t array,
                                   int compression_level) {
   if (array.type == BSP_COMPLEX_FLOAT32 || array.type == BSP_COMPLEX_FLOAT64) {
-    array = bsp_complex_array_to_fp(array);
+    bsp_error_t error = bsp_complex_array_to_fp(&array);
+    if (error != BSP_SUCCESS) {
+      return -3; // Type conversion error
+    }
   }
 
   hsize_t hsize[1];
@@ -198,12 +201,21 @@ static inline bsp_array_t bsp_read_array(hid_t f, const char* label) {
 
   bsp_type_t type = bsp_get_bsp_type(hdf5_type);
 
-  bsp_array_t array = bsp_construct_array_t(dims[0], type);
+  bsp_array_t array = bsp_construct_default_array_t();
+  bsp_error_t error = bsp_construct_array_t(&array, dims[0], type);
+  if (error != BSP_SUCCESS) {
+    H5Dclose(dset);
+    H5Sclose(fspace);
+    return bsp_construct_default_array_t();
+  }
 
   herr_t status = H5Dread(dset, bsp_get_hdf5_native_type(type), H5S_ALL,
                           H5S_ALL, H5P_DEFAULT, array.data);
 
   if (status < 0) {
+    bsp_destroy_array_t(&array);
+    H5Dclose(dset);
+    H5Sclose(fspace);
     return bsp_construct_default_array_t();
   }
 

include/binsparse/matrix.h

@@ -39,10 +39,10 @@ static inline bsp_matrix_t bsp_construct_default_matrix_t() {
 }
 
 static inline void bsp_destroy_matrix_t(bsp_matrix_t matrix) {
-  bsp_destroy_array_t(matrix.values);
-  bsp_destroy_array_t(matrix.indices_0);
-  bsp_destroy_array_t(matrix.indices_1);
-  bsp_destroy_array_t(matrix.pointers_to_1);
+  bsp_destroy_array_t(&matrix.values);
+  bsp_destroy_array_t(&matrix.indices_0);
+  bsp_destroy_array_t(&matrix.indices_1);
+  bsp_destroy_array_t(&matrix.pointers_to_1);
 }
 
 static inline size_t bsp_matrix_nbytes(bsp_matrix_t mat) {