Remove SXBP_DEBUG macro

Fixes #116

Author: saxbophone

saxbospiral/initialise.c

@@ -74,8 +74,7 @@ sxbp_status_t sxbp_init_spiral(sxbp_buffer_t buffer, sxbp_spiral_t* spiral) {
     spiral->lines = calloc(sizeof(sxbp_line_t), line_count);
     // check for memory allocation failure
     if(spiral->lines == NULL) {
-        result.location = SXBP_DEBUG;
-        result.diagnostic = SXBP_MALLOC_REFUSED;
+        result = SXBP_MALLOC_REFUSED;
         return result;
     }
     // First line is always an UP line - this is for orientation purposes
@@ -105,7 +104,7 @@ sxbp_status_t sxbp_init_spiral(sxbp_buffer_t buffer, sxbp_spiral_t* spiral) {
         }
     }
     // all ok
-    result.diagnostic = SXBP_OPERATION_OK;
+    result = SXBP_OPERATION_OK;
     return result;
 }
 

saxbospiral/plot.c

@@ -76,16 +76,15 @@ sxbp_status_t sxbp_spiral_points(
     assert(end <= spiral.size);
     assert(spiral.lines != NULL);
     // prepare result status
-    sxbp_status_t result = {{0, 0, 0}, 0};
+    sxbp_status_t result;
     // the amount of space needed is the sum of all line lengths + 1 for end
     size_t size = sxbp_sum_lines(spiral, start, end) + 1;
     // allocate memory
     output->items = calloc(sizeof(sxbp_co_ord_t), size);
     // catch malloc error
     if(output->items == NULL) {
         // set error information then early return
-        result.location = SXBP_DEBUG;
-        result.diagnostic = SXBP_MALLOC_REFUSED;
+        result = SXBP_MALLOC_REFUSED;
         return result;
     }
     output->size = size;
@@ -107,7 +106,7 @@ sxbp_status_t sxbp_spiral_points(
         }
     }
     // all good
-    result.diagnostic = SXBP_OPERATION_OK;
+    result = SXBP_OPERATION_OK;
     return result;
 }
 
@@ -129,7 +128,7 @@ sxbp_status_t sxbp_cache_spiral_points(sxbp_spiral_t* spiral, size_t limit) {
     assert(spiral->lines != NULL);
     assert(limit <= spiral->size);
     // prepare result status
-    sxbp_status_t result = {{0, 0, 0}, 0};
+    sxbp_status_t result;
     // the amount of space needed is the sum of all line lengths + 1 for end
     size_t size = sxbp_sum_lines(*spiral, 0, limit) + 1;
     // allocate / reallocate memory
@@ -150,8 +149,7 @@ sxbp_status_t sxbp_cache_spiral_points(sxbp_spiral_t* spiral, size_t limit) {
     // catch malloc failure
     if(spiral->co_ord_cache.co_ords.items == NULL) {
         // set error information then early return
-        result.location = SXBP_DEBUG;
-        result.diagnostic = SXBP_MALLOC_REFUSED;
+        result = SXBP_MALLOC_REFUSED;
         return result;
     }
     spiral->co_ord_cache.co_ords.size = size;
@@ -180,7 +178,7 @@ sxbp_status_t sxbp_cache_spiral_points(sxbp_spiral_t* spiral, size_t limit) {
         *spiral, &missing, current, smallest, limit
     );
     // return errors from previous call if needed
-    if(calculate_result.diagnostic != SXBP_OPERATION_OK) {
+    if(calculate_result != SXBP_OPERATION_OK) {
         return calculate_result;
     }
     // add the missing co-ords to the cache
@@ -196,7 +194,7 @@ sxbp_status_t sxbp_cache_spiral_points(sxbp_spiral_t* spiral, size_t limit) {
         limit > spiral->co_ord_cache.validity
     ) ? limit : spiral->co_ord_cache.validity;
     // return ok
-    result.diagnostic = SXBP_OPERATION_OK;
+    result = SXBP_OPERATION_OK;
     return result;
 }
 

saxbospiral/render.c

@@ -86,7 +86,7 @@ sxbp_status_t sxbp_render_spiral(sxbp_spiral_t spiral, sxbp_bitmap_t* image) {
     assert(image->pixels == NULL);
     assert(spiral.lines != NULL);
     // create result status struct
-    sxbp_status_t result = {{0, 0, 0}, 0};
+    sxbp_status_t result;
     // plot co-ords of spiral into it's cache
     sxbp_cache_spiral_points(&spiral, spiral.size);
     // get the min and max bounds of the spiral's co-ords
@@ -109,8 +109,7 @@ sxbp_status_t sxbp_render_spiral(sxbp_spiral_t spiral, sxbp_bitmap_t* image) {
     image->pixels = malloc(image->width * sizeof(bool*));
     // check for malloc fail
     if(image->pixels == NULL) {
-        result.location = SXBP_DEBUG;
-        result.diagnostic = SXBP_MALLOC_REFUSED;
+        result = SXBP_MALLOC_REFUSED;
         return result;
     }
     for(size_t i = 0; i < image->width; i++) {
@@ -123,8 +122,7 @@ sxbp_status_t sxbp_render_spiral(sxbp_spiral_t spiral, sxbp_bitmap_t* image) {
             }
             // now we need to free() the top-level array
             free(image->pixels);
-            result.location = SXBP_DEBUG;
-            result.diagnostic = SXBP_MALLOC_REFUSED;
+            result = SXBP_MALLOC_REFUSED;
             return result;
         }
     }
@@ -155,7 +153,7 @@ sxbp_status_t sxbp_render_spiral(sxbp_spiral_t spiral, sxbp_bitmap_t* image) {
         }
     }
     // status ok
-    result.diagnostic = SXBP_OPERATION_OK;
+    result = SXBP_OPERATION_OK;
     return result;
 }
 

saxbospiral/render_backends/png_backend.c

@@ -99,8 +99,7 @@ sxbp_status_t sxbp_write_png_image(
     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
     // catch malloc fail
     if(png_ptr == NULL) {
-        result.location = SXBP_DEBUG;
-        result.diagnostic = SXBP_MALLOC_REFUSED;
+        result = SXBP_MALLOC_REFUSED;
         // cleanup
         cleanup_png_lib(png_ptr, info_ptr, row);
         return result;
@@ -109,8 +108,7 @@ sxbp_status_t sxbp_write_png_image(
     info_ptr = png_create_info_struct(png_ptr);
     // catch malloc fail
     if(info_ptr == NULL) {
-        result.location = SXBP_DEBUG;
-        result.diagnostic = SXBP_MALLOC_REFUSED;
+        result = SXBP_MALLOC_REFUSED;
         // cleanup
         cleanup_png_lib(png_ptr, info_ptr, row);
         return result;
@@ -159,8 +157,7 @@ sxbp_status_t sxbp_write_png_image(
     row = (png_bytep) malloc(bitmap.width * sizeof(png_byte));
     // catch malloc fail
     if(row == NULL) {
-        result.location = SXBP_DEBUG;
-        result.diagnostic = SXBP_MALLOC_REFUSED;
+        result = SXBP_MALLOC_REFUSED;
         // cleanup
         cleanup_png_lib(png_ptr, info_ptr, row);
         return result;
@@ -178,7 +175,7 @@ sxbp_status_t sxbp_write_png_image(
     // cleanup
     cleanup_png_lib(png_ptr, info_ptr, row);
     // status ok
-    result.diagnostic = SXBP_OPERATION_OK;
+    result = SXBP_OPERATION_OK;
     return result;
 }
 

saxbospiral/saxbospiral.h

@@ -51,32 +51,13 @@ typedef uint32_t sxbp_version_hash_t;
  */
 sxbp_version_hash_t sxbp_version_hash(sxbp_version_t version);
 
-// struct for storing the location of a DEBUG invocation
-typedef struct sxbp_debug_t {
-    size_t line;
-    char* file;
-    const char* function;
-} sxbp_debug_t;
-
-/*
- * handy short-hand for debugging purposes
- * usage: debug_t debug = DEBUG;
- */
-#define SXBP_DEBUG (sxbp_debug_t) { .line = __LINE__, .file = __FILE__, .function = __func__, }
-
 // enum for function error information
-typedef enum sxbp_diagnostic_t {
+typedef enum sxbp_status_t {
     SXBP_STATE_UNKNOWN = 0, // unknown, the default state
     SXBP_OPERATION_FAIL, // generic failure state
     SXBP_MALLOC_REFUSED, // memory allocation or re-allocation was refused
     SXBP_IMPOSSIBLE_CONDITION, // condition thought to be impossible detected
     SXBP_OPERATION_OK, // no problem
-} sxbp_diagnostic_t;
-
-// struct for storing generic diagnostics about function failure reasons
-typedef struct sxbp_status_t {
-    sxbp_debug_t location; // for storing location of error
-    sxbp_diagnostic_t diagnostic; // for storing error information (if any)
 } sxbp_status_t;
 
 // type for representing a cartesian direction

saxbospiral/serialise.c

@@ -129,15 +129,13 @@ sxbp_serialise_result_t sxbp_load_spiral(
     sxbp_serialise_result_t result; // build struct for returning success / failure
     // first, if header is too small for header + 1 line, then return early
     if(buffer.size < SXBP_FILE_HEADER_SIZE + SXBP_LINE_T_PACK_SIZE) {
-        result.status.location = SXBP_DEBUG; // catch location of error
-        result.status.diagnostic = SXBP_OPERATION_FAIL; // flag failure
+        result.status = SXBP_OPERATION_FAIL; // flag failure
         result.diagnostic = SXBP_DESERIALISE_BAD_HEADER_SIZE; // failure reason
         return result;
     }
     // check for magic number and return early if not right
     if(strncmp((char*)buffer.bytes, "SAXBOSPIRAL", 11) != 0) {
-        result.status.location = SXBP_DEBUG; // catch location of error
-        result.status.diagnostic = SXBP_OPERATION_FAIL; // flag failure
+        result.status = SXBP_OPERATION_FAIL; // flag failure
         result.diagnostic = SXBP_DESERIALISE_BAD_MAGIC_NUMBER; // failure reason
         return result;
     }
@@ -152,8 +150,7 @@ sxbp_serialise_result_t sxbp_load_spiral(
     // check for version compatibility
     if(sxbp_version_hash(buffer_version) < sxbp_version_hash(min_version)) {
         // check failed
-        result.status.location = SXBP_DEBUG; // catch location of error
-        result.status.diagnostic = SXBP_OPERATION_FAIL; // flag failure
+        result.status = SXBP_OPERATION_FAIL; // flag failure
         result.diagnostic = SXBP_DESERIALISE_BAD_VERSION; // failure reason
         return result;
     }
@@ -162,8 +159,7 @@ sxbp_serialise_result_t sxbp_load_spiral(
     // Check that the file data section is large enough for the spiral size
     if((buffer.size - SXBP_FILE_HEADER_SIZE) != (SXBP_LINE_T_PACK_SIZE * spiral_size)) {
         // this check failed
-        result.status.location = SXBP_DEBUG; // catch location of error
-        result.status.diagnostic = SXBP_OPERATION_FAIL; // flag failure
+        result.status = SXBP_OPERATION_FAIL; // flag failure
         result.diagnostic = SXBP_DESERIALISE_BAD_DATA_SIZE; // failure reason
         return result;
     }
@@ -176,8 +172,7 @@ sxbp_serialise_result_t sxbp_load_spiral(
     spiral->lines = calloc(sizeof(sxbp_line_t), spiral->size);
     // catch allocation error
     if(spiral->lines == NULL) {
-        result.status.location = SXBP_DEBUG; // catch location of error
-        result.status.diagnostic = SXBP_MALLOC_REFUSED; // flag failure
+        result.status = SXBP_MALLOC_REFUSED; // flag failure
         return result;
     }
     // convert each serialised line segment in buffer into a line_t struct
@@ -203,7 +198,7 @@ sxbp_serialise_result_t sxbp_load_spiral(
         }
     }
     // return ok status
-    result.status.diagnostic = SXBP_OPERATION_OK;
+    result.status = SXBP_OPERATION_OK;
     return result;
 }
 
@@ -231,8 +226,7 @@ sxbp_serialise_result_t sxbp_dump_spiral(
     buffer->bytes = calloc(1, buffer->size);
     // catch memory allocation failure
     if(buffer->bytes == NULL) {
-        result.status.location = SXBP_DEBUG;
-        result.status.diagnostic = SXBP_MALLOC_REFUSED;
+        result.status = SXBP_MALLOC_REFUSED;
         return result;
     }
     // write first part of data header (magic number and version info)
@@ -267,7 +261,7 @@ sxbp_serialise_result_t sxbp_dump_spiral(
         }
     }
     // return ok status
-    result.status.diagnostic = SXBP_OPERATION_OK;
+    result.status = SXBP_OPERATION_OK;
     return result;
 }
 

saxbospiral/solve.c

@@ -230,7 +230,7 @@ sxbp_status_t sxbp_resize_spiral(
      * state of which line is being resized, and what size it should be.
      */
     // set result status
-    sxbp_status_t result = {{0, 0, 0}, 0};
+    sxbp_status_t result;
     size_t current_index = index;
     sxbp_length_t current_length = length;
     while(true) {
@@ -246,7 +246,7 @@ sxbp_status_t sxbp_resize_spiral(
         // update the spiral's co-ord cache, and catch any errors
         result = sxbp_cache_spiral_points(spiral, current_index + 1);
         // return if errors
-        if(result.diagnostic != SXBP_OPERATION_OK) {
+        if(result != SXBP_OPERATION_OK) {
             return result;
         }
         spiral->collides = spiral_collides(spiral, current_index);
@@ -275,7 +275,7 @@ sxbp_status_t sxbp_resize_spiral(
              * Return OPERATION_OK from function.
              */
             spiral->solved_count = index + 1;
-            result.diagnostic = SXBP_OPERATION_OK;
+            result = SXBP_OPERATION_OK;
             return result;
         }
     }
@@ -314,14 +314,14 @@ sxbp_status_t sxbp_plot_spiral(
     // preconditional assertions
     assert(spiral->lines != NULL);
     // set up result status
-    sxbp_status_t result = {{0, 0, 0}, 0};
+    sxbp_status_t result;
     // get index of highest line to plot
     uint64_t max_index = (max_line > spiral->size) ? spiral->size : max_line;
     // calculate the length of each line within range solved_count -> max_index
     for(size_t i = spiral->solved_count; i < max_index; i++) {
         result = sxbp_resize_spiral(spiral, i, 1, perfection_threshold);
         // catch and return error if any
-        if(result.diagnostic != SXBP_OPERATION_OK) {
+        if(result != SXBP_OPERATION_OK) {
             return result;
         }
         // call callback if given
@@ -330,7 +330,7 @@ sxbp_status_t sxbp_plot_spiral(
         }
     }
     // all ok
-    result.diagnostic = SXBP_OPERATION_OK;
+    result = SXBP_OPERATION_OK;
     return result;
 }
 

tests.c

@@ -447,7 +447,7 @@ bool test_sxbp_load_spiral_rejects_missing_magic_number() {
     sxbp_serialise_result_t serialise_result = sxbp_load_spiral(buffer, &output);
 
     if(
-        (serialise_result.status.diagnostic != SXBP_OPERATION_FAIL) ||
+        (serialise_result.status != SXBP_OPERATION_FAIL) ||
         (serialise_result.diagnostic != SXBP_DESERIALISE_BAD_MAGIC_NUMBER)
     ) {
         result = false;
@@ -470,7 +470,7 @@ bool test_sxbp_load_spiral_rejects_too_small_for_header() {
     sxbp_serialise_result_t serialise_result = sxbp_load_spiral(buffer, &output);
 
     if(
-        (serialise_result.status.diagnostic != SXBP_OPERATION_FAIL) ||
+        (serialise_result.status != SXBP_OPERATION_FAIL) ||
         (serialise_result.diagnostic != SXBP_DESERIALISE_BAD_HEADER_SIZE)
     ) {
         result = false;
@@ -510,7 +510,7 @@ bool test_sxbp_load_spiral_rejects_too_small_data_section() {
     sxbp_serialise_result_t serialise_result = sxbp_load_spiral(buffer, &output);
 
     if(
-        (serialise_result.status.diagnostic != SXBP_OPERATION_FAIL) ||
+        (serialise_result.status != SXBP_OPERATION_FAIL) ||
         (serialise_result.diagnostic != SXBP_DESERIALISE_BAD_DATA_SIZE)
     ) {
         result = false;
@@ -550,7 +550,7 @@ bool test_sxbp_load_spiral_rejects_wrong_version() {
     sxbp_serialise_result_t serialise_result = sxbp_load_spiral(buffer, &output);
 
     if(
-        (serialise_result.status.diagnostic != SXBP_OPERATION_FAIL) ||
+        (serialise_result.status != SXBP_OPERATION_FAIL) ||
         (serialise_result.diagnostic != SXBP_DESERIALISE_BAD_VERSION)
     ) {
         result = false;