Merge pull request #53 from saxbophone/develop

v0.12.0

Author: saxbophone

CMakeLists.txt

@@ -2,7 +2,7 @@
 cmake_minimum_required(VERSION 3.0)
 enable_language(C CXX)
 
-project(saxbospiral VERSION 0.11.3 LANGUAGES C)
+project(saxbospiral VERSION 0.12.0 LANGUAGES C)
 set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(

build_logo.sh

@@ -8,6 +8,4 @@
 # 
 echo "Generating logo";
 echo -n "$3" > temp.hex && \
-./"$1" -pg -i temp.hex -o temp.sxp && \
-./"$1" -r -i temp.sxp -o "$2"
-rm temp.hex temp.sxp;
+./"$1" -pgr -i temp.hex -o "$2";

saxbospiral.png

@@ -1,6 +1,7 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+#include "saxbospiral.h"
 #include "initialise.h"
 
 
@@ -18,25 +19,33 @@ change_direction(direction_t current, rotation_t turn) {
 }
 
 /*
- * initialises a spiral_t struct from an array pointer to unsigned bytes
+ * given a buffer_t full of data, and a pointer to a blank spiral_t
+ * struct, populates the spiral struct from the data in the buffer
  * this converts the 0s and 1s in the data into UP, LEFT, DOWN, RIGHT
  * instructions which are then used to build the pattern.
+ * returns a status_t struct with error information (if needed)
  */
-spiral_t
-init_spiral(buffer_t buffer) {
+status_t
+init_spiral(buffer_t buffer, spiral_t * spiral) {
+    // result status object
+    status_t result;
     // number of lines is number of bits of the data, + 1 for the first UP line
     size_t line_count = (buffer.size * 8) + 1;
-    // create spiral_t struct
-    spiral_t result = {
-        .size = line_count,
-        .collides = -1,
-        // allocate enough memory for a line_t struct for each bit
-        .lines = calloc(sizeof(line_t), line_count),
-    };
+    // populate spiral struct
+    spiral->size = line_count;
+    spiral->collides = -1;
+    // allocate enough memory for a line_t struct for each bit
+    spiral->lines = calloc(sizeof(line_t), line_count);
+    // check for memory allocation failure
+    if(spiral->lines == NULL) {
+        result.location = DEBUG;
+        result.diagnostic = MALLOC_REFUSED;
+        return result;
+    }
     // First line is always an UP line - this is for orientation purposes
     direction_t current = UP;
-    result.lines[0].direction = current;
-    result.lines[0].length = 0;
+    spiral->lines[0].direction = current;
+    spiral->lines[0].length = 0;
     /*
      * now, iterate over all the bits in the data and convert to directions
      * that make the spiral pattern, storing these directions in the result lines
@@ -54,11 +63,13 @@ init_spiral(buffer_t buffer) {
             // calculate the change of direction
             current = change_direction(current, rotation);
             // store direction in result struct
-            result.lines[index].direction = current;
+            spiral->lines[index].direction = current;
             // set length to 0 initially
-            result.lines[index].length = 0;
+            spiral->lines[index].length = 0;
         }
     }
+    // all ok
+    result.diagnostic = OPERATION_OK;
     return result;
 }
 

saxbospiral/initialise.c

@@ -16,12 +16,14 @@ direction_t
 change_direction(direction_t current, rotation_t turn);
 
 /*
- * initialises a spiral_t struct from an array pointer to unsigned bytes
+ * given a buffer_t full of data, and a pointer to a blank spiral_t
+ * struct, populates the spiral struct from the data in the buffer
  * this converts the 0s and 1s in the data into UP, LEFT, DOWN, RIGHT
  * instructions which are then used to build the pattern.
+ * returns a status_t struct with error information (if needed)
  */
-spiral_t
-init_spiral(buffer_t buffer);
+status_t
+init_spiral(buffer_t buffer, spiral_t * spiral);
 
 #ifdef __cplusplus
 } // extern "C"

saxbospiral/initialise.h

@@ -20,28 +20,39 @@ sum_lines(spiral_t spiral, size_t start, size_t end) {
 }
 
 /*
- * given a spiral_t struct, a pair of co-ords specifying the start point and
- * indexes of the lowest and highest line segments to use, return a
- * co_ord_array_t struct containing all the co-ordinates of the line segments of
- * the struct according to the current directions and lengths of the lines in
- * the spiral.
+ * given a spiral_t struct, a pointer to a co_ord_array_t, a pair of co-ords
+ * specifying the start point and indexes of the lowest and highest line
+ * segments to use, write to the co_ord_array_t struct all the co-ordinates of
+ * the line segments of the struct according to the current directions and
+ * lengths of the lines in the spiral.
  * each line segment is only one unit long, meaning multiple ones are needed for
  * lines longer than one unit.
+ * returns a status struct with error information (if any)
  */
-co_ord_array_t
-spiral_points(spiral_t spiral, co_ord_t start_point, size_t start, size_t end) {
+status_t
+spiral_points(
+    spiral_t spiral, co_ord_array_t * output, co_ord_t start_point,
+    size_t start, size_t end
+) {
+    // prepare result status
+    status_t result = {};
     // the amount of space needed is the sum of all line lengths + 1 for end
     size_t size = sum_lines(spiral, start, end) + 1;
     // allocate memory
-    co_ord_array_t results = {
-        .items = calloc(sizeof(co_ord_t), size),
-        .size = size,
-    };
+    output->items = calloc(sizeof(co_ord_t), size);
+    // catch malloc error
+    if(output->items == NULL) {
+        // set error information then early return
+        result.location = DEBUG;
+        result.diagnostic = MALLOC_REFUSED;
+        return result;
+    }
+    output->size = size;
     // start current co-ordinate at the given start point
     co_ord_t current = start_point;
     // initialise independent result index
     size_t result_index = 0;
-    results.items[result_index] = current;
+    output->items[result_index] = current;
     // calculate all the specified co-ords
     for(size_t i = start; i < end; i++) {
         // get current direction
@@ -50,11 +61,13 @@ spiral_points(spiral_t spiral, co_ord_t start_point, size_t start, size_t end) {
         for(length_t j = 0; j < spiral.lines[i].length; j++) {
             current.x += direction.x;
             current.y += direction.y;
-            results.items[result_index + 1] = current;
+            output->items[result_index + 1] = current;
             result_index++;
         }
     }
-    return results;
+    // all good
+    result.diagnostic = OPERATION_OK;
+    return result;
 }
 
 /*
@@ -64,9 +77,12 @@ spiral_points(spiral_t spiral, co_ord_t start_point, size_t start, size_t end) {
  * each line segment is only one unit long, meaning multiple ones are needed for
  * lines longer than one unit. The co-ords are stored in the spiral's co_ord_cache
  * member and are re-used if they are still valid
+ * returns a status struct with error information (if any)
  */
-void
+status_t
 cache_spiral_points(spiral_t * spiral, size_t limit) {
+    // prepare result status
+    status_t result = {};
     // the amount of space needed is the sum of all line lengths + 1 for end
     size_t size = sum_lines(*spiral, 0, limit) + 1;
     // allocate / reallocate memory
@@ -82,6 +98,13 @@ cache_spiral_points(spiral_t * spiral, size_t limit) {
             spiral->co_ord_cache.co_ords.items, sizeof(co_ord_t) * size
         );
     }
+    // catch malloc failure
+    if(spiral->co_ord_cache.co_ords.items == NULL) {
+        // set error information then early return
+        result.location = DEBUG;
+        result.diagnostic = MALLOC_REFUSED;
+        return result;
+    }
     spiral->co_ord_cache.co_ords.size = size;
     // start at (0, 0) as origin
     co_ord_t current = { 0, 0, };
@@ -103,7 +126,14 @@ cache_spiral_points(spiral_t * spiral, size_t limit) {
         spiral->co_ord_cache.co_ords.items[0] = current;
     }
     // calculate the missing co-ords
-    co_ord_array_t missing = spiral_points(*spiral, current, smallest, limit);
+    co_ord_array_t missing= {};
+    status_t calculate_result = spiral_points(
+        *spiral, &missing, current, smallest, limit
+    );
+    // return errors from previous call if needed
+    if(calculate_result.diagnostic != OPERATION_OK) {
+        return calculate_result;
+    }
     // add the missing co-ords to the cache
     for(size_t i = result_index; i < size; i++) {
         spiral->co_ord_cache.co_ords.items[i] = missing.items[i-result_index];
@@ -116,6 +146,9 @@ cache_spiral_points(spiral_t * spiral, size_t limit) {
     spiral->co_ord_cache.validity = (
         limit > spiral->co_ord_cache.validity
     ) ? limit : spiral->co_ord_cache.validity;
+    // return ok
+    result.diagnostic = OPERATION_OK;
+    return result;
 }
 
 #ifdef __cplusplus

saxbospiral/plot.c

@@ -15,16 +15,20 @@ size_t
 sum_lines(spiral_t spiral, size_t start, size_t end);
 
 /*
- * given a spiral_t struct, a pair of co-ords specifying the start point and
- * indexes of the lowest and highest line segments to use, return a
- * co_ord_array_t struct containing all the co-ordinates of the line segments of
- * the struct according to the current directions and lengths of the lines in
- * the spiral.
+ * given a spiral_t struct, a pointer to a co_ord_array_t, a pair of co-ords
+ * specifying the start point and indexes of the lowest and highest line
+ * segments to use, write to the co_ord_array_t struct all the co-ordinates of
+ * the line segments of the struct according to the current directions and
+ * lengths of the lines in the spiral.
  * each line segment is only one unit long, meaning multiple ones are needed for
  * lines longer than one unit.
+ * returns a status struct with error information (if any)
  */
-co_ord_array_t
-spiral_points(spiral_t spiral, co_ord_t start_point, size_t start, size_t end);
+status_t
+spiral_points(
+    spiral_t spiral, co_ord_array_t * output, co_ord_t start_point,
+    size_t start, size_t end
+);
 
 /*
  * given a pointer to a spiral struct an limit, which is the index of the last
@@ -33,8 +37,9 @@ spiral_points(spiral_t spiral, co_ord_t start_point, size_t start, size_t end);
  * each line segment is only one unit long, meaning multiple ones are needed for
  * lines longer than one unit. The co-ords are stored in the spiral's co_ord_cache
  * member and are re-used if they are still valid
+ * returns a status struct with error information (if any)
  */
-void
+status_t
 cache_spiral_points(spiral_t * spiral, size_t limit);
 
 #ifdef __cplusplus

saxbospiral/plot.h

@@ -17,11 +17,14 @@ extern "C"{
 #endif
 
 /*
- * given a spiral struct with co-ords in it's cache, find and return the co-ords
- * for the corners of the square needed to contain the points.
+ * given a spiral struct with co-ords in it's cache and a pointer to a
+ * 2-item-long array of type co_ord_t, find and store the co-ords for the
+ * corners of the square needed to contain the points.
+ * NOTE: This should NEVER be called with a pointer to anything other than a
+ * 2-item struct of type co_ord_t
  */
-static co_ord_array_t
-get_bounds(spiral_t spiral) {
+static void
+get_bounds(spiral_t spiral, co_ord_t * bounds) {
     tuple_item_t min_x = 0;
     tuple_item_t min_y = 0;
     tuple_item_t max_x = 0;
@@ -40,54 +43,64 @@ get_bounds(spiral_t spiral) {
             max_y = spiral.co_ord_cache.co_ords.items[i].y;
         }
     }
-    // initialise output struct
-    co_ord_array_t bounds = {
-        .size = 2,
-        .items = calloc(sizeof(co_ord_t), 2),
-    };
     // write bounds to struct
-    bounds.items[0].x = min_x;
-    bounds.items[0].y = min_y;
-    bounds.items[1].x = max_x;
-    bounds.items[1].y = max_y;
-    return bounds;
+    bounds[0].x = min_x;
+    bounds[0].y = min_y;
+    bounds[1].x = max_x;
+    bounds[1].y = max_y;
 }
 
 /*
- * given a spiral struct, returns a bitmap_t representing a monochromatic image
- * of the rendered spiral
+ * given a spiral struct and a pointer to a blank bitmap_t struct, writes data
+ * representing a monochromatic image of the rendered spiral to the bitmap
+ * returns a status struct with error information (if any)
  */
-bitmap_t
-render_spiral(spiral_t spiral) {
+status_t
+render_spiral(spiral_t spiral, bitmap_t * image) {
+    // create result status struct
+    status_t result = {};
     // plot co-ords of spiral into it's cache
     cache_spiral_points(&spiral, spiral.size);
     // get the min and max bounds of the spiral's co-ords
-    co_ord_array_t bounds = get_bounds(spiral);
+    co_ord_t bounds[2] = {};
+    get_bounds(spiral, bounds);
     // get the normalisation vector needed to make all values unsigned
     tuple_t normalisation_vector = {
-        .x = -bounds.items[0].x,
-        .y = -bounds.items[0].y,
+        .x = -bounds[0].x,
+        .y = -bounds[0].y,
     };
     // get co-ords of top left and bottom right corners, as unsigned
     co_ord_t top_left = {
         .x = 0,
         .y = 0,
     };
     co_ord_t bottom_right = {
-        .x = bounds.items[1].x + normalisation_vector.x,
-        .y = bounds.items[1].y + normalisation_vector.y,
-    };
-    // free memory allocated for bounds.items, as we no longer need it
-    free(bounds.items);
-    // initialise output bitmap - image dimensions are twice the size + 1
-    bitmap_t output = {
-        .width = ((bottom_right.x + 1) * 2) + 1,
-        .height = ((bottom_right.y + 1) * 2) + 1,
+        .x = bounds[1].x + normalisation_vector.x,
+        .y = bounds[1].y + normalisation_vector.y,
     };
-    // allocate dynamic memory - 2D array of bools
-    output.pixels = malloc(output.width * sizeof(bool*));
-    for(size_t i = 0; i < output.width; i++) {
-        output.pixels[i] = calloc(output.height, sizeof(bool));
+    // initialise image struct - image dimensions are twice the size + 1
+    image->width = ((bottom_right.x + 1) * 2) + 1;
+    image->height = ((bottom_right.y + 1) * 2) + 1;
+    // allocate dynamic memory to image struct - 2D array of bools
+    image->pixels = malloc(image->width * sizeof(bool*));
+    // check for malloc fail
+    if(image->pixels == NULL) {
+        result.location = DEBUG;
+        result.diagnostic = MALLOC_REFUSED;
+        return result;
+    }
+    for(size_t i = 0; i < image->width; i++) {
+        image->pixels[i] = calloc(image->height, sizeof(bool));
+        // check for malloc fail
+        if(image->pixels[i] == NULL) {
+            // we need to free() all previous rows
+            for(size_t j = i; j > 0; j--) {
+                free(image->pixels[j]);
+            }
+            result.location = DEBUG;
+            result.diagnostic = MALLOC_REFUSED;
+            return result;
+        }
     }
     // set 'current point' co-ordinate
     co_ord_t current = {
@@ -106,7 +119,7 @@ render_spiral(spiral_t spiral) {
             // skip the second pixel of the first line
             if(!((i == 0) && (j == 1))) {
                 // flip the y-axis otherwise they appear vertically mirrored
-                output.pixels[x_pos][output.height - 1 - y_pos] = true;
+                image->pixels[x_pos][image->height - 1 - y_pos] = true;
             }
             if(j != (spiral.lines[i].length * 2)) {
                 // if we're not on the last line, advance the marker along
@@ -115,7 +128,9 @@ render_spiral(spiral_t spiral) {
             }
         }
     }
-    return output;
+    // status ok
+    result.diagnostic = OPERATION_OK;
+    return result;
 }
 
 #ifdef __cplusplus