#1062

Committed 27 Apr 2026 05:41PM UTC coverage: 82.993% (-0.06%) from 83.048%

Build # #1062

Build Type

push

travis-ci

Committed by

tbeu

Commit Message

Avoid uninitialized memory access

As reported by https://issues.oss-fuzz.com/506942183

Coverage Stats

13112 of 15799 relevant lines covered (82.99%)

53290.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.42

/src/read_data_impl.h

/*
 * Copyright (c) 2015-2026, The matio contributors
 * Copyright (c) 2019-2014, Christopher C. Hulbert
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#define READ_TYPE_DOUBLE_DATA CAT(READ_TYPED_FUNC1, Double)
#define READ_TYPE_SINGLE_DATA CAT(READ_TYPED_FUNC1, Single)
#define READ_TYPE_INT32_DATA CAT(READ_TYPED_FUNC1, Int32)
#define READ_TYPE_UINT32_DATA CAT(READ_TYPED_FUNC1, UInt32)
#define READ_TYPE_INT16_DATA CAT(READ_TYPED_FUNC1, Int16)
#define READ_TYPE_UINT16_DATA CAT(READ_TYPED_FUNC1, UInt16)
#define READ_TYPE_INT8_DATA CAT(READ_TYPED_FUNC1, Int8)
#define READ_TYPE_UINT8_DATA CAT(READ_TYPED_FUNC1, UInt8)
#ifdef HAVE_MAT_INT64_T
#define READ_TYPE_INT64_DATA CAT(READ_TYPED_FUNC1, Int64)
#endif /* HAVE_MAT_INT64_T */
#ifdef HAVE_MAT_UINT64_T
#define READ_TYPE_UINT64_DATA CAT(READ_TYPED_FUNC1, UInt64)
#endif /* HAVE_MAT_UINT64_T */

static int
READ_TYPE_DOUBLE_DATA(mat_t *mat, READ_TYPE *data, size_t len)
{
    size_t readCount;
    int err;
#if READ_TYPE_TYPE == READ_TYPE_DOUBLE
    readCount = fread(data, sizeof(double), len, (FILE *)mat->fp);
    if ( readCount != len ) {
        return MATIO_E_GENERIC_READ_ERROR;
    }
    err = MATIO_E_NO_ERROR;
    if ( mat->byteswap ) {
        size_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_doubleSwap(data + i);
        }
    }
#else
    size_t i;
    const size_t data_size = sizeof(double);
    double v[READ_BLOCK_SIZE / sizeof(double)];
    READ_DATA(READ_TYPE, Mat_doubleSwap);
#endif
    return err;
}

static int
READ_TYPE_SINGLE_DATA(mat_t *mat, READ_TYPE *data, size_t len)
{
    size_t readCount;
    int err;
#if READ_TYPE_TYPE == READ_TYPE_SINGLE
    readCount = fread(data, sizeof(float), len, (FILE *)mat->fp);
    if ( readCount != len ) {
        return MATIO_E_GENERIC_READ_ERROR;
    }
    err = MATIO_E_NO_ERROR;
    if ( mat->byteswap ) {
        size_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_floatSwap(data + i);
        }
    }
#else
    size_t i;
    const size_t data_size = sizeof(float);
    float v[READ_BLOCK_SIZE / sizeof(float)];
    READ_DATA(READ_TYPE, Mat_floatSwap);
#endif
    return err;
}

static int
READ_TYPE_INT32_DATA(mat_t *mat, READ_TYPE *data, size_t len)
{
    size_t readCount;
    int err;
#if READ_TYPE_TYPE == READ_TYPE_INT32
    readCount = fread(data, sizeof(mat_int32_t), len, (FILE *)mat->fp);
    if ( readCount != len ) {
        return MATIO_E_GENERIC_READ_ERROR;
    }
    err = MATIO_E_NO_ERROR;
    if ( mat->byteswap ) {
        size_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_int32Swap(data + i);
        }
    }
#else
    size_t i;
    const size_t data_size = sizeof(mat_int32_t);
    mat_int32_t v[READ_BLOCK_SIZE / sizeof(mat_int32_t)];
    READ_DATA(READ_TYPE, Mat_int32Swap);
#endif
    return err;
}

static int
READ_TYPE_UINT32_DATA(mat_t *mat, READ_TYPE *data, size_t len)
{
    size_t readCount;
    int err;
#if READ_TYPE_TYPE == READ_TYPE_UINT32
    readCount = fread(data, sizeof(mat_uint32_t), len, (FILE *)mat->fp);
    if ( readCount != len ) {
        return MATIO_E_GENERIC_READ_ERROR;
    }
    err = MATIO_E_NO_ERROR;
    if ( mat->byteswap ) {
        size_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_uint32Swap(data + i);
        }
    }
#else
    size_t i;
    const size_t data_size = sizeof(mat_uint32_t);
    mat_uint32_t v[READ_BLOCK_SIZE / sizeof(mat_uint32_t)];
    READ_DATA(READ_TYPE, Mat_uint32Swap);
#endif
    return err;
}

static int
READ_TYPE_INT16_DATA(mat_t *mat, READ_TYPE *data, size_t len)
{
    size_t readCount;
    int err;
#if READ_TYPE_TYPE == READ_TYPE_INT16
    readCount = fread(data, sizeof(mat_int16_t), len, (FILE *)mat->fp);
    if ( readCount != len ) {
        return MATIO_E_GENERIC_READ_ERROR;
    }
    err = MATIO_E_NO_ERROR;
    if ( mat->byteswap ) {
        size_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_int16Swap(data + i);
        }
    }
#else
    size_t i;
    const size_t data_size = sizeof(mat_int16_t);
    mat_int16_t v[READ_BLOCK_SIZE / sizeof(mat_int16_t)];
    READ_DATA(READ_TYPE, Mat_int16Swap);
#endif
    return err;
}

static int
READ_TYPE_UINT16_DATA(mat_t *mat, READ_TYPE *data, size_t len)
{
    size_t readCount;
    int err;
#if READ_TYPE_TYPE == READ_TYPE_UINT16
    readCount = fread(data, sizeof(mat_uint16_t), len, (FILE *)mat->fp);
    if ( readCount != len ) {
        return MATIO_E_GENERIC_READ_ERROR;
    }
    err = MATIO_E_NO_ERROR;
    if ( mat->byteswap ) {
        size_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_uint16Swap(data + i);
        }
    }
#else
    size_t i;
    const size_t data_size = sizeof(mat_uint16_t);
    mat_uint16_t v[READ_BLOCK_SIZE / sizeof(mat_uint16_t)];
    READ_DATA(READ_TYPE, Mat_uint16Swap);
#endif
    return err;
}

static int
READ_TYPE_INT8_DATA(mat_t *mat, READ_TYPE *data, size_t len)
{
    size_t readCount;
    int err;
#if READ_TYPE_TYPE == READ_TYPE_INT8
    readCount = fread(data, sizeof(mat_int8_t), len, (FILE *)mat->fp);
    if ( readCount != len ) {
        return MATIO_E_GENERIC_READ_ERROR;
    }
    err = MATIO_E_NO_ERROR;
#else
    size_t i;
    const size_t data_size = sizeof(mat_int8_t);
    mat_int8_t v[READ_BLOCK_SIZE / sizeof(mat_int8_t)];
    READ_DATA_NOSWAP(READ_TYPE);
#endif
    return err;
}

static int
READ_TYPE_UINT8_DATA(mat_t *mat, READ_TYPE *data, size_t len)
{
    size_t readCount;
    int err;
#if READ_TYPE_TYPE == READ_TYPE_UINT8
    readCount = fread(data, sizeof(mat_uint8_t), len, (FILE *)mat->fp);
    if ( readCount != len ) {
        return MATIO_E_GENERIC_READ_ERROR;
    }
    err = MATIO_E_NO_ERROR;
#else
    size_t i;
    const size_t data_size = sizeof(mat_uint8_t);
    mat_uint8_t v[READ_BLOCK_SIZE / sizeof(mat_uint8_t)];
    READ_DATA_NOSWAP(READ_TYPE);
#endif
    return err;
}

#ifdef HAVE_MAT_INT64_T
static int
READ_TYPE_INT64_DATA(mat_t *mat, READ_TYPE *data, size_t len)
{
    size_t readCount;
    int err;
#if READ_TYPE_TYPE == READ_TYPE_INT64
    readCount = fread(data, sizeof(mat_int64_t), len, (FILE *)mat->fp);
    if ( readCount != len ) {
        return MATIO_E_GENERIC_READ_ERROR;
    }
    err = MATIO_E_NO_ERROR;
    if ( mat->byteswap ) {
        size_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_int64Swap(data + i);
        }
    }
#else
    size_t i;
    const size_t data_size = sizeof(mat_int64_t);
    mat_int64_t v[READ_BLOCK_SIZE / sizeof(mat_int64_t)];
    READ_DATA(READ_TYPE, Mat_int64Swap);
#endif
    return err;
}
#endif /* HAVE_MAT_INT64_T */

#ifdef HAVE_MAT_UINT64_T
static int
READ_TYPE_UINT64_DATA(mat_t *mat, READ_TYPE *data, size_t len)
{
    size_t readCount;
    int err;
#if READ_TYPE_TYPE == READ_TYPE_UINT64
    readCount = fread(data, sizeof(mat_uint64_t), len, (FILE *)mat->fp);
    if ( readCount != len ) {
        return MATIO_E_GENERIC_READ_ERROR;
    }
    err = MATIO_E_NO_ERROR;
    if ( mat->byteswap ) {
        size_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_uint64Swap(data + i);
        }
    }
#else
    size_t i;
    const size_t data_size = sizeof(mat_uint64_t);
    mat_uint64_t v[READ_BLOCK_SIZE / sizeof(mat_uint64_t)];
    READ_DATA(READ_TYPE, Mat_uint64Swap);
#endif
    return err;
}
#endif /* HAVE_MAT_UINT64_T */

/** @brief Reads data of type @c data_type into a READ_TYPE type
 *
 * Reads from the MAT file @c len elements of data type @c data_type storing
 * them as READ_TYPE's in @c data.
 * @ingroup mat_internal
 * @param mat MAT file pointer
 * @param data Pointer to store the output values (len*sizeof(READ_TYPE))
 * @param data_type one of the @c matio_types enumerations which is the source
 *                  data type in the file
 * @param len Number of elements of type @c data_type to read from the file
 * @retval 0 on success
 */
int
READ_TYPED_FUNC1(mat_t *mat, READ_TYPE *data, enum matio_types data_type, size_t len)
{
    if ( mat == NULL || data == NULL || mat->fp == NULL )
        return MATIO_E_BAD_ARGUMENT;

    switch ( data_type ) {
        case MAT_T_DOUBLE:
            return READ_TYPE_DOUBLE_DATA(mat, data, len);
        case MAT_T_SINGLE:
            return READ_TYPE_SINGLE_DATA(mat, data, len);
#ifdef HAVE_MAT_INT64_T
        case MAT_T_INT64:
            return READ_TYPE_INT64_DATA(mat, data, len);
#endif /* HAVE_MAT_UINT64_T */
#ifdef HAVE_MAT_UINT64_T
        case MAT_T_UINT64:
            return READ_TYPE_UINT64_DATA(mat, data, len);
#endif /* HAVE_MAT_UINT64_T */
        case MAT_T_INT32:
            return READ_TYPE_INT32_DATA(mat, data, len);
        case MAT_T_UINT32:
            return READ_TYPE_UINT32_DATA(mat, data, len);
        case MAT_T_INT16:
            return READ_TYPE_INT16_DATA(mat, data, len);
        case MAT_T_UINT16:
            return READ_TYPE_UINT16_DATA(mat, data, len);
        case MAT_T_INT8:
            return READ_TYPE_INT8_DATA(mat, data, len);
        case MAT_T_UINT8:
            return READ_TYPE_UINT8_DATA(mat, data, len);
        default:
            break;
    }
    return MATIO_E_GENERIC_READ_ERROR;
}

#undef READ_TYPE_DOUBLE_DATA
#undef READ_TYPE_SINGLE_DATA
#undef READ_TYPE_INT32_DATA
#undef READ_TYPE_UINT32_DATA
#undef READ_TYPE_INT16_DATA
#undef READ_TYPE_UINT16_DATA
#undef READ_TYPE_INT8_DATA
#undef READ_TYPE_UINT8_DATA
#ifdef HAVE_MAT_INT64_T
#undef READ_TYPE_INT64_DATA
#endif /* HAVE_MAT_INT64_T */
#ifdef HAVE_MAT_UINT64_T
#undef READ_TYPE_UINT64_DATA
#endif /* HAVE_MAT_UINT64_T */

#if HAVE_ZLIB

#define READ_TYPE_DOUBLE_DATA CAT(READ_TYPED_FUNC2, Double)
#define READ_TYPE_SINGLE_DATA CAT(READ_TYPED_FUNC2, Single)
#define READ_TYPE_INT32_DATA CAT(READ_TYPED_FUNC2, Int32)
#define READ_TYPE_UINT32_DATA CAT(READ_TYPED_FUNC2, UInt32)
#define READ_TYPE_INT16_DATA CAT(READ_TYPED_FUNC2, Int16)
#define READ_TYPE_UINT16_DATA CAT(READ_TYPED_FUNC2, UInt16)
#define READ_TYPE_INT8_DATA CAT(READ_TYPED_FUNC2, Int8)
#define READ_TYPE_UINT8_DATA CAT(READ_TYPED_FUNC2, UInt8)
#ifdef HAVE_MAT_INT64_T
#define READ_TYPE_INT64_DATA CAT(READ_TYPED_FUNC2, Int64)
#endif /* HAVE_MAT_INT64_T */
#ifdef HAVE_MAT_UINT64_T
#define READ_TYPE_UINT64_DATA CAT(READ_TYPED_FUNC2, UInt64)
#endif /* HAVE_MAT_UINT64_T */

static int
READ_TYPE_DOUBLE_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
{
    int err;
#if READ_TYPE_TYPE == READ_TYPE_DOUBLE
    err = InflateData(mat, z, data, len * sizeof(double));
    if ( err ) {
        return err;
    }
    if ( mat->byteswap ) {
        mat_uint32_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_doubleSwap(data + i);
        }
    }
#else
    mat_uint32_t i;
    const size_t data_size = sizeof(double);
    double v[READ_BLOCK_SIZE / sizeof(double)];
    READ_COMPRESSED_DATA(READ_TYPE, Mat_doubleSwap);
#endif
    return err;
}

static int
READ_TYPE_SINGLE_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
{
    int err;
#if READ_TYPE_TYPE == READ_TYPE_SINGLE
    err = InflateData(mat, z, data, len * sizeof(float));
    if ( err ) {
        return err;
    }
    if ( mat->byteswap ) {
        mat_uint32_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_floatSwap(data + i);
        }
    }
#else
    mat_uint32_t i;
    const size_t data_size = sizeof(float);
    float v[READ_BLOCK_SIZE / sizeof(float)];
    READ_COMPRESSED_DATA(READ_TYPE, Mat_floatSwap);
#endif
    return err;
}

#ifdef HAVE_MAT_INT64_T
static int
READ_TYPE_INT64_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
{
    int err;
#if READ_TYPE_TYPE == READ_TYPE_INT64
    err = InflateData(mat, z, data, len * sizeof(mat_int64_t));
    if ( err ) {
        return err;
    }
    if ( mat->byteswap ) {
        mat_uint32_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_int64Swap(data + i);
        }
    }
#else
    mat_uint32_t i;
    const size_t data_size = sizeof(mat_int64_t);
    mat_int64_t v[READ_BLOCK_SIZE / sizeof(mat_int64_t)];
    READ_COMPRESSED_DATA(READ_TYPE, Mat_int64Swap);
#endif
    return err;
}
#endif /* HAVE_MAT_INT64_T */

#ifdef HAVE_MAT_UINT64_T
static int
READ_TYPE_UINT64_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
{
    int err;
#if READ_TYPE_TYPE == READ_TYPE_UINT64
    err = InflateData(mat, z, data, len * sizeof(mat_uint64_t));
    if ( err ) {
        return err;
    }
    if ( mat->byteswap ) {
        mat_uint32_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_uint64Swap(data + i);
        }
    }
#else
    mat_uint32_t i;
    const size_t data_size = sizeof(mat_uint64_t);
    mat_uint64_t v[READ_BLOCK_SIZE / sizeof(mat_uint64_t)];
    READ_COMPRESSED_DATA(READ_TYPE, Mat_uint64Swap);
#endif
    return err;
}
#endif /* HAVE_MAT_UINT64_T */

static int
READ_TYPE_INT32_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
{
    int err;
#if READ_TYPE_TYPE == READ_TYPE_INT32
    err = InflateData(mat, z, data, len * sizeof(mat_int32_t));
    if ( err ) {
        return err;
    }
    if ( mat->byteswap ) {
        mat_uint32_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_int32Swap(data + i);
        }
    }
#else
    mat_uint32_t i;
    const size_t data_size = sizeof(mat_int32_t);
    mat_int32_t v[READ_BLOCK_SIZE / sizeof(mat_int32_t)];
    READ_COMPRESSED_DATA(READ_TYPE, Mat_int32Swap);
#endif
    return err;
}

static int
READ_TYPE_UINT32_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
{
    int err;
#if READ_TYPE_TYPE == READ_TYPE_UINT32
    err = InflateData(mat, z, data, len * sizeof(mat_uint32_t));
    if ( err ) {
        return err;
    }
    if ( mat->byteswap ) {
        mat_uint32_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_uint32Swap(data + i);
        }
    }
#else
    mat_uint32_t i;
    const size_t data_size = sizeof(mat_uint32_t);
    mat_uint32_t v[READ_BLOCK_SIZE / sizeof(mat_uint32_t)];
    READ_COMPRESSED_DATA(READ_TYPE, Mat_uint32Swap);
#endif
    return err;
}

static int
READ_TYPE_INT16_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
{
    int err;
#if READ_TYPE_TYPE == READ_TYPE_INT16
    err = InflateData(mat, z, data, len * sizeof(mat_int16_t));
    if ( err ) {
        return err;
    }
    if ( mat->byteswap ) {
        mat_uint32_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_int16Swap(data + i);
        }
    }
#else
    mat_uint32_t i;
    const size_t data_size = sizeof(mat_int16_t);
    mat_int16_t v[READ_BLOCK_SIZE / sizeof(mat_int16_t)];
    READ_COMPRESSED_DATA(READ_TYPE, Mat_int16Swap);
#endif
    return err;
}

static int
READ_TYPE_UINT16_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
{
    int err;
#if READ_TYPE_TYPE == READ_TYPE_UINT16
    err = InflateData(mat, z, data, len * sizeof(mat_uint16_t));
    if ( err ) {
        return err;
    }
    if ( mat->byteswap ) {
        mat_uint32_t i;
        for ( i = 0; i < len; i++ ) {
            (void)Mat_uint16Swap(data + i);
        }
    }
#else
    mat_uint32_t i;
    const size_t data_size = sizeof(mat_uint16_t);
    mat_uint16_t v[READ_BLOCK_SIZE / sizeof(mat_uint16_t)];
    READ_COMPRESSED_DATA(READ_TYPE, Mat_uint16Swap);
#endif
    return err;
}

static int
READ_TYPE_INT8_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
{
    int err;
#if READ_TYPE_TYPE == READ_TYPE_INT8
    err = 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 err;
}

static int
READ_TYPE_UINT8_DATA(mat_t *mat, z_streamp z, READ_TYPE *data, mat_uint32_t len)
{
    int err;
#if READ_TYPE_TYPE == READ_TYPE_UINT8
    err = 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 err;
}

/** @brief Reads data of type @c data_type into a READ_TYPE type
 *
 * Reads from the MAT file @c len compressed elements of data type @c data_type
 * storing them as READ_TYPE's in @c data.
 * @ingroup mat_internal
 * @param mat MAT file pointer
 * @param z Pointer to the zlib stream for inflation
 * @param data Pointer to store the output values (len*sizeof(READ_TYPE))
 * @param data_type one of the @c matio_types enumerations which is the source
 *                  data type in the file
 * @param len Number of elements of type @c data_type to read from the file
 * @retval 0 on success
 */
int
READ_TYPED_FUNC2(mat_t *mat, z_streamp z, READ_TYPE *data, enum matio_types data_type, int len)
{
    if ( mat == NULL || data == NULL || mat->fp == NULL )
        return MATIO_E_BAD_ARGUMENT;

    switch ( data_type ) {
        case MAT_T_DOUBLE:
            return READ_TYPE_DOUBLE_DATA(mat, z, data, len);
        case MAT_T_SINGLE:
            return READ_TYPE_SINGLE_DATA(mat, z, data, len);
#ifdef HAVE_MAT_INT64_T
        case MAT_T_INT64:
            return READ_TYPE_INT64_DATA(mat, z, data, len);
#endif /* HAVE_MAT_UINT64_T */
#ifdef HAVE_MAT_UINT64_T
        case MAT_T_UINT64:
            return READ_TYPE_UINT64_DATA(mat, z, data, len);
#endif /* HAVE_MAT_UINT64_T */
        case MAT_T_INT32:
            return READ_TYPE_INT32_DATA(mat, z, data, len);
        case MAT_T_UINT32:
            return READ_TYPE_UINT32_DATA(mat, z, data, len);
        case MAT_T_INT16:
            return READ_TYPE_INT16_DATA(mat, z, data, len);
        case MAT_T_UINT16:
            return READ_TYPE_UINT16_DATA(mat, z, data, len);
        case MAT_T_INT8:
            return READ_TYPE_INT8_DATA(mat, z, data, len);
        case MAT_T_UINT8:
            return READ_TYPE_UINT8_DATA(mat, z, data, len);
        default:
            break;
    }
    return MATIO_E_GENERIC_READ_ERROR;
}

#undef READ_TYPE_DOUBLE_DATA
#undef READ_TYPE_SINGLE_DATA
#undef READ_TYPE_INT32_DATA
#undef READ_TYPE_UINT32_DATA
#undef READ_TYPE_INT16_DATA
#undef READ_TYPE_UINT16_DATA
#undef READ_TYPE_INT8_DATA
#undef READ_TYPE_UINT8_DATA
#ifdef HAVE_MAT_INT64_T
#undef READ_TYPE_INT64_DATA
#endif /* HAVE_MAT_INT64_T */
#ifdef HAVE_MAT_UINT64_T
#undef READ_TYPE_UINT64_DATA
#endif /* HAVE_MAT_UINT64_T */

#endif

1	/*
2	* Copyright (c) 2015-2026, The matio contributors
3	* Copyright (c) 2019-2014, Christopher C. Hulbert
4	* All rights reserved.
5	*
6	* SPDX-License-Identifier: BSD-2-Clause
7	*/
8
9	#define READ_TYPE_DOUBLE_DATA CAT(READ_TYPED_FUNC1, Double)
10	#define READ_TYPE_SINGLE_DATA CAT(READ_TYPED_FUNC1, Single)
11	#define READ_TYPE_INT32_DATA CAT(READ_TYPED_FUNC1, Int32)
12	#define READ_TYPE_UINT32_DATA CAT(READ_TYPED_FUNC1, UInt32)
13	#define READ_TYPE_INT16_DATA CAT(READ_TYPED_FUNC1, Int16)
14	#define READ_TYPE_UINT16_DATA CAT(READ_TYPED_FUNC1, UInt16)
15	#define READ_TYPE_INT8_DATA CAT(READ_TYPED_FUNC1, Int8)
16	#define READ_TYPE_UINT8_DATA CAT(READ_TYPED_FUNC1, UInt8)
17	#ifdef HAVE_MAT_INT64_T
18	#define READ_TYPE_INT64_DATA CAT(READ_TYPED_FUNC1, Int64)
19	#endif /* HAVE_MAT_INT64_T */
20	#ifdef HAVE_MAT_UINT64_T
21	#define READ_TYPE_UINT64_DATA CAT(READ_TYPED_FUNC1, UInt64)
22	#endif /* HAVE_MAT_UINT64_T */
23
24	static int
25	READ_TYPE_DOUBLE_DATA(mat_t mat, READ_TYPE data, size_t len)	10,778✔
26	{
27	size_t readCount;	10,778✔
28	int err;	10,778✔
29	#if READ_TYPE_TYPE == READ_TYPE_DOUBLE
30	readCount = fread(data, sizeof(double), len, (FILE *)mat->fp);	10,286✔
31	if ( readCount != len ) {	10,286✔
32	return MATIO_E_GENERIC_READ_ERROR;
33	}
34	err = MATIO_E_NO_ERROR;	10,286✔
35	if ( mat->byteswap ) {	10,286✔
36	size_t i;
37	for ( i = 0; i < len; i++ ) {	605✔
38	(void)Mat_doubleSwap(data + i);	517✔
39	}
40	}
41	#else
42	size_t i;	492✔
43	const size_t data_size = sizeof(double);	492✔
44	double v[READ_BLOCK_SIZE / sizeof(double)];	492✔
45	READ_DATA(READ_TYPE, Mat_doubleSwap);	2,106✔
46	#endif
47	return err;	492✔
48	}
49		54✔
50	static int
51	READ_TYPE_SINGLE_DATA(mat_t mat, READ_TYPE data, size_t len)	54✔
52	{	54✔
53	size_t readCount;
54	int err;
55	#if READ_TYPE_TYPE == READ_TYPE_SINGLE
56	readCount = fread(data, sizeof(float), len, (FILE *)mat->fp);
57	if ( readCount != len ) {
58	return MATIO_E_GENERIC_READ_ERROR;
59	}
60	err = MATIO_E_NO_ERROR;
61	if ( mat->byteswap ) {
62	size_t i;
63	for ( i = 0; i < len; i++ ) {
64	(void)Mat_floatSwap(data + i);
65	}
66	}	54✔
67	#else	54✔
68	size_t i;	54✔
69	const size_t data_size = sizeof(float);	534✔
70	float v[READ_BLOCK_SIZE / sizeof(float)];
71	READ_DATA(READ_TYPE, Mat_floatSwap);	54✔
72	#endif
73	return err;	48✔
74	}
75		48✔
76	static int	48✔
77	READ_TYPE_INT32_DATA(mat_t mat, READ_TYPE data, size_t len)
78	{
79	size_t readCount;
80	int err;
81	#if READ_TYPE_TYPE == READ_TYPE_INT32
82	readCount = fread(data, sizeof(mat_int32_t), len, (FILE *)mat->fp);
83	if ( readCount != len ) {
84	return MATIO_E_GENERIC_READ_ERROR;
85	}
86	err = MATIO_E_NO_ERROR;
87	if ( mat->byteswap ) {
88	size_t i;
89	for ( i = 0; i < len; i++ ) {
90	(void)Mat_int32Swap(data + i);	48✔
91	}	48✔
92	}	48✔
93	#else	96✔
94	size_t i;
95	const size_t data_size = sizeof(mat_int32_t);	48✔
96	mat_int32_t v[READ_BLOCK_SIZE / sizeof(mat_int32_t)];
97	READ_DATA(READ_TYPE, Mat_int32Swap);	48✔
98	#endif
99	return err;	48✔
100	}	48✔
101
102	static int
103	READ_TYPE_UINT32_DATA(mat_t mat, READ_TYPE data, size_t len)
104	{
105	size_t readCount;
106	int err;
107	#if READ_TYPE_TYPE == READ_TYPE_UINT32
108	readCount = fread(data, sizeof(mat_uint32_t), len, (FILE *)mat->fp);
109	if ( readCount != len ) {
110	return MATIO_E_GENERIC_READ_ERROR;
111	}
112	err = MATIO_E_NO_ERROR;
113	if ( mat->byteswap ) {
114	size_t i;	48✔
115	for ( i = 0; i < len; i++ ) {	48✔
116	(void)Mat_uint32Swap(data + i);	48✔
117	}	96✔
118	}
119	#else	48✔
120	size_t i;
121	const size_t data_size = sizeof(mat_uint32_t);	48✔
122	mat_uint32_t v[READ_BLOCK_SIZE / sizeof(mat_uint32_t)];
123	READ_DATA(READ_TYPE, Mat_uint32Swap);	48✔
124	#endif	48✔
125	return err;
126	}
127
128	static int
129	READ_TYPE_INT16_DATA(mat_t mat, READ_TYPE data, size_t len)
130	{
131	size_t readCount;
132	int err;
133	#if READ_TYPE_TYPE == READ_TYPE_INT16
134	readCount = fread(data, sizeof(mat_int16_t), len, (FILE *)mat->fp);
135	if ( readCount != len ) {
136	return MATIO_E_GENERIC_READ_ERROR;
137	}
138	err = MATIO_E_NO_ERROR;	48✔
139	if ( mat->byteswap ) {	48✔
140	size_t i;	48✔
141	for ( i = 0; i < len; i++ ) {	96✔
142	(void)Mat_int16Swap(data + i);
143	}	48✔
144	}
145	#else	102✔
146	size_t i;
147	const size_t data_size = sizeof(mat_int16_t);	102✔
148	mat_int16_t v[READ_BLOCK_SIZE / sizeof(mat_int16_t)];	102✔
149	READ_DATA(READ_TYPE, Mat_int16Swap);
150	#endif
151	return err;
152	}
153
154	static int
155	READ_TYPE_UINT16_DATA(mat_t mat, READ_TYPE data, size_t len)
156	{
157	size_t readCount;
158	int err;
159	#if READ_TYPE_TYPE == READ_TYPE_UINT16
160	readCount = fread(data, sizeof(mat_uint16_t), len, (FILE *)mat->fp);
161	if ( readCount != len ) {
162	return MATIO_E_GENERIC_READ_ERROR;	102✔
163	}	102✔
164	err = MATIO_E_NO_ERROR;	102✔
165	if ( mat->byteswap ) {	900✔
166	size_t i;
167	for ( i = 0; i < len; i++ ) {	102✔
168	(void)Mat_uint16Swap(data + i);
169	}	48✔
170	}
171	#else	48✔
172	size_t i;	48✔
173	const size_t data_size = sizeof(mat_uint16_t);
174	mat_uint16_t v[READ_BLOCK_SIZE / sizeof(mat_uint16_t)];
175	READ_DATA(READ_TYPE, Mat_uint16Swap);
176	#endif
177	return err;
178	}
179
180	static int
181	READ_TYPE_INT8_DATA(mat_t mat, READ_TYPE data, size_t len)
182	{
183	size_t readCount;
184	int err;
185	#if READ_TYPE_TYPE == READ_TYPE_INT8
186	readCount = fread(data, sizeof(mat_int8_t), len, (FILE *)mat->fp);	48✔
187	if ( readCount != len ) {	48✔
188	return MATIO_E_GENERIC_READ_ERROR;	48✔
189	}	96✔
190	err = MATIO_E_NO_ERROR;
191	#else	48✔
192	size_t i;
193	const size_t data_size = sizeof(mat_int8_t);	48✔
194	mat_int8_t v[READ_BLOCK_SIZE / sizeof(mat_int8_t)];
195	READ_DATA_NOSWAP(READ_TYPE);	48✔
196	#endif	48✔
197	return err;
198	}
199
200	static int
201	READ_TYPE_UINT8_DATA(mat_t mat, READ_TYPE data, size_t len)
202	{
203	size_t readCount;
204	int err;
205	#if READ_TYPE_TYPE == READ_TYPE_UINT8
206	readCount = fread(data, sizeof(mat_uint8_t), len, (FILE *)mat->fp);
207	if ( readCount != len ) {
208	return MATIO_E_GENERIC_READ_ERROR;
209	}
210	err = MATIO_E_NO_ERROR;	48✔
211	#else	48✔
212	size_t i;	48✔
213	const size_t data_size = sizeof(mat_uint8_t);	96✔
214	mat_uint8_t v[READ_BLOCK_SIZE / sizeof(mat_uint8_t)];
215	READ_DATA_NOSWAP(READ_TYPE);	48✔
216	#endif
217	return err;	48✔
218	}
219		48✔
220	#ifdef HAVE_MAT_INT64_T	48✔
221	static int
222	READ_TYPE_INT64_DATA(mat_t mat, READ_TYPE data, size_t len)
223	{
224	size_t readCount;
225	int err;
226	#if READ_TYPE_TYPE == READ_TYPE_INT64
227	readCount = fread(data, sizeof(mat_int64_t), len, (FILE *)mat->fp);
228	if ( readCount != len ) {
229	return MATIO_E_GENERIC_READ_ERROR;
230	}
231	err = MATIO_E_NO_ERROR;
232	if ( mat->byteswap ) {
233	size_t i;
234	for ( i = 0; i < len; i++ ) {	48✔
235	(void)Mat_int64Swap(data + i);	48✔
236	}	48✔
237	}	96✔
238	#else
239	size_t i;	48✔
240	const size_t data_size = sizeof(mat_int64_t);
241	mat_int64_t v[READ_BLOCK_SIZE / sizeof(mat_int64_t)];	48✔
242	READ_DATA(READ_TYPE, Mat_int64Swap);
243	#endif	48✔
244	return err;	48✔
245	}
246	#endif /* HAVE_MAT_INT64_T */
247
248	#ifdef HAVE_MAT_UINT64_T
249	static int
250	READ_TYPE_UINT64_DATA(mat_t mat, READ_TYPE data, size_t len)
251	{
252	size_t readCount;
253	int err;
254	#if READ_TYPE_TYPE == READ_TYPE_UINT64
255	readCount = fread(data, sizeof(mat_uint64_t), len, (FILE *)mat->fp);
256	if ( readCount != len ) {
257	return MATIO_E_GENERIC_READ_ERROR;
258	}	48✔
259	err = MATIO_E_NO_ERROR;	48✔
260	if ( mat->byteswap ) {	48✔
261	size_t i;	96✔
262	for ( i = 0; i < len; i++ ) {
263	(void)Mat_uint64Swap(data + i);	48✔
264	}
265	}	10,286✔
266	#else
267	size_t i;	10,286✔
268	const size_t data_size = sizeof(mat_uint64_t);	10,286✔
269	mat_uint64_t v[READ_BLOCK_SIZE / sizeof(mat_uint64_t)];
270	READ_DATA(READ_TYPE, Mat_uint64Swap);	10,286✔
271	#endif	10,286✔
272	return err;
273	}
274	#endif /* HAVE_MAT_UINT64_T */	10,286✔
275		10,286✔
276	/** @brief Reads data of type @c data_type into a READ_TYPE type
277	*	605✔
278	* Reads from the MAT file @c len elements of data type @c data_type storing	517✔
279	* them as READ_TYPE's in @c data.
280	* @ingroup mat_internal
281	* @param mat MAT file pointer
282	* @param data Pointer to store the output values (len*sizeof(READ_TYPE))
283	* @param data_type one of the @c matio_types enumerations which is the source
284	* data type in the file
285	* @param len Number of elements of type @c data_type to read from the file
286	* @retval 0 on success
287	*/
288	int
289	READ_TYPED_FUNC1(mat_t mat, READ_TYPE data, enum matio_types data_type, size_t len)
290	{
291	if ( mat == NULL \|\| data == NULL \|\| mat->fp == NULL )	4,014✔
292	return MATIO_E_BAD_ARGUMENT;
293		4,014✔
294	switch ( data_type ) {	4,014✔
295	case MAT_T_DOUBLE:
296	return READ_TYPE_DOUBLE_DATA(mat, data, len);	3,147✔
297	case MAT_T_SINGLE:	3,147✔
298	return READ_TYPE_SINGLE_DATA(mat, data, len);
299	#ifdef HAVE_MAT_INT64_T
300	case MAT_T_INT64:	3,147✔
301	return READ_TYPE_INT64_DATA(mat, data, len);	3,147✔
302	#endif /* HAVE_MAT_UINT64_T */
303	#ifdef HAVE_MAT_UINT64_T	1,488✔
304	case MAT_T_UINT64:	888✔
305	return READ_TYPE_UINT64_DATA(mat, data, len);
306	#endif /* HAVE_MAT_UINT64_T */
307	case MAT_T_INT32:
308	return READ_TYPE_INT32_DATA(mat, data, len);	867✔
309	case MAT_T_UINT32:	867✔
310	return READ_TYPE_UINT32_DATA(mat, data, len);	867✔
311	case MAT_T_INT16:	1,881✔
312	return READ_TYPE_INT16_DATA(mat, data, len);
313	case MAT_T_UINT16:	867✔
314	return READ_TYPE_UINT16_DATA(mat, data, len);
315	case MAT_T_INT8:	96✔
316	return READ_TYPE_INT8_DATA(mat, data, len);
317	case MAT_T_UINT8:	96✔
318	return READ_TYPE_UINT8_DATA(mat, data, len);	96✔
319	default:
320	break;
321	}
322	return MATIO_E_GENERIC_READ_ERROR;
323	}
324
325	#undef READ_TYPE_DOUBLE_DATA
326	#undef READ_TYPE_SINGLE_DATA
327	#undef READ_TYPE_INT32_DATA
328	#undef READ_TYPE_UINT32_DATA
329	#undef READ_TYPE_INT16_DATA
330	#undef READ_TYPE_UINT16_DATA
331	#undef READ_TYPE_INT8_DATA
332	#undef READ_TYPE_UINT8_DATA	96✔
333	#ifdef HAVE_MAT_INT64_T	96✔
334	#undef READ_TYPE_INT64_DATA	96✔
335	#endif /* HAVE_MAT_INT64_T */	192✔
336	#ifdef HAVE_MAT_UINT64_T
337	#undef READ_TYPE_UINT64_DATA	96✔
338	#endif /* HAVE_MAT_UINT64_T */
339		96✔
340	#if HAVE_ZLIB
341		96✔
342	#define READ_TYPE_DOUBLE_DATA CAT(READ_TYPED_FUNC2, Double)	96✔
343	#define READ_TYPE_SINGLE_DATA CAT(READ_TYPED_FUNC2, Single)
344	#define READ_TYPE_INT32_DATA CAT(READ_TYPED_FUNC2, Int32)
345	#define READ_TYPE_UINT32_DATA CAT(READ_TYPED_FUNC2, UInt32)
346	#define READ_TYPE_INT16_DATA CAT(READ_TYPED_FUNC2, Int16)
347	#define READ_TYPE_UINT16_DATA CAT(READ_TYPED_FUNC2, UInt16)
348	#define READ_TYPE_INT8_DATA CAT(READ_TYPED_FUNC2, Int8)
349	#define READ_TYPE_UINT8_DATA CAT(READ_TYPED_FUNC2, UInt8)
350	#ifdef HAVE_MAT_INT64_T
351	#define READ_TYPE_INT64_DATA CAT(READ_TYPED_FUNC2, Int64)
352	#endif /* HAVE_MAT_INT64_T */
353	#ifdef HAVE_MAT_UINT64_T
354	#define READ_TYPE_UINT64_DATA CAT(READ_TYPED_FUNC2, UInt64)
355	#endif /* HAVE_MAT_UINT64_T */
356		96✔
357	static int	96✔
358	READ_TYPE_DOUBLE_DATA(mat_t mat, z_streamp z, READ_TYPE data, mat_uint32_t len)	96✔
359	{	192✔
360	int err;
361	#if READ_TYPE_TYPE == READ_TYPE_DOUBLE	96✔
362	err = InflateData(mat, z, data, len * sizeof(double));
363	if ( err ) {	96✔
364	return err;
365	}	96✔
366	if ( mat->byteswap ) {	96✔
367	mat_uint32_t i;
368	for ( i = 0; i < len; i++ ) {
369	(void)Mat_doubleSwap(data + i);
370	}
371	}
372	#else
373	mat_uint32_t i;
374	const size_t data_size = sizeof(double);
375	double v[READ_BLOCK_SIZE / sizeof(double)];
376	READ_COMPRESSED_DATA(READ_TYPE, Mat_doubleSwap);
377	#endif
378	return err;
379	}
380		96✔
381	static int	96✔
382	READ_TYPE_SINGLE_DATA(mat_t mat, z_streamp z, READ_TYPE data, mat_uint32_t len)	96✔
383	{	192✔
384	int err;
385	#if READ_TYPE_TYPE == READ_TYPE_SINGLE	96✔
386	err = InflateData(mat, z, data, len * sizeof(float));
387	if ( err ) {	96✔
388	return err;
389	}	96✔
390	if ( mat->byteswap ) {	96✔
391	mat_uint32_t i;
392	for ( i = 0; i < len; i++ ) {
393	(void)Mat_floatSwap(data + i);
394	}
395	}
396	#else
397	mat_uint32_t i;
398	const size_t data_size = sizeof(float);
399	float v[READ_BLOCK_SIZE / sizeof(float)];
400	READ_COMPRESSED_DATA(READ_TYPE, Mat_floatSwap);
401	#endif
402	return err;
403	}
404		96✔
405	#ifdef HAVE_MAT_INT64_T	96✔
406	static int	96✔
407	READ_TYPE_INT64_DATA(mat_t mat, z_streamp z, READ_TYPE data, mat_uint32_t len)	192✔
408	{
409	int err;	96✔
410	#if READ_TYPE_TYPE == READ_TYPE_INT64
411	err = InflateData(mat, z, data, len * sizeof(mat_int64_t));	96✔
412	if ( err ) {
413	return err;	96✔
414	}	96✔
415	if ( mat->byteswap ) {
416	mat_uint32_t i;
417	for ( i = 0; i < len; i++ ) {
418	(void)Mat_int64Swap(data + i);
419	}
420	}
421	#else
422	mat_uint32_t i;
423	const size_t data_size = sizeof(mat_int64_t);
424	mat_int64_t v[READ_BLOCK_SIZE / sizeof(mat_int64_t)];
425	READ_COMPRESSED_DATA(READ_TYPE, Mat_int64Swap);
426	#endif
427	return err;
428	}	96✔
429	#endif /* HAVE_MAT_INT64_T */	96✔
430		96✔
431	#ifdef HAVE_MAT_UINT64_T	192✔
432	static int
433	READ_TYPE_UINT64_DATA(mat_t mat, z_streamp z, READ_TYPE data, mat_uint32_t len)	96✔
434	{
435	int err;	96✔
436	#if READ_TYPE_TYPE == READ_TYPE_UINT64
437	err = InflateData(mat, z, data, len * sizeof(mat_uint64_t));	96✔
438	if ( err ) {	96✔
439	return err;
440	}
441	if ( mat->byteswap ) {
442	mat_uint32_t i;
443	for ( i = 0; i < len; i++ ) {
444	(void)Mat_uint64Swap(data + i);
445	}
446	}
447	#else
448	mat_uint32_t i;
449	const size_t data_size = sizeof(mat_uint64_t);
450	mat_uint64_t v[READ_BLOCK_SIZE / sizeof(mat_uint64_t)];
451	READ_COMPRESSED_DATA(READ_TYPE, Mat_uint64Swap);
452	#endif	96✔
453	return err;	96✔
454	}	96✔
455	#endif /* HAVE_MAT_UINT64_T */	192✔
456
457	static int	96✔
458	READ_TYPE_INT32_DATA(mat_t mat, z_streamp z, READ_TYPE data, mat_uint32_t len)
459	{	96✔
460	int err;
461	#if READ_TYPE_TYPE == READ_TYPE_INT32	96✔
462	err = InflateData(mat, z, data, len * sizeof(mat_int32_t));	96✔
463	if ( err ) {
464	return err;
465	}
466	if ( mat->byteswap ) {
467	mat_uint32_t i;
468	for ( i = 0; i < len; i++ ) {
469	(void)Mat_int32Swap(data + i);
470	}
471	}
472	#else
473	mat_uint32_t i;
474	const size_t data_size = sizeof(mat_int32_t);
475	mat_int32_t v[READ_BLOCK_SIZE / sizeof(mat_int32_t)];
476	READ_COMPRESSED_DATA(READ_TYPE, Mat_int32Swap);	96✔
477	#endif	96✔
478	return err;	96✔
479	}	192✔
480
481	static int	96✔
482	READ_TYPE_UINT32_DATA(mat_t mat, z_streamp z, READ_TYPE data, mat_uint32_t len)
483	{	96✔
484	int err;
485	#if READ_TYPE_TYPE == READ_TYPE_UINT32	96✔
486	err = InflateData(mat, z, data, len * sizeof(mat_uint32_t));	96✔
487	if ( err ) {
488	return err;
489	}
490	if ( mat->byteswap ) {
491	mat_uint32_t i;
492	for ( i = 0; i < len; i++ ) {
493	(void)Mat_uint32Swap(data + i);
494	}
495	}
496	#else
497	mat_uint32_t i;
498	const size_t data_size = sizeof(mat_uint32_t);
499	mat_uint32_t v[READ_BLOCK_SIZE / sizeof(mat_uint32_t)];
500	READ_COMPRESSED_DATA(READ_TYPE, Mat_uint32Swap);	96✔
501	#endif	96✔
502	return err;	96✔
503	}	192✔
504
505	static int	96✔
506	READ_TYPE_INT16_DATA(mat_t mat, z_streamp z, READ_TYPE data, mat_uint32_t len)
507	{	3,147✔
508	int err;
509	#if READ_TYPE_TYPE == READ_TYPE_INT16	3,147✔
510	err = InflateData(mat, z, data, len * sizeof(mat_int16_t));	3,147✔
511	if ( err ) {
512	return err;	3,147✔
513	}	3,147✔
514	if ( mat->byteswap ) {
515	mat_uint32_t i;
516	for ( i = 0; i < len; i++ ) {	3,147✔
517	(void)Mat_int16Swap(data + i);	3,147✔
518	}
519	}	1,488✔
520	#else	888✔
521	mat_uint32_t i;
522	const size_t data_size = sizeof(mat_int16_t);
523	mat_int16_t v[READ_BLOCK_SIZE / sizeof(mat_int16_t)];
524	READ_COMPRESSED_DATA(READ_TYPE, Mat_int16Swap);
525	#endif
526	return err;
527	}
528
529	static int
530	READ_TYPE_UINT16_DATA(mat_t mat, z_streamp z, READ_TYPE data, mat_uint32_t len)
531	{	99✔
532	int err;
533	#if READ_TYPE_TYPE == READ_TYPE_UINT16	99✔
534	err = InflateData(mat, z, data, len * sizeof(mat_uint16_t));	99✔
535	if ( err ) {
536	return err;
537	}
538	if ( mat->byteswap ) {
539	mat_uint32_t i;
540	for ( i = 0; i < len; i++ ) {
541	(void)Mat_uint16Swap(data + i);
542	}
543	}
544	#else
545	mat_uint32_t i;
546	const size_t data_size = sizeof(mat_uint16_t);
547	mat_uint16_t v[READ_BLOCK_SIZE / sizeof(mat_uint16_t)];
548	READ_COMPRESSED_DATA(READ_TYPE, Mat_uint16Swap);	99✔
549	#endif	99✔
550	return err;	99✔
551	}	345✔
552
553	static int	99✔
554	READ_TYPE_INT8_DATA(mat_t mat, z_streamp z, READ_TYPE data, mat_uint32_t len)
555	{
556	int err;
557	#if READ_TYPE_TYPE == READ_TYPE_INT8	4,740✔
558	err = InflateData(mat, z, data, len * sizeof(mat_int8_t));
559	#else	4,740✔
560	mat_uint32_t i;	4,740✔
561	const size_t data_size = sizeof(mat_int8_t);
562	mat_int8_t v[READ_BLOCK_SIZE / sizeof(mat_int8_t)];	3,429✔
563	READ_COMPRESSED_DATA_NOSWAP(READ_TYPE);	3,429✔
564	#endif
565	return err;
566	}	3,429✔
567		3,429✔
568	static int
569	READ_TYPE_UINT8_DATA(mat_t mat, z_streamp z, READ_TYPE data, mat_uint32_t len)	1,488✔
570	{	888✔
571	int err;
572	#if READ_TYPE_TYPE == READ_TYPE_UINT8
573	err = InflateData(mat, z, data, len * sizeof(mat_uint8_t));
574	#else	1,311✔
575	mat_uint32_t i;	1,311✔
576	const size_t data_size = sizeof(mat_uint8_t);	1,311✔
577	mat_uint8_t v[READ_BLOCK_SIZE / sizeof(mat_uint8_t)];	69,271✔
578	READ_COMPRESSED_DATA_NOSWAP(READ_TYPE);
579	#endif	1,311✔
580	return err;
581	}	96✔
582
583	/** @brief Reads data of type @c data_type into a READ_TYPE type	96✔
584	*	96✔
585	* Reads from the MAT file @c len compressed elements of data type @c data_type
586	* storing them as READ_TYPE's in @c data.
587	* @ingroup mat_internal
588	* @param mat MAT file pointer
589	* @param z Pointer to the zlib stream for inflation
590	* @param data Pointer to store the output values (len*sizeof(READ_TYPE))
591	* @param data_type one of the @c matio_types enumerations which is the source
592	* data type in the file
593	* @param len Number of elements of type @c data_type to read from the file
594	* @retval 0 on success
595	*/
596	int
597	READ_TYPED_FUNC2(mat_t mat, z_streamp z, READ_TYPE data, enum matio_types data_type, int len)
598	{	96✔
599	if ( mat == NULL \|\| data == NULL \|\| mat->fp == NULL )	96✔
600	return MATIO_E_BAD_ARGUMENT;	96✔
601		192✔
602	switch ( data_type ) {
603	case MAT_T_DOUBLE:	96✔
604	return READ_TYPE_DOUBLE_DATA(mat, z, data, len);
605	case MAT_T_SINGLE:	96✔
606	return READ_TYPE_SINGLE_DATA(mat, z, data, len);
607	#ifdef HAVE_MAT_INT64_T	96✔
608	case MAT_T_INT64:	96✔
609	return READ_TYPE_INT64_DATA(mat, z, data, len);
610	#endif /* HAVE_MAT_UINT64_T */
611	#ifdef HAVE_MAT_UINT64_T
612	case MAT_T_UINT64:
613	return READ_TYPE_UINT64_DATA(mat, z, data, len);
614	#endif /* HAVE_MAT_UINT64_T */
615	case MAT_T_INT32:
616	return READ_TYPE_INT32_DATA(mat, z, data, len);
617	case MAT_T_UINT32:
618	return READ_TYPE_UINT32_DATA(mat, z, data, len);
619	case MAT_T_INT16:
620	return READ_TYPE_INT16_DATA(mat, z, data, len);
621	case MAT_T_UINT16:
622	return READ_TYPE_UINT16_DATA(mat, z, data, len);	96✔
623	case MAT_T_INT8:	96✔
624	return READ_TYPE_INT8_DATA(mat, z, data, len);	96✔
625	case MAT_T_UINT8:	192✔
626	return READ_TYPE_UINT8_DATA(mat, z, data, len);
627	default:	96✔
628	break;
629	}	96✔
630	return MATIO_E_GENERIC_READ_ERROR;
631	}	96✔
632		96✔
633	#undef READ_TYPE_DOUBLE_DATA
634	#undef READ_TYPE_SINGLE_DATA
635	#undef READ_TYPE_INT32_DATA
636	#undef READ_TYPE_UINT32_DATA
637	#undef READ_TYPE_INT16_DATA
638	#undef READ_TYPE_UINT16_DATA
639	#undef READ_TYPE_INT8_DATA
640	#undef READ_TYPE_UINT8_DATA
641	#ifdef HAVE_MAT_INT64_T
642	#undef READ_TYPE_INT64_DATA
643	#endif /* HAVE_MAT_INT64_T */
644	#ifdef HAVE_MAT_UINT64_T
645	#undef READ_TYPE_UINT64_DATA
646	#endif /* HAVE_MAT_UINT64_T */	96✔
647		96✔
648	#endif	96✔

tbeu / matio / #1062

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous