mirror/netcdf-c
2
0
Fork 0
mirror of https://github.com/Unidata/netcdf-c.git synced 2024-11-27 07:30:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2808 from ZedThree/explicit-casts-in-nc4var

Browse Source 
Use explicit casts in `nc4_convert_type` to silence warnings
This commit is contained in:
Ward Fisher 2023-12-22 11:29:13 -07:00 committed by GitHub
commit 6e636ef465
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 69 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
libsrc4/nc4var.c
View File

@ -659,7 +659,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*bp < 0)
(*range_error)++;
*ubp++ = *bp++;
*ubp++ = (unsigned char)*bp++;
}
break;
case NC_SHORT:
@ -671,7 +671,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*bp < 0)
(*range_error)++;
*usp++ = *bp++;
*usp++ = (unsigned short)*bp++;
}
break;
case NC_INT:
@ -683,7 +683,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*bp < 0)
(*range_error)++;
*uip++ = *bp++;
*uip++ = (unsigned int)*bp++;
}
break;
case NC_INT64:
@ -695,7 +695,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*bp < 0)
(*range_error)++;
*ulip++ = *bp++;
*ulip++ = (unsigned long long)*bp++;
}
break;
case NC_FLOAT:
@ -721,7 +721,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (!strict_nc3 && *ubp > X_SCHAR_MAX)
(*range_error)++;
*bp++ = *ubp++;
*bp++ = (signed char)*ubp++;
}
break;
case NC_SHORT:
@ -775,7 +775,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*sp > X_UCHAR_MAX || *sp < 0)
(*range_error)++;
*ubp++ = *sp++;
*ubp++ = (unsigned char)*sp++;
}
break;
case NC_BYTE:
@ -783,7 +783,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*sp > X_SCHAR_MAX || *sp < X_SCHAR_MIN)
(*range_error)++;
*bp++ = *sp++;
*bp++ = (signed char)*sp++;
}
break;
case NC_SHORT:
@ -795,7 +795,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*sp < 0)
(*range_error)++;
*usp++ = *sp++;
*usp++ = (unsigned short)*sp++;
}
break;
case NC_INT:
@ -807,7 +807,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*sp < 0)
(*range_error)++;
*uip++ = *sp++;
*uip++ = (unsigned int)*sp++;
}
break;
case NC_INT64:
@ -819,7 +819,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*sp < 0)
(*range_error)++;
*ulip++ = *sp++;
*ulip++ = (unsigned long long)*sp++;
}
break;
case NC_FLOAT:
@ -845,7 +845,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*usp > X_UCHAR_MAX)
(*range_error)++;
*ubp++ = *usp++;
*ubp++ = (unsigned char)*usp++;
}
break;
case NC_BYTE:
@ -853,7 +853,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*usp > X_SCHAR_MAX)
(*range_error)++;
*bp++ = *usp++;
*bp++ = (signed char)*usp++;
}
break;
case NC_SHORT:
@ -861,7 +861,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*usp > X_SHORT_MAX)
(*range_error)++;
*sp++ = *usp++;
*sp++ = (signed short)*usp++;
}
break;
case NC_USHORT:
@ -907,7 +907,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ip > X_UCHAR_MAX || *ip < 0)
(*range_error)++;
*ubp++ = *ip++;
*ubp++ = (unsigned char)*ip++;
}
break;
case NC_BYTE:
@ -915,7 +915,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ip > X_SCHAR_MAX || *ip < X_SCHAR_MIN)
(*range_error)++;
*bp++ = *ip++;
*bp++ = (signed char)*ip++;
}
break;
case NC_SHORT:
@ -923,7 +923,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ip > X_SHORT_MAX || *ip < X_SHORT_MIN)
(*range_error)++;
*sp++ = *ip++;
*sp++ = (short)*ip++;
}
break;
case NC_USHORT:
@ -931,7 +931,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ip > X_USHORT_MAX || *ip < 0)
(*range_error)++;
*usp++ = *ip++;
*usp++ = (unsigned short)*ip++;
}
break;
case NC_INT: /* src is int */
@ -947,7 +947,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ip > X_UINT_MAX || *ip < 0)
(*range_error)++;
*uip++ = *ip++;
*uip++ = (unsigned int)*ip++;
}
break;
case NC_INT64:
@ -959,16 +959,16 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ip < 0)
(*range_error)++;
*ulip++ = *ip++;
*ulip++ = (unsigned long long)*ip++;
}
break;
case NC_FLOAT:
for (ip = (int *)src, fp = dest; count < len; count++)
*fp++ = *ip++;
*fp++ = (float)*ip++;
break;
case NC_DOUBLE:
for (ip = (int *)src, dp = dest; count < len; count++)
*dp++ = *ip++;
*dp++ = (double)*ip++;
break;
default:
LOG((0, "%s: unexpected dest type. src_type %d, dest_type %d",
@ -985,7 +985,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*uip > X_UCHAR_MAX)
(*range_error)++;
*ubp++ = *uip++;
*ubp++ = (unsigned char)*uip++;
}
break;
case NC_BYTE:
@ -993,7 +993,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*uip > X_SCHAR_MAX)
(*range_error)++;
*bp++ = *uip++;
*bp++ = (signed char)*uip++;
}
break;
case NC_SHORT:
@ -1001,7 +1001,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*uip > X_SHORT_MAX)
(*range_error)++;
*sp++ = *uip++;
*sp++ = (signed short)*uip++;
}
break;
case NC_USHORT:
@ -1009,7 +1009,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*uip > X_USHORT_MAX)
(*range_error)++;
*usp++ = *uip++;
*usp++ = (unsigned short)*uip++;
}
break;
case NC_INT:
@ -1017,7 +1017,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*uip > X_INT_MAX)
(*range_error)++;
*ip++ = *uip++;
*ip++ = (int)*uip++;
}
break;
case NC_UINT:
@ -1038,7 +1038,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
break;
case NC_FLOAT:
for (uip = (unsigned int *)src, fp = dest; count < len; count++)
*fp++ = *uip++;
*fp++ = (float)*uip++;
break;
case NC_DOUBLE:
for (uip = (unsigned int *)src, dp = dest; count < len; count++)
@ -1059,7 +1059,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*lip > X_UCHAR_MAX || *lip < 0)
(*range_error)++;
*ubp++ = *lip++;
*ubp++ = (unsigned char)*lip++;
}
break;
case NC_BYTE:
@ -1067,7 +1067,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*lip > X_SCHAR_MAX || *lip < X_SCHAR_MIN)
(*range_error)++;
*bp++ = *lip++;
*bp++ = (signed char)*lip++;
}
break;
case NC_SHORT:
@ -1075,7 +1075,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*lip > X_SHORT_MAX || *lip < X_SHORT_MIN)
(*range_error)++;
*sp++ = *lip++;
*sp++ = (short)*lip++;
}
break;
case NC_USHORT:
@ -1083,7 +1083,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*lip > X_USHORT_MAX || *lip < 0)
(*range_error)++;
*usp++ = *lip++;
*usp++ = (unsigned short)*lip++;
}
break;
case NC_UINT:
@ -1091,7 +1091,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*lip > X_UINT_MAX || *lip < 0)
(*range_error)++;
*uip++ = *lip++;
*uip++ = (unsigned int)*lip++;
}
break;
case NC_INT:
@ -1099,7 +1099,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*lip > X_INT_MAX || *lip < X_INT_MIN)
(*range_error)++;
*ip++ = *lip++;
*ip++ = (int)*lip++;
}
break;
case NC_INT64:
@ -1111,16 +1111,16 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*lip < 0)
(*range_error)++;
*ulip++ = *lip++;
*ulip++ = (unsigned long long)*lip++;
}
break;
case NC_FLOAT:
for (lip = (long long *)src, fp = dest; count < len; count++)
*fp++ = *lip++;
*fp++ = (float)*lip++;
break;
case NC_DOUBLE:
for (lip = (long long *)src, dp = dest; count < len; count++)
*dp++ = *lip++;
*dp++ = (double)*lip++;
break;
default:
LOG((0, "%s: unexpected dest type. src_type %d, dest_type %d",
@ -1137,7 +1137,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ulip > X_UCHAR_MAX)
(*range_error)++;
*ubp++ = *ulip++;
*ubp++ = (unsigned char)*ulip++;
}
break;
case NC_BYTE:
@ -1145,7 +1145,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ulip > X_SCHAR_MAX)
(*range_error)++;
*bp++ = *ulip++;
*bp++ = (signed char)*ulip++;
}
break;
case NC_SHORT:
@ -1153,7 +1153,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ulip > X_SHORT_MAX)
(*range_error)++;
*sp++ = *ulip++;
*sp++ = (short)*ulip++;
}
break;
case NC_USHORT:
@ -1161,7 +1161,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ulip > X_USHORT_MAX)
(*range_error)++;
*usp++ = *ulip++;
*usp++ = (unsigned short)*ulip++;
}
break;
case NC_UINT:
@ -1169,7 +1169,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ulip > X_UINT_MAX)
(*range_error)++;
*uip++ = *ulip++;
*uip++ = (unsigned int)*ulip++;
}
break;
case NC_INT:
@ -1177,7 +1177,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ulip > X_INT_MAX)
(*range_error)++;
*ip++ = *ulip++;
*ip++ = (int)*ulip++;
}
break;
case NC_INT64:
@ -1185,7 +1185,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*ulip > X_INT64_MAX)
(*range_error)++;
*lip++ = *ulip++;
*lip++ = (long long)*ulip++;
}
break;
case NC_UINT64:
@ -1194,11 +1194,11 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
break;
case NC_FLOAT:
for (ulip = (unsigned long long *)src, fp = dest; count < len; count++)
*fp++ = *ulip++;
*fp++ = (float)*ulip++;
break;
case NC_DOUBLE:
for (ulip = (unsigned long long *)src, dp = dest; count < len; count++)
*dp++ = *ulip++;
*dp++ = (double)*ulip++;
break;
default:
LOG((0, "%s: unexpected dest type. src_type %d, dest_type %d",
@ -1215,7 +1215,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*fp > X_UCHAR_MAX || *fp < 0)
(*range_error)++;
*ubp++ = *fp++;
*ubp++ = (unsigned char)*fp++;
}
break;
case NC_BYTE:
@ -1223,7 +1223,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*fp > (double)X_SCHAR_MAX || *fp < (double)X_SCHAR_MIN)
(*range_error)++;
*bp++ = *fp++;
*bp++ = (signed char)*fp++;
}
break;
case NC_SHORT:
@ -1231,7 +1231,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*fp > (double)X_SHORT_MAX || *fp < (double)X_SHORT_MIN)
(*range_error)++;
*sp++ = *fp++;
*sp++ = (short)*fp++;
}
break;
case NC_USHORT:
@ -1239,15 +1239,15 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*fp > X_USHORT_MAX || *fp < 0)
(*range_error)++;
*usp++ = *fp++;
*usp++ = (unsigned short)*fp++;
}
break;
case NC_UINT:
for (fp = (float *)src, uip = dest; count < len; count++)
{
if (*fp > X_UINT_MAX || *fp < 0)
if (*fp > (float)X_UINT_MAX || *fp < 0)
(*range_error)++;
*uip++ = *fp++;
*uip++ = (unsigned int)*fp++;
}
break;
case NC_INT:
@ -1255,23 +1255,23 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*fp > (double)X_INT_MAX || *fp < (double)X_INT_MIN)
(*range_error)++;
*ip++ = *fp++;
*ip++ = (int)*fp++;
}
break;
case NC_INT64:
for (fp = (float *)src, lip = dest; count < len; count++)
{
if (*fp > X_INT64_MAX || *fp <X_INT64_MIN)
if (*fp > (float)X_INT64_MAX || *fp <X_INT64_MIN)
(*range_error)++;
*lip++ = *fp++;
*lip++ = (long long)*fp++;
}
break;
case NC_UINT64:
for (fp = (float *)src, lip = dest; count < len; count++)
for (fp = (float *)src, ulip = dest; count < len; count++)
{
if (*fp > X_UINT64_MAX || *fp < 0)
if (*fp > (float)X_UINT64_MAX || *fp < 0)
(*range_error)++;
*lip++ = *fp++;
*ulip++ = (unsigned long long)*fp++;
}
break;
case NC_FLOAT:
@ -1297,7 +1297,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*dp > X_UCHAR_MAX || *dp < 0)
(*range_error)++;
*ubp++ = *dp++;
*ubp++ = (unsigned char)*dp++;
}
break;
case NC_BYTE:
@ -1305,7 +1305,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*dp > X_SCHAR_MAX || *dp < X_SCHAR_MIN)
(*range_error)++;
*bp++ = *dp++;
*bp++ = (signed char)*dp++;
}
break;
case NC_SHORT:
@ -1313,7 +1313,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*dp > X_SHORT_MAX || *dp < X_SHORT_MIN)
(*range_error)++;
*sp++ = *dp++;
*sp++ = (short)*dp++;
}
break;
case NC_USHORT:
@ -1321,7 +1321,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*dp > X_USHORT_MAX || *dp < 0)
(*range_error)++;
*usp++ = *dp++;
*usp++ = (unsigned short)*dp++;
}
break;
case NC_UINT:
@ -1329,7 +1329,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*dp > X_UINT_MAX || *dp < 0)
(*range_error)++;
*uip++ = *dp++;
*uip++ = (unsigned int)*dp++;
}
break;
case NC_INT:
@ -1337,23 +1337,23 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (*dp > X_INT_MAX || *dp < X_INT_MIN)
(*range_error)++;
*ip++ = *dp++;
*ip++ = (int)*dp++;
}
break;
case NC_INT64:
for (dp = (double *)src, lip = dest; count < len; count++)
{
if (*dp > X_INT64_MAX || *dp < X_INT64_MIN)
if (*dp > (double)X_INT64_MAX || *dp < X_INT64_MIN)
(*range_error)++;
*lip++ = *dp++;
*lip++ = (long long)*dp++;
}
break;
case NC_UINT64:
for (dp = (double *)src, lip = dest; count < len; count++)
for (dp = (double *)src, ulip = dest; count < len; count++)
{
if (*dp > X_UINT64_MAX || *dp < 0)
if (*dp > (double)X_UINT64_MAX || *dp < 0)
(*range_error)++;
*lip++ = *dp++;
*ulip++ = (unsigned long long)*dp++;
}
break;
case NC_FLOAT:
@ -1361,7 +1361,7 @@ nc4_convert_type(const void *src, void *dest, const nc_type src_type,
{
if (isgreater(*dp, X_FLOAT_MAX) || isless(*dp, X_FLOAT_MIN))
(*range_error)++;
*fp++ = *dp++;
*fp++ = (float)*dp++;
}
break;
case NC_DOUBLE: