Merge pull request #7 from saxbophone/develop

Version v0.5.9

Author: saxbophone

.gitignore

@@ -30,9 +30,3 @@
 
 # Debug files
 *.dSYM/
-
-# Custom executables using names used in Makefile
-tests
-prepare
-generate
-render

Makefile

@@ -9,57 +9,59 @@ INCLUDES=
 CFLAGS=$(STANDARD) $(OPTIMISE) $(DEBUG) $(INCLUDES)
 LIBPNG=-lpng
 LIB=saxbospiral.h
+OS_NAME=
+EXE_SUFFIX=.out
 
 saxbospiral.o: saxbospiral.c $(LIB)
-	$(CC) $(CFLAGS) -c saxbospiral.c
+	$(CC) $(CFLAGS) -o saxbospiral$(OS_NAME).o -c saxbospiral.c
 
 tests.o: $(LIB) tests.c
-	$(CC) $(CFLAGS) -c tests.c
+	$(CC) $(CFLAGS) -o tests$(OS_NAME).o -c tests.c
 
 tests: saxbospiral.o tests.o
-	$(CC) $(CFLAGS) -o tests saxbospiral.o tests.o
+	$(CC) $(CFLAGS) -o tests$(OS_NAME)$(EXE_SUFFIX) saxbospiral$(OS_NAME).o tests$(OS_NAME).o
 
 prepare.o: $(LIB) prepare.c
-	$(CC) $(CFLAGS) -c prepare.c
+	$(CC) $(CFLAGS) -o prepare$(OS_NAME).o -c prepare.c
 
 prepare: saxbospiral.o prepare.o
-	$(CC) $(CFLAGS) -o prepare saxbospiral.o prepare.o
+	$(CC) $(CFLAGS) -o prepare$(OS_NAME)$(EXE_SUFFIX) saxbospiral$(OS_NAME).o prepare$(OS_NAME).o
 
 generate.o: $(LIB) generate.c
-	$(CC) $(CFLAGS) -c generate.c
+	$(CC) $(CFLAGS) -o generate$(OS_NAME).o -c generate.c
 
 generate: saxbospiral.o generate.o
-	$(CC) $(CFLAGS) -o generate saxbospiral.o generate.o
+	$(CC) $(CFLAGS) -o generate$(OS_NAME)$(EXE_SUFFIX) saxbospiral$(OS_NAME).o generate$(OS_NAME).o
 
 render.o: $(LIB) render.c
-	$(CC) $(CFLAGS) -c render.c
+	$(CC) $(CFLAGS) -o render$(OS_NAME).o -c render.c
 
 render: saxbospiral.o render.o
-	$(CC) $(CFLAGS) -o render saxbospiral.o render.o $(LIBPNG)
+	$(CC) $(CFLAGS) -o render$(OS_NAME)$(EXE_SUFFIX) saxbospiral$(OS_NAME).o render$(OS_NAME).o $(LIBPNG)
 
 test-unit: tests
-	./tests
+	./tests$(OS_NAME)$(EXE_SUFFIX)
 
 test-func: prepare generate render
 	@echo "Running Functional Test"
 	@echo -n "saxbospiral `git describe --abbrev=0`" > message.hex
-	@./prepare message.hex message.sxp.hex
-	@./generate message.sxp.hex
-	@./render message.sxp.hex saxbospiral_test.png
+	@./prepare$(OS_NAME)$(EXE_SUFFIX) message.hex message.sxp.hex
+	@./generate$(OS_NAME)$(EXE_SUFFIX) message.sxp.hex
+	@./render$(OS_NAME)$(EXE_SUFFIX) message.sxp.hex saxbospiral_test.png
 	@diff saxbospiral.png saxbospiral_test.png
 	@rm saxbospiral_test.png message.hex message.sxp.hex
 
 logo: prepare generate render
 	@echo "Generating logo"
 	@echo -n "saxbospiral `git describe --abbrev=0`" > saxbospiral.hex
-	@./prepare saxbospiral.hex saxbospiral.sxp
-	@./generate saxbospiral.sxp
-	@./render saxbospiral.sxp saxbospiral.png
+	@./prepare$(OS_NAME)$(EXE_SUFFIX) saxbospiral.hex saxbospiral.sxp
+	@./generate$(OS_NAME)$(EXE_SUFFIX) saxbospiral.sxp
+	@./render$(OS_NAME)$(EXE_SUFFIX) saxbospiral.sxp saxbospiral.png
 	@rm saxbospiral.hex saxbospiral.sxp
 
 build: prepare generate render
 
 clean:
-	rm -f *.o tests prepare generate render
+	rm -f *.o *.out *.exe
 
 all: test-unit test-func build

build_all.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+# NOTE: This file assumes you are running linux and have installed cross-compilers for Windows and OSX.
+# I used w64-mingw32-gcc and OSXCROSS (https://github.com/tpoechtrager/osxcross) respectively. 
+
+$POSIX_EXTENSION='';
+if [[ $USE_POSIX_EXTENSIONS ]]; then
+    $POSIX_EXTENSION='.out';
+fi
+
+make prepare generate tests OS_NAME=_lin64 EXE_SUFFIX=$POSIX_EXTENSION; # linux 64-bit target
+make prepare generate tests OPTIMISE=-O3 CC=o32-clang OS_NAME=_osx32 EXE_SUFFIX=$POSIX_EXTENSION; # osx 32-bit target
+make prepare generate tests OPTIMISE=-O3 CC=o64-clang OS_NAME=_osx64 EXE_SUFFIX=$POSIX_EXTENSION; # osx 64-bit target
+make prepare generate tests OPTIMISE=-O3 CC=i686-w64-mingw32-gcc OS_NAME=_win32 EXE_SUFFIX=.exe; # windows 32-bit target
+make prepare generate tests OPTIMISE=-O3 CC=x86_64-w64-mingw32-gcc OS_NAME=_win64 EXE_SUFFIX=.exe; # windows 64-bit target

saxbospiral.c

@@ -11,10 +11,12 @@ extern "C"{
 #endif
 
 const version_t VERSION = {
-    .major = 0, .minor = 5, .patch = 8,
+    .major = 0, .minor = 5, .patch = 9,
 };
 
+// constants related to how spiral data is packed in files - measured in bytes
 const size_t FILE_HEADER_SIZE = 25;
+const size_t LINE_T_PACK_SIZE = 4;
 
 // vector direction constants
 const vector_t VECTOR_DIRECTIONS[4] = {
@@ -287,7 +289,7 @@ load_spiral(buffer_t buffer) {
             spiral_size |= (buffer.bytes[16 + i]) << (8 * (7 - i));
         }
         // Check that the file data section is large enough for the spiral size
-        if((buffer.size - FILE_HEADER_SIZE) != (sizeof(line_t) * spiral_size)) {
+        if((buffer.size - FILE_HEADER_SIZE) != (LINE_T_PACK_SIZE * spiral_size)) {
             // this check failed, so return it as it is
             return output;
         }
@@ -299,18 +301,18 @@ load_spiral(buffer_t buffer) {
         for(size_t i = 0; i < spiral_size; i++) {
             // direction is stored in 2 most significant bits of each 32-bit sequence
             output.lines[i].direction = (
-                buffer.bytes[FILE_HEADER_SIZE + (i * sizeof(line_t))] >> 6
+                buffer.bytes[FILE_HEADER_SIZE + (i * LINE_T_PACK_SIZE)] >> 6
             );
             // length is stored as 30 least significant bits, so we have to unpack it
             // handle first byte on it's own as we only need least 6 bits of it
             // bit mask and shift 3 bytes to left
             output.lines[i].length = (
-                buffer.bytes[FILE_HEADER_SIZE + (i * sizeof(line_t))] & 0b00111111
+                buffer.bytes[FILE_HEADER_SIZE + (i * LINE_T_PACK_SIZE)] & 0b00111111
             ) << 24;
             // handle remaining 3 bytes in loop
             for(uint8_t j = 0; j < 3; j++) {
                 output.lines[i].length |= (
-                    buffer.bytes[FILE_HEADER_SIZE + (i * sizeof(line_t)) + 1 + j]
+                    buffer.bytes[FILE_HEADER_SIZE + (i * LINE_T_PACK_SIZE) + 1 + j]
                 ) << (8 * (2 - j));
             }
         }
@@ -325,7 +327,7 @@ buffer_t
 dump_spiral(spiral_t spiral) {
     // build output buffer struct, base size on header + spiral size
     buffer_t output = {
-        .size = (FILE_HEADER_SIZE + (sizeof(line_t) * spiral.size)),
+        .size = (FILE_HEADER_SIZE + (LINE_T_PACK_SIZE * spiral.size)),
     };
     // allocate memory
     output.bytes = calloc(1, output.size);
@@ -348,16 +350,16 @@ dump_spiral(spiral_t spiral) {
         // serialise each line in the spiral to 4 bytes, handle first byte first
         // map direction to 2 most significant bits
         output.bytes[
-            FILE_HEADER_SIZE + (i * sizeof(line_t))
+            FILE_HEADER_SIZE + (i * LINE_T_PACK_SIZE)
         ] = (spiral.lines[i].direction << 6);
         // handle first 6 bits of the length
         output.bytes[
-            FILE_HEADER_SIZE + (i * sizeof(line_t))
+            FILE_HEADER_SIZE + (i * LINE_T_PACK_SIZE)
         ] |= (spiral.lines[i].length >> 24);
         // handle remaining 3 bytes in a loop
         for(uint8_t j = 0; j < 3; j++) {
             output.bytes[
-                FILE_HEADER_SIZE + (i * sizeof(line_t)) + 1 + j
+                FILE_HEADER_SIZE + (i * LINE_T_PACK_SIZE) + 1 + j
             ] = (uint8_t)(spiral.lines[i].length >> (8 * (2 - j)));
         }
     }

saxbospiral.h

@@ -17,7 +17,9 @@ typedef struct version_t {
 
 extern const version_t VERSION;
 
+// constants related to how spiral data is packed in files - measured in bytes
 extern const size_t FILE_HEADER_SIZE;
+extern const size_t LINE_T_PACK_SIZE;
 
 // type for representing a cartesian direction
 typedef uint8_t direction_t;

saxbospiral.png

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+echo -n "TEST" > test.hex;
+./prepare test.hex test.sxp.hex;
+time for i in {1..1000}; do ./generate test.sxp.hex; done;