Make helper functions void

As reported by #65

Author: tbeu

src/read_data_impl.h

@@ -336,12 +336,11 @@ READ_TYPED_FUNC1(mat_t *mat, READ_TYPE *data, enum matio_types data_type, size_t
 #define READ_TYPE_UINT64_DATA CAT(READ_TYPED_FUNC2, UInt64)
 #endif /* HAVE_MAT_UINT64_T */
 
-static size_t
+static void
 READ_TYPE_DOUBLE_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
 {
-    size_t bytesread = 0;
 #if READ_TYPE_TYPE == READ_TYPE_DOUBLE
-    bytesread = InflateData(mat, z, data, len*sizeof(double));
+    InflateData(mat, z, data, len*sizeof(double));
     if ( mat->byteswap ) {
         mat_uint32_t i;
         for ( i = 0; i < len; i++ ) {
@@ -354,15 +353,13 @@ READ_TYPE_DOUBLE_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len
     double v[READ_BLOCK_SIZE/sizeof(double)];
     READ_COMPRESSED_DATA(READ_TYPE, Mat_doubleSwap);
 #endif
-    return bytesread;
 }
 
-static size_t
+static void
 READ_TYPE_SINGLE_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
 {
-    size_t bytesread = 0;
 #if READ_TYPE_TYPE == READ_TYPE_SINGLE
-    bytesread = InflateData(mat, z, data, len*sizeof(float));
+    InflateData(mat, z, data, len*sizeof(float));
     if ( mat->byteswap ) {
         mat_uint32_t i;
         for ( i = 0; i < len; i++ ) {
@@ -375,16 +372,14 @@ READ_TYPE_SINGLE_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len
     float v[READ_BLOCK_SIZE/sizeof(float)];
     READ_COMPRESSED_DATA(READ_TYPE, Mat_floatSwap);
 #endif
-    return bytesread;
 }
 
 #ifdef HAVE_MAT_INT64_T
-static size_t
+static void
 READ_TYPE_INT64_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
 {
-    size_t bytesread = 0;
 #if READ_TYPE_TYPE == READ_TYPE_INT64
-    bytesread = InflateData(mat, z, data, len*sizeof(mat_int64_t));
+    InflateData(mat, z, data, len*sizeof(mat_int64_t));
     if ( mat->byteswap ) {
         mat_uint32_t i;
         for ( i = 0; i < len; i++ ) {
@@ -397,17 +392,15 @@ READ_TYPE_INT64_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
     mat_int64_t v[READ_BLOCK_SIZE/sizeof(mat_int64_t)];
     READ_COMPRESSED_DATA(READ_TYPE, Mat_int64Swap);
 #endif
-    return bytesread;
 }
 #endif /* HAVE_MAT_INT64_T */
 
 #ifdef HAVE_MAT_UINT64_T
-static size_t
+static void
 READ_TYPE_UINT64_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
 {
-    size_t bytesread = 0;
 #if READ_TYPE_TYPE == READ_TYPE_UINT64
-    bytesread = InflateData(mat, z, data, len*sizeof(mat_uint64_t));
+    InflateData(mat, z, data, len*sizeof(mat_uint64_t));
     if ( mat->byteswap ) {
         mat_uint32_t i;
         for ( i = 0; i < len; i++ ) {
@@ -420,16 +413,14 @@ READ_TYPE_UINT64_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len
     mat_uint64_t v[READ_BLOCK_SIZE/sizeof(mat_uint64_t)];
     READ_COMPRESSED_DATA(READ_TYPE, Mat_uint64Swap);
 #endif
-    return bytesread;
 }
 #endif /* HAVE_MAT_UINT64_T */
 
-static size_t
+static void
 READ_TYPE_INT32_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
 {
-    size_t bytesread = 0;
 #if READ_TYPE_TYPE == READ_TYPE_INT32
-    bytesread = InflateData(mat, z, data, len*sizeof(mat_int32_t));
+    InflateData(mat, z, data, len*sizeof(mat_int32_t));
     if ( mat->byteswap ) {
         mat_uint32_t i;
         for ( i = 0; i < len; i++ ) {
@@ -442,15 +433,13 @@ READ_TYPE_INT32_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
     mat_int32_t v[READ_BLOCK_SIZE/sizeof(mat_int32_t)];
     READ_COMPRESSED_DATA(READ_TYPE, Mat_int32Swap);
 #endif
-    return bytesread;
 }
 
-static size_t
+static void
 READ_TYPE_UINT32_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
 {
-    size_t bytesread = 0;
 #if READ_TYPE_TYPE == READ_TYPE_UINT32
-    bytesread = InflateData(mat, z, data, len*sizeof(mat_uint32_t));
+    InflateData(mat, z, data, len*sizeof(mat_uint32_t));
     if ( mat->byteswap ) {
         mat_uint32_t i;
         for ( i = 0; i < len; i++ ) {
@@ -463,15 +452,13 @@ READ_TYPE_UINT32_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len
     mat_uint32_t v[READ_BLOCK_SIZE/sizeof(mat_uint32_t)];
     READ_COMPRESSED_DATA(READ_TYPE, Mat_uint32Swap);
 #endif
-    return bytesread;
 }
 
-static size_t
+static void
 READ_TYPE_INT16_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
 {
-    size_t bytesread = 0;
 #if READ_TYPE_TYPE == READ_TYPE_INT16
-    bytesread = InflateData(mat, z, data, len*sizeof(mat_int16_t));
+    InflateData(mat, z, data, len*sizeof(mat_int16_t));
     if ( mat->byteswap ) {
         mat_uint32_t i;
         for ( i = 0; i < len; i++ ) {
@@ -484,15 +471,13 @@ READ_TYPE_INT16_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
     mat_int16_t v[READ_BLOCK_SIZE/sizeof(mat_int16_t)];
     READ_COMPRESSED_DATA(READ_TYPE, Mat_int16Swap);
 #endif
-    return bytesread;
 }
 
-static size_t
+static void
 READ_TYPE_UINT16_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
 {
-    size_t bytesread = 0;
 #if READ_TYPE_TYPE == READ_TYPE_UINT16
-    bytesread = InflateData(mat, z, data, len*sizeof(mat_uint16_t));
+    InflateData(mat, z, data, len*sizeof(mat_uint16_t));
     if ( mat->byteswap ) {
         mat_uint32_t i;
         for ( i = 0; i < len; i++ ) {
@@ -505,37 +490,32 @@ READ_TYPE_UINT16_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len
     mat_uint16_t v[READ_BLOCK_SIZE/sizeof(mat_uint16_t)];
     READ_COMPRESSED_DATA(READ_TYPE, Mat_uint16Swap);
 #endif
-    return bytesread;
 }
 
-static size_t
+static void
 READ_TYPE_INT8_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
 {
-    size_t bytesread = 0;
 #if READ_TYPE_TYPE == READ_TYPE_INT8
-    bytesread = InflateData(mat, z, data, len*sizeof(mat_int8_t));
+    InflateData(mat, z, data, len*sizeof(mat_int8_t));
 #else
     mat_uint32_t i;
     const size_t data_size = sizeof(mat_int8_t);
     mat_int8_t v[READ_BLOCK_SIZE/sizeof(mat_int8_t)];
     READ_COMPRESSED_DATA_NOSWAP(READ_TYPE);
 #endif
-    return bytesread;
 }
 
-static size_t
+static void
 READ_TYPE_UINT8_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
 {
-    size_t bytesread = 0;
 #if READ_TYPE_TYPE == READ_TYPE_UINT8
-    bytesread = InflateData(mat, z, data, len*sizeof(mat_uint8_t));
+    InflateData(mat, z, data, len*sizeof(mat_uint8_t));
 #else
     mat_uint32_t i;
     const size_t data_size = sizeof(mat_uint8_t);
     mat_uint8_t v[READ_BLOCK_SIZE/sizeof(mat_uint8_t)];
     READ_COMPRESSED_DATA_NOSWAP(READ_TYPE);
 #endif
-    return bytesread;
 }
 
 /** @brief Reads data of type @c data_type into a READ_TYPE type