diff options
| author | Larry Knox <lrknox@hdfgroup.org> | 2021-02-08 16:56:16 (GMT) |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2021-02-08 16:56:16 (GMT) |
| commit | 22c67ff6570f16050f0a5654cf1c84df917bb598 (patch) | |
| tree | 38fb63aa498b250c2543fe7e22a511706de96a42 /test/dt_arith.c | |
| parent | 551f15f8ae02ca9c995619b216121081eb07633e (diff) | |
| download | hdf5-hdf5-1_8_22.zip hdf5-hdf5-1_8_22.tar.gz hdf5-hdf5-1_8_22.tar.bz2 | |
1.8/master (#317)hdf5-1_8_22
* Revert incorrect bool type
* Correct grep text for filter test
* Check sizeof type to use correct ref_type
* h5dump reg ref chnages has no error file
* Fix comment
* Remove unneeded files
* Verify the decoded version for "all" and "none" selection.
* Remove double entry
* Add missing include
* Snapshot version 1.8 release 22 (snap4)
Update version to 1.8-snap5
* Fixes for test failures with --disable-tests --disable-tools options.
Don't test ph5diff if tests are disabled.
* Correct conditions for parallel builds with and without tests.
* Snapshot version 1.8 release 22 (snap5)
Update version to 1.8.22-snap6
* TRILAB-192 merging warnings changes from develop
* Autotools reconfigure update
* Restore page ejects.
* Restore page eject chars
* Fix orphaned token
* Update LT files
* Correct extra flags and merge TRILAB-24
* Update release note for CMake warnings
* H5repack bug fixes from develop
* TRILAB-192 - merge changes from develop
Single source, config files, for warnings for both autotools and CMake.
Update CMake libraries, tools, tests to use correct flags.
* Add missing m4 file
* Remove 128bit config check fo 1.8
* TRILAB-192 update LTparse files
* A fix in the cleaning up code for datatype when datatype initialization via H5D__init_type() fails.
The code to fix the problem is the same as what is done in H5D__open_oid().
* Add missing " and update function calls incorrectly
named load_gcc_arguments.
Commit changes to gnu-cxxflags to remove unmatched " and to gnu-fflags
to not add C warnings flags to H5_FCFLAGS.
* TRILAB-192 - cleanup edits and match CMake CXX to autotools
* Fix shadowed type
* TRILAB-192 correct fortran commands
* TRILAB-192 version of std=f2008 special check
* Fix shadow variable
* Add prefix_relto_examplesdir function to set relative path to h5c++.
* TRILAB-192 - parser files cannot handle this warning
* Parallel Fortran tests now use the MPI module instead of including
mpif.h.
* Don't add general warnings flags for unsupported old versions of gcc and
g++ (older than gcc/g++ 4.2).
Correct gnu-cxxflags to determine warnings flags to be added based on
C++ compiler version instead of C compiler version.
* Snapshot version 1.8 release 22 (snap6)
Update version to 1.8.22-snap7
* TRILAB-244 separate CXX warnings and errors from C
* Fix NoFilter build
* Move ADD_H5_FLAGS macro from *CompilerFlags.cmake files to
config/cmake_ext_mod/HDFMacros.cmake for common use.
* Restrict errors to gcc 4.8 and above.
* OESS-65 replace szip with aec szip
* Correct CMake version
* Correct -Werror=unused-variable
* Add -Werror= flags to lists displayed in libhdf5.settings.
* Fix -Werror=unused-variable
* More fixes for unused variable
* Resolve warning errors from -Werror= flags:
-Werror=bad-function-cast
-Werror=bad-function-cast
-Werror=implicit-function-declaration
-Werror=nested-externs
* Remove verbose assignments in smoke_check 3 and 5 functions.
* Update to use optimization flags, C++ error flags, and correct
libhdf5.settings.in to remove unworkable changes.
* Update config/gnu-cxxflags.
* Add missing headers
* Fix ifort warning flag.
Restore AC_DEFUN([PAC_PROG_FC_DEFAULT_REALisDBLE] in m4/aclocal_fc.m4.
Add --enable-symbols, --enable-profiling, and --enable-optimization
options to autotools configure; all configure flags for
--enable-production and --disable-production should match HDF5 1.10 and
1.12 production and debug default flags.
* Add github actions file
* Correct path
* OESS-65 Fix packaging
* Update reference name
* Correct filename
* disable pr action and enable fail fast
* Snapshot 1.8.22-snap7
Update version to 1.8.22-snap8.
* Correct mingw path
* Correct mingw paths
* Revise gnu-*flags and cmake/HDF*CompilerFlags.cmake files to add warning
flags for GCC compilers version 4.8 and above.
Removed files from gnu-warnings that only apply to versions < 4.8.
Consolidated warnings from versions < 4.8 that apply to versions >= 4.8
into the 4.8 warnings files.
* Update MANIFEST for removal of older warnings files.
* Yanked all MPI-1 calls
Added batch scripts in bin/batch.
* Snapshot 1.8.22-snap8.
Update version to 1.8.22-snap9.
* Squashed commit of the following:
commit 45b0cbc71929930a874e1c09e0770aa64d0ae697
Author: Larry Knox <lrknox@hdfgroup.org>
Date: Thu Apr 23 13:14:56 2020 -0500
Add C++ warnings treated as error for autotools builds.
commit 6debcddcc766601799d5bd661bd60946f951a07e
Author: Larry Knox <lrknox@hdfgroup.org>
Date: Fri Jun 19 16:50:03 2020 -0500
Remove tests for develop branch from testh5cc.sh.in.
Add @H5_ECXXFLAGS@ to AM_CXXFLAGS.
commit fed497e7f207313b2a133d3b68c942b7d7104b90
Author: Larry Knox <lrknox@hdfgroup.org>
Date: Fri Jun 12 15:06:39 2020 -0500
Merge pull request #2646 in HDFFV/hdf5 from ~LRKNOX/hdf5_lrk:develop to develop
* commit '998c6470d78e14228695419c3b514c35ecf3d69e':
Remove unnecessary version conditions for Clang compilers.
commit 92e52ce5c211bd1d3991a3b8bb67287ac7b652aa
Author: Larry Knox <lrknox@hdfgroup.org>
Date: Wed Jun 10 18:53:45 2020 -0500
Merge pull request #2639 in HDFFV/hdf5 from ~LRKNOX/hdf5_lrk:develop to develop
* commit 'a33667faf226f5d8c9633bf537893e8fce1bf1f6':
Add c++ to --enable-sanitize-checks option.
commit 2e802534fb997b81fa98fdd1c7d97d4310898e0d
Author: Larry Knox <lrknox@hdfgroup.org>
Date: Wed Jun 10 15:18:36 2020 -0500
Merge pull request #2633 in HDFFV/hdf5 from ~LRKNOX/hdf5_lrk:develop to develop
* commit '20eab963899841c9a003baebead8e3bc07d9e127':
Remove duplicate entries in MANIFEST.
Make changes to CMake CompilerFlags.cmake files so extra flags are loaded for non-GNU compilers.
Update new clang files to not pick up clang as vendor for pgCC. Add new files to MANIFEST Temporary demotion of 2 -Werror warning flags that fail on macos 10.12 Remove Production flag unknown to Apple clang.
commit 96ef60a58a23847a7da89a891f2415055ec2ab60
Author: Larry Knox <lrknox@hdfgroup.org>
Date: Mon Jun 8 16:24:49 2020 -0500
Merge pull request #2631 in HDFFV/hdf5 from ~LRKNOX/hdf5_lrk:develop to develop
* commit 'b942a4d8a3e27317cac50ce37ff5302d477664d8':
Clean up code to get clang version in config/linux-gnulibc1
commit 8a7c687da568e8b50b38fa53da1ca63759be6ec4
Author: Larry Knox <lrknox@hdfgroup.org>
Date: Mon Jun 8 11:42:37 2020 -0500
Merge pull request #2623 in HDFFV/hdf5 from ~LRKNOX/hdf5_lrk:develop to develop
* commit 'c7626f79fdee4eee13925e240ef41e61f3367eab':
Add flags from config/clang-warnings/*general files to H5 C and CXX flags for all versions of Clang and Clang++ compilers. Switched from cut to awk in testcheck_version.sh.in to avoid dependence on tab vs. " " in version definitions in H5public.h.
Add files for adding warning flags for clang compilers in autotools configure.
commit db3ef7ff3c1ed79167cecef831501411cff8291f
Merge: 5a0f8d7 f9f1310
Author: Larry Knox <lrknox@hdfgroup.org>
Date: Fri Jun 19 14:46:22 2020 -0500
Merge branch 'hdf5_1_12' of https://bitbucket.hdfgroup.org/scm/~lrknox/hdf5_lrk into hdf5_1_12
commit 5a0f8d7940ae57b445f545a0abd7e303ce6924ee
Author: Larry Knox <lrknox@hdfgroup.org>
Date: Wed Jun 10 20:15:41 2020 -0500
Merge pull request #2636 in HDFFV/hdf5 from ~LRKNOX/hdf5_lrk:HDFFV-11000-update-testh5cc.sh.in-for-version to develop
* commit '5c0bd670d6e9919c463fbc05de99e2ba55b0761e':
Add tests for all version to H5_NO_DEPRECATED_SYMBOLS section and to section for current version, with and without default API version flags.
HDFFV-11000: update-testh5cc.sh.in to test sample versioned functions in HDF5 1.10, 1.12 and develop.
* Update configure and Makefile.ins after bin/reconfigure.
* Fix MANIFEST
* Fix HDFFV-10591
Description:
h52gif produced a segfault when a buffer overflow occurred because
the data size was corrupted and became very large. This commit added
a check on the data size against the buffer size to prevent the segfault.
It also added error reporting to h52gif to display an error message
instead of silently exiting when the failure occurred.
Platforms tested:
Linux/64 (jelly)
* Snapshot 1.8.22-snap9. Update version to 1.8.22-snap10.
* Merge pull request #2686 in HDFFV/hdf5 from ~LRKNOX/hdf5_lrk:develop to develop
* commit '800f93f7c994f88dfa716746153ded4b1e690e3a':
Remove path to szip header file from AM_CPPFLAGS when configure check of libsz fails. Fix for HDFFV-10830.
* Regenerate configure.
* Merge from 1.10-1.12-dev - LT parse needs update
* Incorporate pull request #2693 from develop for the fix to HDFFV-11080:
(1) Patch up the file pointer when reading attribute of variable length datatype
(2) Test to verify the fix when doing multiple threads
(3) Update MANIFEST
(4) Add new test to Cmake
* Switch bison and flex update of LT files from bin/genltanalyse to
bin/genparser, and from automatically updating the LT files whenever
reconfigure is run to running only on man<F12>ual command.
* Update hl/sr/H5LT files.
Add bin/genparser to MANIFEST; remove bin/genltanalyze.
* Fix to the merge of PR #2708 for HDFFV-11080 to the 1.8 branch.
Need to checkin test/Makefile.in for the new file added.
* Fix HDFFV-11120 and HDFFV-11121 (CVE-2018-13870 and CVE-2018-13869)
Description:
When a buffer overflow occurred because a name length was corrupted
and became very large, h5dump produced a segfault on one file and a
memcpy parameter overlap on another file. This commit added checks
that detect a read pass the end of the buffer to prevent these error
conditions.
Platforms tested:
Linux/64 (jelly)
* Fixed typo
* Check for header szlib.h only when libsz passes AC_CHECK_LIB, so that
H5_HAVE_SALIB_H is not defined when szip is not enabled, to prevent
compile failures for incompatible szlib.
* HDFFV-11127 - force RTLD_LOCAL in dlopen
* spelling
* Remove extra parens
* Remove unnecessary assignment freom configure.ac.
* Add hypen to subrelease regex
* Add special case when H5_VERS_SUBRELEASE is 0
* Revert H5_VERS_SUBRELEASE check
* The version string has a second use for packaging
* MinGW uses "MinGW Makefiles"
* Snapshot 1.8.22-snap10. Update version to 1.8.22-snap11.
* Merge clang-format changes from develop
* remove stray file
* Source formatted
* Add options to github actions.
* Add back file, remove py file
* HDFFV-11096 Correct h5dump usage text
* Update formating
* remove autogen for 1.8 branch
* Fix comment whitespace
* Change '==' to 'eq' in test script
* Merge from develop
github updates
bin scripts
parser updates
* Snapshot 1.8.22-snap11. Update version to 1.8.22-snap12.
* Merge from 1.10
Comments, whitespace
Simple init and if block brackets.
Minimal code changes limited to return value and spelling
* Update autotools files
* Update FD source
* More merges from 1.10 comments and inits
* Comment fixes
* Fix macro argument
* Remove autogen file and cache dir
* Revert autotools files to previous version
* Correct boolean value and missing define
* URL and options corrections
* revert autoconf files
* Fix compile issues with vfd drivers.
* Fix HDFS test
* Remove extra #endif
* Move init above execution
* Multiple changes to bring branch up-to-date (#87)
Correct TARGET variable and CMake config file location.
Add option to allow filter plugins to be built inline.
Update CMake tools macros.
* hdf5 1 8 release text (#113)
* Multiple changes to bring branch up-to-date
Correct TARGET variable and CMake config file location.
Add option to allow filter plugins to be built inline.
Update CMake tools macros.
* release text updates - mostly whitespace
* Fixed HDFFV-10480 and HDFFV-11159 (#145)
* Fixed HDFFV-10480 and HDFFV-11159
Description
Checked against buffer size to prevent segfault, in case of data corruption.
+ HDFFV-11159 CVE-2018-14033 Buffer over-read in H5O_layout_decode
+ HDFFV-10480 CVE-2018-11206 Buffer over-read in H5O_fill_new[/old]_decode and
A user's patch was applied to this previously, but it is redone
for a more correct fix, that is the check now accounted for the
previous advance of the buffer pointer.
Platforms tested:
Linux/64 (jelly)
* Fixed typo
* Update HDF5 1.8 copyright headers with updated copyright URL (#148)
* Update URL for COPYING file in copyright headers.
* Make fortran copyright headers uniformly spaced.
* Update url for Copyright file in c++/src/footer.html.
* OESS-98 Update plugin build option (#171)
* 1.8 has extra fortran CMake option (#176)
* 1.8 has extra fortran CMake option
* Update license URL
* OESS-98 fix tools test for plugins (#180)
* Hdf5 1 8 (#169)
* Fixed HDFFV-10480 and HDFFV-11159
Description
Checked against buffer size to prevent segfault, in case of data corruption.
+ HDFFV-11159 CVE-2018-14033 Buffer over-read in H5O_layout_decode
+ HDFFV-10480 CVE-2018-11206 Buffer over-read in H5O_fill_new[/old]_decode and
A user's patch was applied to this previously, but it is redone
for a more correct fix, that is the check now accounted for the
previous advance of the buffer pointer.
Platforms tested:
Linux/64 (jelly)
* Fixed typo
* Fixed HDFFV-11150
Description
Replaced an HDassert with a check for null pointer in H5O_dec_rc() to
catch null pointer in corrupted data situation.
Reversed the fix in svn-r24463 in which a check for null pointer prior
to calling H5O_dec_rc()
Platforms tested:
Linux/64 (jelly)
* HDF5 1 8 fix fortran build on macs (#186)
* Correct fortran and shared libs option
* Fix for no shared fortran build
* OESS-98 fix hdf5 link target (#191)
* Partial changes to RELEASE.txt for release. (#185)
* Partial changes to RELEASE.txt for release.
* Update supported and tested platforms.
* Update version to 1.8.22-12.
* close #195. (#196)
* Update HDF5PluginMacros.cmake
* Update HDF5PluginMacros.cmake
* Update directory for SZ filter in HDF5PluginMacros.cmake.
Updates for release:
Switch configure default to production mode.
Set HDF5_GENERATE_HEADERS to OFF.
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Restores maintainer mode in the autotools (#200) (#203)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
* Hdf5 1 8 22 (#212)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Brings ttsafe_attr_vlen.c changes from develop (#214)
Fixes exposed pthread problem on Windows.
* Update SO numbers for Hdf5 1 8 22 (#215)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Hdf5 1 8 22 (#224)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
* Update CMake/HDF5Examples version in bin/release
* Update CMake/HDF5Examples version number in bin/release (#225)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Update CMake/HDF5Examples version in bin/release
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
* Fixed typo in an error message. (#228)
* Fixed typo in an error message. (#227)
* Remove duplicate setting (#239)
* Bring 3 small changes from Hdf5 1.8 to 1.8.22 (#241)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Update CMake/HDF5Examples version in bin/release
* Fixed typo in an error message. (#227)
* Remove duplicate setting (#239)
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
Co-authored-by: bmribler <39579120+bmribler@users.noreply.github.com>
* Stat st blocks fix 1822 (#251)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Update CMake/HDF5Examples version in bin/release
* Fixed typo in an error message. (#227)
* Remove duplicate setting (#239)
* Fixes Autotools detection of the st_blocks field in stat (#246)
* Fixes Autotools detection of the st_blocks field in stat
The Autotools and CMake will now both correctly determine if the
stat struct has the st_blocks field and set H5_HAVE_STAT_ST_BLOCKS
appropriately.
* Fixes a typo in configure.ac
* Restore lines in RELEASE.txt.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
Co-authored-by: bmribler <39579120+bmribler@users.noreply.github.com>
* Stat st blocks fix 1822 (#256)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Update CMake/HDF5Examples version in bin/release
* Fixed typo in an error message. (#227)
* Remove duplicate setting (#239)
* Fixes Autotools detection of the st_blocks field in stat (#246)
* Fixes Autotools detection of the st_blocks field in stat
The Autotools and CMake will now both correctly determine if the
stat struct has the st_blocks field and set H5_HAVE_STAT_ST_BLOCKS
appropriately.
* Fixes a typo in configure.ac
* Restore lines in RELEASE.txt.
* Updated configure with reconfigure.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
Co-authored-by: bmribler <39579120+bmribler@users.noreply.github.com>
* RELEASE.txt cleanup.
* Hdf5 1 8 22 (#261)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Update CMake/HDF5Examples version in bin/release
* Fixed typo in an error message. (#227)
* Remove duplicate setting (#239)
* RELEASE.txt cleanup.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
Co-authored-by: bmribler <39579120+bmribler@users.noreply.github.com>
* Add macOS Big Sur to tested machines, also missing entries for macOS 10.13 and 10.14.
* )Update version.
* Hdf5 1 8 22 (#266)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Update CMake/HDF5Examples version in bin/release
* Fixed typo in an error message. (#227)
* Remove duplicate setting (#239)
* RELEASE.txt cleanup.
* Add macOS Big Sur to tested machines, also missing entries for macOS 10.13 and 10.14.
* )Update version.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
Co-authored-by: bmribler <39579120+bmribler@users.noreply.github.com>
* Reverts lock/unlock callback signature to 1.8.21 version (#254)
* Reverts lock/unlock callback signature to 1.8.21 version
This callback is unused in 1.8. The ros3 and hdfs VFDs are the only VFDs
that have the lock callback implemented and that is just as no-op stubs.
These stubs were removed so the callbacks are now NULL pointers, like
the other VFDs in 1.8.
* Trivial whitespace fix
* Update version to 1.8.22-14.
* Hdf5 1 8 22 - Reverts lock/unlock callback signature to 1.8.21 version (#267)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Update CMake/HDF5Examples version in bin/release
* Fixed typo in an error message. (#227)
* Remove duplicate setting (#239)
* RELEASE.txt cleanup.
* Add macOS Big Sur to tested machines, also missing entries for macOS 10.13 and 10.14.
* )Update version.
* Reverts lock/unlock callback signature to 1.8.21 version (#254)
* Reverts lock/unlock callback signature to 1.8.21 version
This callback is unused in 1.8. The ros3 and hdfs VFDs are the only VFDs
that have the lock callback implemented and that is just as no-op stubs.
These stubs were removed so the callbacks are now NULL pointers, like
the other VFDs in 1.8.
* Trivial whitespace fix
* Update version to 1.8.22-14.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
Co-authored-by: bmribler <39579120+bmribler@users.noreply.github.com>
* Update version in H5public.h
* Hdf5 1 8 22 (#269)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Update CMake/HDF5Examples version in bin/release
* Fixed typo in an error message. (#227)
* Remove duplicate setting (#239)
* RELEASE.txt cleanup.
* Add macOS Big Sur to tested machines, also missing entries for macOS 10.13 and 10.14.
* )Update version.
* Reverts lock/unlock callback signature to 1.8.21 version (#254)
* Reverts lock/unlock callback signature to 1.8.21 version
This callback is unused in 1.8. The ros3 and hdfs VFDs are the only VFDs
that have the lock callback implemented and that is just as no-op stubs.
These stubs were removed so the callbacks are now NULL pointers, like
the other VFDs in 1.8.
* Trivial whitespace fix
* Update version to 1.8.22-14.
* Update version in H5public.h
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
Co-authored-by: bmribler <39579120+bmribler@users.noreply.github.com>
* Set version 1.8.22 for release.
* dd RELEASE.txt entry for HDFFV-10741.
* Hdf5 1 8 22 (#279)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Update CMake/HDF5Examples version in bin/release
* Fixed typo in an error message. (#227)
* Remove duplicate setting (#239)
* RELEASE.txt cleanup.
* Add macOS Big Sur to tested machines, also missing entries for macOS 10.13 and 10.14.
* )Update version.
* Reverts lock/unlock callback signature to 1.8.21 version (#254)
* Reverts lock/unlock callback signature to 1.8.21 version
This callback is unused in 1.8. The ros3 and hdfs VFDs are the only VFDs
that have the lock callback implemented and that is just as no-op stubs.
These stubs were removed so the callbacks are now NULL pointers, like
the other VFDs in 1.8.
* Trivial whitespace fix
* Update version to 1.8.22-14.
* Update version in H5public.h
* Set version 1.8.22 for release.
* dd RELEASE.txt entry for HDFFV-10741.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
Co-authored-by: bmribler <39579120+bmribler@users.noreply.github.com>
* Improve performance of multiple calls to H5Sget_select_elem_pointlist (#270) (#277)
* Cache the pointer to the next point to process after the last call to
H5S__get_select_elem_pointlist. This allows the normal process of
iterating over the points in batches to be much more efficient, as the
library does not need to traverse the entirety of the preceding points
every time the funciton is re-entered.
* Update RELEASE.txt for point selection iteration performance fix.
* Hdf5 1 8 22 (#281)
* Restores maintainer mode in the autotools (#200)
Maintainer mode should be enabled in development branches.
Also adds helpful commenting.
Add bin/switch_maint_mode
Disable maintainer mode for release.
Fix incomplete merge for stub functions in H5Fdhdfs.c
* Update configure for Restores maintainer mode in the autotools (#200).
* Update MANIFEST for switch_maint_mode script.
* Update so numbers for 1.8.22 release.
* Add so numbers changes in Makefile.ins for 1.8.22 release.
* Update pkgconfig settings with version - #218 (#223)
* Add notice of final HDFF5 1.8 release.
Add solaris 64bit alignment issue to "Known Problems".
* Update 1.8 final release notice.
* Update CMake/HDF5Examples version in bin/release
* Fixed typo in an error message. (#227)
* Remove duplicate setting (#239)
* RELEASE.txt cleanup.
* Add macOS Big Sur to tested machines, also missing entries for macOS 10.13 and 10.14.
* )Update version.
* Reverts lock/unlock callback signature to 1.8.21 version (#254)
* Reverts lock/unlock callback signature to 1.8.21 version
This callback is unused in 1.8. The ros3 and hdfs VFDs are the only VFDs
that have the lock callback implemented and that is just as no-op stubs.
These stubs were removed so the callbacks are now NULL pointers, like
the other VFDs in 1.8.
* Trivial whitespace fix
* Update version to 1.8.22-14.
* Update version in H5public.h
* Set version 1.8.22 for release.
* dd RELEASE.txt entry for HDFFV-10741.
* Improve performance of multiple calls to H5Sget_select_elem_pointlist (#270) (#277)
* Cache the pointer to the next point to process after the last call to
H5S__get_select_elem_pointlist. This allows the normal process of
iterating over the points in batches to be much more efficient, as the
library does not need to traverse the entirety of the preceding points
every time the funciton is re-entered.
* Update RELEASE.txt for point selection iteration performance fix.
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
Co-authored-by: bmribler <39579120+bmribler@users.noreply.github.com>
Co-authored-by: Neil Fortner <nfortne2@hdfgroup.org>
* Hdf5 1 8 22 (#284)
* Fixed typo in an error message.
* Updated for HDFFV-11150, HDFFV-10480, and HDFFV-11159
* Update "Support for New Platforms and Compilers" section in RELEASE.txt;
add check_version workaround for binary compatibility to "Known
Problems".
* Add SUSE Linux to tested platforms.
* Update numbers in config/lt_vers.am and run bin/reconfigure for so
numbers.
* Update version in 3 files missed by merge.
Co-authored-by: Allen Byrne <byrn@hdfgroup.org>
Co-authored-by: Vailin Choi <vchoi@hdfgroup.org>
Co-authored-by: vchoi <vchoi@jelly.ad.hdfgroup.org>
Co-authored-by: hdftest <hdftest@hdfgroup.org>
Co-authored-by: Jordan Henderson <jhenderson@hdfgroup.org>
Co-authored-by: Dana Robinson <derobins@hdfgroup.org>
Co-authored-by: Binh-Minh Ribler <bmribler@hdfgroup.org>
Co-authored-by: Allen Byrne <50328838+byrnHDF@users.noreply.github.com>
Co-authored-by: bmribler <39579120+bmribler@users.noreply.github.com>
Co-authored-by: H. Joe Lee <hyoklee@hdfgroup.org>
Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Neil Fortner <nfortne2@hdfgroup.org>
Diffstat (limited to 'test/dt_arith.c')
| -rw-r--r-- | test/dt_arith.c | 6031 |
1 files changed, 3120 insertions, 2911 deletions
diff --git a/test/dt_arith.c b/test/dt_arith.c index 41fb49d..1b8fd17 100644 --- a/test/dt_arith.c +++ b/test/dt_arith.c @@ -6,7 +6,7 @@ * This file is part of HDF5. The full HDF5 copyright notice, including * * terms governing use, modification, and redistribution, is contained in * * the COPYING file, which can be found at the root of the source code * - * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. * + * distribution tree, or in https://www.hdfgroup.org/licenses. * * If you do not have access to either file, you may request a copy from * * help@hdfgroup.org. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -21,7 +21,7 @@ #include "h5test.h" /* Number of elements in each random test */ -#define NTESTELEM 10000 +#define NTESTELEM 10000 /* Epsilon for floating-point comparisons */ #define FP_EPSILON 0.000001F @@ -30,7 +30,7 @@ * Offset from alinged memory returned by malloc(). This can be used to test * that type conversions handle non-aligned buffers correctly. */ -#define ALIGNMENT 1 +#define ALIGNMENT 1 /* * Define if you want to test alignment code on a machine that doesn't @@ -44,26 +44,31 @@ #define H5T_PACKAGE #include "H5Tpkg.h" #endif -#define SET_ALIGNMENT(TYPE,VAL) \ - H5T_NATIVE_##TYPE##_ALIGN_g=MAX(H5T_NATIVE_##TYPE##_ALIGN_g, VAL) +#define SET_ALIGNMENT(TYPE, VAL) H5T_NATIVE_##TYPE##_ALIGN_g = MAX(H5T_NATIVE_##TYPE##_ALIGN_g, VAL) -const char *FILENAME[] = { - "dt_arith1", - "dt_arith2", - NULL -}; +const char *FILENAME[] = {"dt_arith1", "dt_arith2", NULL}; /* * Count up or down depending on whether the machine is big endian or little * endian. If local variable `endian' is H5T_ORDER_BE then the result will * be I, otherwise the result will be Z-(I+1). */ -#define ENDIAN(Z,I,E) (H5T_ORDER_BE==E?(I):(Z)-((I)+1)) +#define ENDIAN(Z, I, E) (H5T_ORDER_BE == E ? (I) : (Z) - ((I) + 1)) typedef enum dtype_t { - INT_SCHAR, INT_UCHAR, INT_SHORT, INT_USHORT, INT_INT, INT_UINT, - INT_LONG, INT_ULONG, INT_LLONG, INT_ULLONG, FLT_FLOAT, FLT_DOUBLE, -#if H5_SIZEOF_LONG_DOUBLE !=0 + INT_SCHAR, + INT_UCHAR, + INT_SHORT, + INT_USHORT, + INT_INT, + INT_UINT, + INT_LONG, + INT_ULONG, + INT_LLONG, + INT_ULLONG, + FLT_FLOAT, + FLT_DOUBLE, +#if H5_SIZEOF_LONG_DOUBLE != 0 FLT_LDOUBLE, #endif OTHER @@ -87,317 +92,322 @@ static int skip_overflow_tests_g = 0; * Decide what values of floating-point number we want to test. They are * 1 - normalized; 2 - denormalized; 3 - special. */ -#define TEST_NOOP 0 -#define TEST_NORMAL 1 -#define TEST_DENORM 2 -#define TEST_SPECIAL 3 +#define TEST_NOOP 0 +#define TEST_NORMAL 1 +#define TEST_DENORM 2 +#define TEST_SPECIAL 3 +/* Temporary buffer sizes */ +#define TMP_BUF_DIM1 32 +#define TMP_BUF_DIM2 100 /* Don't use hardware conversions if set */ static int without_hardware_g = 0; /* Allocates memory aligned on a certain boundary. */ -#define aligned_malloc(Z) ((void*)((char*)HDmalloc(ALIGNMENT+Z)+ALIGNMENT)) -#define aligned_free(M) HDfree((char*)(M)-ALIGNMENT) +#define aligned_malloc(Z) ((void *)((char *)HDmalloc(ALIGNMENT + Z) + ALIGNMENT)) +#define aligned_free(M) HDfree((char *)(M)-ALIGNMENT) /* Initialize source buffer of integer for integer->integer and integer->floating-point conversion test. * This algorithm is mainly to avoid any casting and comparison between source and destination types * for compiler, because we're testing conversions. */ -#define INIT_INTEGER(TYPE, SRC_MAX, SRC_MIN, SRC_SIZE, DST_SIZE, SRC_PREC, BUF, SAVED, NELMTS) \ -{ \ - unsigned char *buf_p, *saved_p; \ - unsigned int n; \ - TYPE value1 = 1; \ - TYPE value2 = 0; \ - \ - /* Allocate buffers */ \ - NELMTS=SRC_PREC*3; \ - BUF = (unsigned char*)aligned_malloc(NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - SAVED = (unsigned char*)aligned_malloc(NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - HDmemset(BUF, 0, NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - HDmemset(SAVED, 0, NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - \ - buf_p = BUF; \ - saved_p = SAVED; \ - \ - /*positive values, ascending order. VALUE1 starts from 00000001, to 00000010, until 10000000*/ \ - /*VALUE2 ascends from 00000000, to 00000011, 00000111,..., until 11111111.*/ \ - for(n=0; n<SRC_PREC; n++) { \ - if(value1<=SRC_MAX && value1>=SRC_MIN) { \ - memcpy(buf_p, &value1, SRC_SIZE); \ - memcpy(saved_p, &value1, SRC_SIZE); \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - } \ - if(value2<=SRC_MAX && value2>=SRC_MIN) { \ - memcpy(buf_p, &value2, SRC_SIZE); \ - memcpy(saved_p, &value2, SRC_SIZE); \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - } \ - \ - if(n<SRC_PREC-2) { \ - value1 <<= 1; \ - value2 = (value1 - 1) | value1; \ - } else if(n==SRC_PREC-2) { /*to avoid overflow of negative values for signed integer*/ \ - value1 <<= 1; \ - value2 = (~value1) | value1; \ - } \ - } \ - \ - /* negative values for signed; descending positive values for unsigned */ \ - /* VALUE2 descends from 11111111 to 11111110, 11111100, ..., until 10000000. */ \ - for(n=0; n<SRC_PREC-1; n++) { \ - if(value2<=SRC_MAX && value2>=SRC_MIN) { \ - memcpy(buf_p, &value2, SRC_SIZE); \ - memcpy(saved_p, &value2, SRC_SIZE); \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - } \ - if(n<SRC_PREC-1) \ - value2 <<= 1; \ - } \ -} +#define INIT_INTEGER(TYPE, SRC_MAX, SRC_MIN, SRC_SIZE, DST_SIZE, SRC_PREC, BUF, SAVED, NELMTS) \ + { \ + unsigned char *buf_p, *saved_p; \ + unsigned int n; \ + TYPE value1 = 1; \ + TYPE value2 = 0; \ + \ + /* Allocate buffers */ \ + NELMTS = SRC_PREC * 3; \ + BUF = (unsigned char *)aligned_malloc(NELMTS * MAX(SRC_SIZE, DST_SIZE)); \ + SAVED = (unsigned char *)aligned_malloc(NELMTS * MAX(SRC_SIZE, DST_SIZE)); \ + HDmemset(BUF, 0, NELMTS *MAX(SRC_SIZE, DST_SIZE)); \ + HDmemset(SAVED, 0, NELMTS *MAX(SRC_SIZE, DST_SIZE)); \ + \ + buf_p = BUF; \ + saved_p = SAVED; \ + \ + /*positive values, ascending order. VALUE1 starts from 00000001, to 00000010, until 10000000*/ \ + /*VALUE2 ascends from 00000000, to 00000011, 00000111,..., until 11111111.*/ \ + for (n = 0; n < SRC_PREC; n++) { \ + { \ + HDmemcpy(buf_p, &value1, SRC_SIZE); \ + HDmemcpy(saved_p, &value1, SRC_SIZE); \ + buf_p += SRC_SIZE; \ + saved_p += SRC_SIZE; \ + } \ + { \ + HDmemcpy(buf_p, &value2, SRC_SIZE); \ + HDmemcpy(saved_p, &value2, SRC_SIZE); \ + buf_p += SRC_SIZE; \ + saved_p += SRC_SIZE; \ + } \ + \ + if (n < SRC_PREC - 2) { \ + value1 = (TYPE)(value1 << 1); \ + value2 = (TYPE)((value1 - 1) | value1); \ + } \ + else if (n == SRC_PREC - 2) { /*to avoid overflow of negative values for signed integer*/ \ + value1 = (TYPE)(value1 << 1); \ + value2 = (TYPE)((~value1) | value1); \ + } \ + } \ + \ + /* negative values for signed; descending positive values for unsigned */ \ + /* VALUE2 descends from 11111111 to 11111110, 11111100, ..., until 10000000. */ \ + for (n = 0; n < SRC_PREC - 1; n++) { \ + { \ + HDmemcpy(buf_p, &value2, SRC_SIZE); \ + HDmemcpy(saved_p, &value2, SRC_SIZE); \ + buf_p += SRC_SIZE; \ + saved_p += SRC_SIZE; \ + } \ + if (n < SRC_PREC - 1) \ + value2 = (TYPE)(value2 << 1); \ + } \ + } /* Change a buffer's byte order from big endian to little endian. It's mainly for library's * bit operations which handle only little endian order. */ -#define CHANGE_ORDER(EBUF, EORDER, ESIZE) \ -{ \ - unsigned int m; \ - if (H5T_ORDER_BE==EORDER) { \ - unsigned char mediator; \ - size_t half_size = ESIZE/2; \ - for (m=0; m<half_size; m++) { \ - mediator = EBUF[ESIZE-(m+1)]; \ - EBUF[ESIZE-(m+1)] = EBUF[m]; \ - EBUF[m] = mediator; \ - } \ - } else if (H5T_ORDER_VAX==EORDER) { \ - unsigned char mediator1, mediator2; \ - for (m = 0; m < ESIZE; m += 4) { \ - mediator1 = EBUF[m]; \ - mediator2 = EBUF[m+1]; \ - \ - EBUF[m] = EBUF[(ESIZE-2)-m]; \ - EBUF[m+1] = EBUF[(ESIZE-1)-m]; \ - \ - EBUF[(ESIZE-2)-m] = mediator1; \ - EBUF[(ESIZE-1)-m] = mediator2; \ - } \ - } \ -} +#define CHANGE_ORDER(EBUF, EORDER, ESIZE) \ + { \ + unsigned int m; \ + if (H5T_ORDER_BE == EORDER) { \ + unsigned char mediator; \ + size_t half_size = ESIZE / 2; \ + for (m = 0; m < half_size; m++) { \ + mediator = EBUF[ESIZE - (m + 1)]; \ + EBUF[ESIZE - (m + 1)] = EBUF[m]; \ + EBUF[m] = mediator; \ + } \ + } \ + else if (H5T_ORDER_VAX == EORDER) { \ + unsigned char mediator1, mediator2; \ + for (m = 0; m < ESIZE; m += 4) { \ + mediator1 = EBUF[m]; \ + mediator2 = EBUF[m + 1]; \ + \ + EBUF[m] = EBUF[(ESIZE - 2) - m]; \ + EBUF[m + 1] = EBUF[(ESIZE - 1) - m]; \ + \ + EBUF[(ESIZE - 2) - m] = mediator1; \ + EBUF[(ESIZE - 1) - m] = mediator2; \ + } \ + } \ + } /* Allocate buffer and initialize it with floating-point normalized values. * It's for conversion test of floating-point as the source. */ -#define INIT_FP_NORM(TYPE, SRC_MAX, SRC_MIN, SRC_MAX_10_EXP, SRC_MIN_10_EXP, SRC_SIZE, \ - DST_SIZE, BUF, SAVED, NELMTS) \ -{ \ - unsigned char *buf_p, *saved_p; \ - size_t num_norm, factor, n; \ - TYPE value1, value2; \ - TYPE multiply; \ - \ - /*Determine the number of normalized values and increment pace. The values start from \ - *minimal normalized value and are multiplied by MULTIPLY each step until reach to maximal \ - *normalized value.*/ \ - if(SRC_MAX_10_EXP<100) { /*for float*/ \ - factor = 0; \ - multiply = 10; \ - } else if(SRC_MAX_10_EXP>=100 && SRC_MAX_10_EXP<400) { /*for double*/ \ - factor = 2; \ - multiply = 10000; \ - } else { /*for long double*/ \ - factor = 3; \ - multiply = 100000000; \ - } \ - \ - /*The number of values if multiplied by 10 for each step.*/ \ - num_norm = (SRC_MAX_10_EXP - SRC_MIN_10_EXP); \ - /*Reduce the number of values by 2^factor. MULTIPLY=10^(2^factor). Using this algorithm \ - *instead of arithmatic operation to avoid any conversion*/ \ - num_norm >>= factor; \ - \ - /*Total number of values*/ \ - NELMTS = 2 * /*both positive and negative*/ \ - (num_norm + /*number of normalized values*/ \ - 1); /*maximal normalized value*/ \ - \ - /* Allocate buffers */ \ - BUF = (unsigned char*)aligned_malloc(NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - SAVED = (unsigned char*)aligned_malloc(NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - HDmemset(BUF, 0, NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - HDmemset(SAVED, 0, NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - \ - buf_p = BUF; \ - saved_p = SAVED; \ - \ - /*Normalized values*/ \ - value1 = SRC_MIN; \ - value2 = -SRC_MIN; \ - for(n=0; n<num_norm; n++) { \ - if(value1<SRC_MAX) { /*positive*/ \ - memcpy(buf_p, &value1, SRC_SIZE); \ - memcpy(saved_p, &value1, SRC_SIZE); \ - value1 *= multiply; \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - } \ - if(value2>-SRC_MAX) { /*negative*/ \ - memcpy(buf_p, &value2, SRC_SIZE); \ - memcpy(saved_p, &value2, SRC_SIZE); \ - value2 *= multiply; \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - } \ - } \ - \ - value1 = SRC_MAX; /*maximal value*/ \ - memcpy(buf_p, &value1, SRC_SIZE); \ - memcpy(saved_p, &value1, SRC_SIZE); \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - \ - value2 = -SRC_MAX; /*negative value*/ \ - memcpy(buf_p, &value2, SRC_SIZE); \ - memcpy(saved_p, &value2, SRC_SIZE); \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ -} +#define INIT_FP_NORM(TYPE, SRC_MAX, SRC_MIN, SRC_MAX_10_EXP, SRC_MIN_10_EXP, SRC_SIZE, DST_SIZE, BUF, SAVED, \ + NELMTS) \ + { \ + unsigned char *buf_p, *saved_p; \ + size_t num_norm, factor, n; \ + TYPE value1, value2; \ + TYPE multiply; \ + \ + /*Determine the number of normalized values and increment pace. The values start from \ + *minimal normalized value and are multiplied by MULTIPLY each step until reach to maximal \ + *normalized value.*/ \ + if (SRC_MAX_10_EXP < 100) { /*for float*/ \ + factor = 0; \ + multiply = 10; \ + } \ + else if (SRC_MAX_10_EXP >= 100 && SRC_MAX_10_EXP < 400) { /*for double*/ \ + factor = 2; \ + multiply = 10000; \ + } \ + else { /*for long double*/ \ + factor = 3; \ + multiply = 100000000; \ + } \ + \ + /*The number of values if multiplied by 10 for each step.*/ \ + num_norm = (SRC_MAX_10_EXP - SRC_MIN_10_EXP); \ + /*Reduce the number of values by 2^factor. MULTIPLY=10^(2^factor). Using this algorithm \ + *instead of arithmatic operation to avoid any conversion*/ \ + num_norm >>= factor; \ + \ + /*Total number of values*/ \ + NELMTS = 2 * /*both positive and negative*/ \ + (num_norm + /*number of normalized values*/ \ + 1); /*maximal normalized value*/ \ + \ + /* Allocate buffers */ \ + BUF = (unsigned char *)aligned_malloc(NELMTS * MAX(SRC_SIZE, DST_SIZE)); \ + SAVED = (unsigned char *)aligned_malloc(NELMTS * MAX(SRC_SIZE, DST_SIZE)); \ + HDmemset(BUF, 0, NELMTS *MAX(SRC_SIZE, DST_SIZE)); \ + HDmemset(SAVED, 0, NELMTS *MAX(SRC_SIZE, DST_SIZE)); \ + \ + buf_p = BUF; \ + saved_p = SAVED; \ + \ + /*Normalized values*/ \ + value1 = SRC_MIN; \ + value2 = -SRC_MIN; \ + for (n = 0; n < num_norm; n++) { \ + if (value1 < SRC_MAX) { /*positive*/ \ + HDmemcpy(buf_p, &value1, SRC_SIZE); \ + HDmemcpy(saved_p, &value1, SRC_SIZE); \ + value1 *= multiply; \ + buf_p += SRC_SIZE; \ + saved_p += SRC_SIZE; \ + } \ + if (value2 > -SRC_MAX) { /*negative*/ \ + HDmemcpy(buf_p, &value2, SRC_SIZE); \ + HDmemcpy(saved_p, &value2, SRC_SIZE); \ + value2 *= multiply; \ + buf_p += SRC_SIZE; \ + saved_p += SRC_SIZE; \ + } \ + } \ + \ + value1 = SRC_MAX; /*maximal value*/ \ + HDmemcpy(buf_p, &value1, SRC_SIZE); \ + HDmemcpy(saved_p, &value1, SRC_SIZE); \ + buf_p += SRC_SIZE; \ + saved_p += SRC_SIZE; \ + \ + value2 = -SRC_MAX; /*negative value*/ \ + HDmemcpy(buf_p, &value2, SRC_SIZE); \ + HDmemcpy(saved_p, &value2, SRC_SIZE); \ + buf_p += SRC_SIZE; \ + saved_p += SRC_SIZE; \ + } /* Allocate buffer and initialize it with floating-point denormalized values. * It's for conversion test of floating-point as the source. */ -#define INIT_FP_DENORM(TYPE, SRC_MANT_DIG, SRC_SIZE, SRC_PREC, SRC_ORDR, DST_SIZE, \ - BUF, SAVED, NELMTS) \ -{ \ - unsigned char *buf_p, *saved_p; \ - unsigned char *tmp1, *tmp2; \ - size_t n; \ - \ - /*Total number of values*/ \ - NELMTS = 2 * /*both positive and negative*/ \ - (SRC_MANT_DIG - 1); /*number of denormalized values*/ \ - \ - /* Allocate buffers */ \ - BUF = (unsigned char*)aligned_malloc(NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - SAVED = (unsigned char*)aligned_malloc(NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - HDmemset(BUF, 0, NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - HDmemset(SAVED, 0, NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - \ - tmp1 = (unsigned char*)HDcalloc((size_t)1, (size_t)SRC_SIZE); \ - tmp2 = (unsigned char*)HDcalloc((size_t)1, (size_t)SRC_SIZE); \ - \ - buf_p = BUF; \ - saved_p = SAVED; \ - \ - /*Denormalized values. Exponent is 0. Let mantissa starts from 00000001, 00000011, \ - *00000111,..., until 11111111.*/ \ - memset(tmp1, 0, SRC_SIZE); \ - memset(tmp2, 0, SRC_SIZE); \ - H5T__bit_set (tmp2, SRC_PREC-1, (size_t)1, TRUE); /*the negative value*/ \ - for(n=0; n<SRC_MANT_DIG-1; n++) { \ - H5T__bit_set (tmp1, n, (size_t)1, TRUE); /*turn on 1 bit each time*/ \ - CHANGE_ORDER(tmp1, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \ - memcpy(buf_p, tmp1, SRC_SIZE); \ - memcpy(saved_p, tmp1, SRC_SIZE); \ - CHANGE_ORDER(tmp1, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - \ - /*negative values*/ \ - H5T__bit_set (tmp2, n, (size_t)1, TRUE); \ - CHANGE_ORDER(tmp2, SRC_ORDR, SRC_SIZE); \ - memcpy(buf_p, tmp2, SRC_SIZE); \ - memcpy(saved_p, tmp2, SRC_SIZE); \ - CHANGE_ORDER(tmp2, SRC_ORDR, SRC_SIZE); \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - } \ - HDfree(tmp1); \ - HDfree(tmp2); \ -} +#define INIT_FP_DENORM(TYPE, SRC_MANT_DIG, SRC_SIZE, SRC_PREC, SRC_ORDR, DST_SIZE, BUF, SAVED, NELMTS) \ + { \ + unsigned char *buf_p, *saved_p; \ + unsigned char *tmp1, *tmp2; \ + size_t n; \ + \ + /*Total number of values*/ \ + NELMTS = 2 * /*both positive and negative*/ \ + (SRC_MANT_DIG - 1); /*number of denormalized values*/ \ + \ + /* Allocate buffers */ \ + BUF = (unsigned char *)aligned_malloc(NELMTS * MAX(SRC_SIZE, DST_SIZE)); \ + SAVED = (unsigned char *)aligned_malloc(NELMTS * MAX(SRC_SIZE, DST_SIZE)); \ + HDmemset(BUF, 0, NELMTS *MAX(SRC_SIZE, DST_SIZE)); \ + HDmemset(SAVED, 0, NELMTS *MAX(SRC_SIZE, DST_SIZE)); \ + \ + tmp1 = (unsigned char *)HDcalloc((size_t)1, (size_t)SRC_SIZE); \ + tmp2 = (unsigned char *)HDcalloc((size_t)1, (size_t)SRC_SIZE); \ + \ + buf_p = BUF; \ + saved_p = SAVED; \ + \ + /*Denormalized values. Exponent is 0. Let mantissa starts from 00000001, 00000011, \ + *00000111,..., until 11111111.*/ \ + HDmemset(tmp1, 0, SRC_SIZE); \ + HDmemset(tmp2, 0, SRC_SIZE); \ + H5T__bit_set(tmp2, SRC_PREC - 1, (size_t)1, TRUE); /*the negative value*/ \ + for (n = 0; n < SRC_MANT_DIG - 1; n++) { \ + H5T__bit_set(tmp1, n, (size_t)1, TRUE); /*turn on 1 bit each time*/ \ + CHANGE_ORDER(tmp1, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \ + HDmemcpy(buf_p, tmp1, SRC_SIZE); \ + HDmemcpy(saved_p, tmp1, SRC_SIZE); \ + CHANGE_ORDER(tmp1, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \ + buf_p += SRC_SIZE; \ + saved_p += SRC_SIZE; \ + \ + /*negative values*/ \ + H5T__bit_set(tmp2, n, (size_t)1, TRUE); \ + CHANGE_ORDER(tmp2, SRC_ORDR, SRC_SIZE); \ + HDmemcpy(buf_p, tmp2, SRC_SIZE); \ + HDmemcpy(saved_p, tmp2, SRC_SIZE); \ + CHANGE_ORDER(tmp2, SRC_ORDR, SRC_SIZE); \ + buf_p += SRC_SIZE; \ + saved_p += SRC_SIZE; \ + } \ + HDfree(tmp1); \ + HDfree(tmp2); \ + } /* Allocate buffer and initialize it with floating-point special values, +/-0, +/-infinity, * +/-QNaN, +/-SNaN. It's for conversion test of floating-point as the source. */ -#define INIT_FP_SPECIAL(SRC_SIZE, SRC_PREC, SRC_ORDR, SRC_MANT_DIG, DST_SIZE, \ - BUF, SAVED, NELMTS) \ -{ \ - unsigned char *buf_p; \ - unsigned char *value; \ - int n; \ - \ - /*Total number of values*/ \ - NELMTS = 2 * /*both positive and negative*/ \ - 4; /*infinity, SNaN, QNaN */ \ - \ - /* Allocate buffers */ \ - BUF = (unsigned char*)aligned_malloc(NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - SAVED = (unsigned char*)aligned_malloc( NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - HDmemset(BUF, 0, NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - HDmemset(SAVED, 0, NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - value = (unsigned char*)HDcalloc(SRC_SIZE, sizeof(unsigned char)); \ - \ - buf_p = BUF; \ - \ - /* +0 */ \ - H5T__bit_set(value, (size_t)0, SRC_PREC, FALSE); \ - memcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char)); \ - buf_p += SRC_SIZE; \ - \ - for(n=0; n<2; n++) { \ - if(n==1) { \ - memset(value, 0, SRC_SIZE*sizeof(unsigned char)); \ - /* -0 */ \ - H5T__bit_set(value, (size_t)(SRC_PREC - 1), (size_t)1, TRUE); \ - CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);/*change order for big endian*/ \ - HDmemcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char)); \ - CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);/*change back the order for bit operation*/ \ - buf_p += SRC_SIZE; \ - } \ - \ - /* +/-infinity */ \ - H5T__bit_set(value, (size_t)(SRC_MANT_DIG - 1), SRC_PREC-SRC_MANT_DIG, TRUE); \ - CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \ - HDmemcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char)); \ - CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \ - buf_p += SRC_SIZE; \ - \ - /* +/-SNaN */ \ - H5T__bit_set(value, (size_t)0, (size_t)1, TRUE); \ - CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \ - HDmemcpy(buf_p, value, SRC_SIZE * sizeof(unsigned char)); \ - CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \ - buf_p += SRC_SIZE; \ - \ - /* +/-QNaN */ \ - H5T__bit_set(value, (size_t)(SRC_MANT_DIG - 2), (size_t)1, TRUE); \ - CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \ - HDmemcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char)); \ - CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \ - buf_p += SRC_SIZE; \ - } \ - \ - HDmemcpy(SAVED, BUF, NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - HDfree(value); \ -} +#define INIT_FP_SPECIAL(SRC_SIZE, SRC_PREC, SRC_ORDR, SRC_MANT_DIG, DST_SIZE, BUF, SAVED, NELMTS) \ + { \ + unsigned char *buf_p; \ + unsigned char *value; \ + int n; \ + \ + /*Total number of values*/ \ + NELMTS = 2 * /*both positive and negative*/ \ + 4; /*infinity, SNaN, QNaN */ \ + \ + /* Allocate buffers */ \ + BUF = (unsigned char *)aligned_malloc(NELMTS * MAX(SRC_SIZE, DST_SIZE)); \ + SAVED = (unsigned char *)aligned_malloc(NELMTS * MAX(SRC_SIZE, DST_SIZE)); \ + HDmemset(BUF, 0, NELMTS *MAX(SRC_SIZE, DST_SIZE)); \ + HDmemset(SAVED, 0, NELMTS *MAX(SRC_SIZE, DST_SIZE)); \ + value = (unsigned char *)HDcalloc(SRC_SIZE, sizeof(unsigned char)); \ + \ + buf_p = BUF; \ + \ + /* +0 */ \ + H5T__bit_set(value, (size_t)0, SRC_PREC, FALSE); \ + HDmemcpy(buf_p, value, SRC_SIZE * sizeof(unsigned char)); \ + buf_p += SRC_SIZE; \ + \ + for (n = 0; n < 2; n++) { \ + if (n == 1) { \ + memset(value, 0, SRC_SIZE * sizeof(unsigned char)); \ + /* -0 */ \ + H5T__bit_set(value, (size_t)(SRC_PREC - 1), (size_t)1, TRUE); \ + CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \ + HDmemcpy(buf_p, value, SRC_SIZE * sizeof(unsigned char)); \ + CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \ + buf_p += SRC_SIZE; \ + } \ + \ + /* +/-infinity */ \ + H5T__bit_set(value, (size_t)(SRC_MANT_DIG - 1), SRC_PREC - SRC_MANT_DIG, TRUE); \ + CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \ + HDmemcpy(buf_p, value, SRC_SIZE * sizeof(unsigned char)); \ + CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \ + buf_p += SRC_SIZE; \ + \ + /* +/-SNaN */ \ + H5T__bit_set(value, (size_t)0, (size_t)1, TRUE); \ + CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \ + HDmemcpy(buf_p, value, SRC_SIZE * sizeof(unsigned char)); \ + CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \ + buf_p += SRC_SIZE; \ + \ + /* +/-QNaN */ \ + H5T__bit_set(value, (size_t)(SRC_MANT_DIG - 2), (size_t)1, TRUE); \ + CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \ + HDmemcpy(buf_p, value, SRC_SIZE * sizeof(unsigned char)); \ + CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \ + buf_p += SRC_SIZE; \ + } \ + \ + HDmemcpy(SAVED, BUF, NELMTS *MAX(SRC_SIZE, DST_SIZE)); \ + HDfree(value); \ + } -void some_dummy_func(float x); +void some_dummy_func(float x); static hbool_t overflows(unsigned char *origin_bits, hid_t src_id, size_t dst_num_bits); -static int my_isnan(dtype_t type, void *val); -static int my_isinf(int endian, unsigned char *val, size_t size, - size_t mpos, size_t msize, size_t epos, size_t esize); +static int my_isnan(dtype_t type, void *val); +static int my_isinf(int endian, unsigned char *val, size_t size, size_t mpos, size_t msize, size_t epos, + size_t esize); /*------------------------------------------------------------------------- - * Function: fpe_handler + * Function: fpe_handler * - * Purpose: Exit with 255 + * Purpose: Exit with 255 * - * Return: void + * Return: void * - * Programmer: Robb Matzke + * Programmer: Robb Matzke * Monday, July 6, 1998 * * Modifications: @@ -416,16 +426,15 @@ fpe_handler(int H5_ATTR_UNUSED signo) HDexit(255); } - /*------------------------------------------------------------------------- - * Function: reset_hdf5 + * Function: reset_hdf5 * - * Purpose: Reset the hdf5 library. This causes statistics to be printed - * and counters to be reset. + * Purpose: Reset the hdf5 library. This causes statistics to be printed + * and counters to be reset. * - * Return: void + * Return: void * - * Programmer: Robb Matzke + * Programmer: Robb Matzke * Monday, November 16, 1998 * * Modifications: @@ -437,40 +446,39 @@ reset_hdf5(void) { h5_reset(); - if (without_hardware_g) h5_no_hwconv(); + if (without_hardware_g) + h5_no_hwconv(); #ifdef TEST_ALIGNMENT - SET_ALIGNMENT(SCHAR, H5_SIZEOF_CHAR); - SET_ALIGNMENT(UCHAR, H5_SIZEOF_CHAR); - SET_ALIGNMENT(SHORT, H5_SIZEOF_SHORT); - SET_ALIGNMENT(USHORT, H5_SIZEOF_SHORT); - SET_ALIGNMENT(INT, H5_SIZEOF_INT); - SET_ALIGNMENT(UINT, H5_SIZEOF_INT); - SET_ALIGNMENT(LONG, H5_SIZEOF_LONG); - SET_ALIGNMENT(ULONG, H5_SIZEOF_LONG); - SET_ALIGNMENT(LLONG, H5_SIZEOF_LONG_LONG); - SET_ALIGNMENT(ULLONG, H5_SIZEOF_LONG_LONG); - SET_ALIGNMENT(FLOAT, H5_SIZEOF_FLOAT); - SET_ALIGNMENT(DOUBLE, H5_SIZEOF_DOUBLE); -#if H5_SIZEOF_LONG_DOUBLE !=0 + SET_ALIGNMENT(SCHAR, H5_SIZEOF_CHAR); + SET_ALIGNMENT(UCHAR, H5_SIZEOF_CHAR); + SET_ALIGNMENT(SHORT, H5_SIZEOF_SHORT); + SET_ALIGNMENT(USHORT, H5_SIZEOF_SHORT); + SET_ALIGNMENT(INT, H5_SIZEOF_INT); + SET_ALIGNMENT(UINT, H5_SIZEOF_INT); + SET_ALIGNMENT(LONG, H5_SIZEOF_LONG); + SET_ALIGNMENT(ULONG, H5_SIZEOF_LONG); + SET_ALIGNMENT(LLONG, H5_SIZEOF_LONG_LONG); + SET_ALIGNMENT(ULLONG, H5_SIZEOF_LONG_LONG); + SET_ALIGNMENT(FLOAT, H5_SIZEOF_FLOAT); + SET_ALIGNMENT(DOUBLE, H5_SIZEOF_DOUBLE); +#if H5_SIZEOF_LONG_DOUBLE != 0 SET_ALIGNMENT(LDOUBLE, H5_SIZEOF_LONG_DOUBLE); #endif #endif - } - /*------------------------------------------------------------------------- - * Function: except_func + * Function: except_func * - * Purpose: Gets called for all data type conversion exceptions. + * Purpose: Gets called for all data type conversion exceptions. * - * Return: H5T_CONV_ABORT: -1 + * Return: H5T_CONV_ABORT: -1 * * H5T_CONV_UNHANDLED 0 * * H5T_CONV_HANDLED 1 * - * Programmer: Raymond Lu + * Programmer: Raymond Lu * April 19, 2004 * * Modifications: @@ -478,47 +486,46 @@ reset_hdf5(void) *------------------------------------------------------------------------- */ static H5T_conv_ret_t -except_func(H5T_conv_except_t except_type, hid_t H5_ATTR_UNUSED src_id, hid_t H5_ATTR_UNUSED dst_id, void H5_ATTR_UNUSED *src_buf, - void *dst_buf, void *user_data) +except_func(H5T_conv_except_t except_type, hid_t H5_ATTR_UNUSED src_id, hid_t H5_ATTR_UNUSED dst_id, + void H5_ATTR_UNUSED *src_buf, void *dst_buf, void *user_data) { - H5T_conv_ret_t ret = H5T_CONV_HANDLED; + H5T_conv_ret_t ret = H5T_CONV_HANDLED; - if(except_type == H5T_CONV_EXCEPT_RANGE_HI) + if (except_type == H5T_CONV_EXCEPT_RANGE_HI) /*only test integer case*/ - *(int*)dst_buf = *(int*)user_data; - else if(except_type == H5T_CONV_EXCEPT_RANGE_LOW) + *(int *)dst_buf = *(int *)user_data; + else if (except_type == H5T_CONV_EXCEPT_RANGE_LOW) /*only test integer case*/ - *(int*)dst_buf = *(int*)user_data; - else if(except_type == H5T_CONV_EXCEPT_TRUNCATE) + *(int *)dst_buf = *(int *)user_data; + else if (except_type == H5T_CONV_EXCEPT_TRUNCATE) ret = H5T_CONV_UNHANDLED; - else if(except_type == H5T_CONV_EXCEPT_PRECISION) + else if (except_type == H5T_CONV_EXCEPT_PRECISION) ret = H5T_CONV_UNHANDLED; - else if(except_type == H5T_CONV_EXCEPT_PINF) + else if (except_type == H5T_CONV_EXCEPT_PINF) /*only test integer case*/ - *(int*)dst_buf = *(int*)user_data; - else if(except_type == H5T_CONV_EXCEPT_NINF) + *(int *)dst_buf = *(int *)user_data; + else if (except_type == H5T_CONV_EXCEPT_NINF) /*only test integer case*/ - *(int*)dst_buf = *(int*)user_data; - else if(except_type == H5T_CONV_EXCEPT_NAN) + *(int *)dst_buf = *(int *)user_data; + else if (except_type == H5T_CONV_EXCEPT_NAN) /*only test integer case*/ - *(int*)dst_buf = *(int*)user_data; + *(int *)dst_buf = *(int *)user_data; return ret; } - /*------------------------------------------------------------------------- - * Function: some_dummy_func + * Function: some_dummy_func * - * Purpose: A dummy function to help check for overflow. + * Purpose: A dummy function to help check for overflow. * - * Note: DO NOT DECLARE THIS FUNCTION STATIC OR THE COMPILER MIGHT - * PROMOTE ARGUMENT `x' TO DOUBLE AND DEFEAT THE OVERFLOW - * CHECKING. + * Note: DO NOT DECLARE THIS FUNCTION STATIC OR THE COMPILER MIGHT + * PROMOTE ARGUMENT `x' TO DOUBLE AND DEFEAT THE OVERFLOW + * CHECKING. * - * Return: void + * Return: void * - * Programmer: Robb Matzke + * Programmer: Robb Matzke * Tuesday, July 21, 1998 * *------------------------------------------------------------------------- @@ -526,21 +533,20 @@ except_func(H5T_conv_except_t except_type, hid_t H5_ATTR_UNUSED src_id, hid_t H5 void some_dummy_func(float x) { - char s[128]; + char s[128]; - HDsnprintf(s, sizeof(s), "%g", x); + HDsnprintf(s, sizeof(s), "%g", (double)x); } - /*------------------------------------------------------------------------- - * Function: generates_sigfpe + * Function: generates_sigfpe * - * Purpose: Determines if SIGFPE is generated from overflows. We must be - * able to fork() and waitpid() in order for this test to work - * properly. Sets skip_overflow_tests_g to non-zero if they - * would generate SIGBUS, zero otherwise. + * Purpose: Determines if SIGFPE is generated from overflows. We must be + * able to fork() and waitpid() in order for this test to work + * properly. Sets skip_overflow_tests_g to non-zero if they + * would generate SIGBUS, zero otherwise. * - * Programmer: Robb Matzke + * Programmer: Robb Matzke * Tuesday, July 21, 1998 * * Modifications: @@ -551,38 +557,40 @@ static void generates_sigfpe(void) { #if defined(H5_HAVE_FORK) && defined(H5_HAVE_WAITPID) - pid_t pid; - int status; - size_t i, j; - double d; - unsigned char *dp = (unsigned char*)&d; - float f; + pid_t pid; + int status; + size_t i, j; + double d; + unsigned char *dp = (unsigned char *)&d; + float f; HDfflush(stdout); HDfflush(stderr); - if ((pid=fork()) < 0) { - HDperror("fork"); - HDexit(1); - } else if (0==pid) { - for (i=0; i<2000; i++) { - for(j = 0; j < sizeof(double); j++) + if ((pid = fork()) < 0) { + HDperror("fork"); + HDexit(EXIT_FAILURE); + } + else if (0 == pid) { + for (i = 0; i < 2000; i++) { + for (j = 0; j < sizeof(double); j++) dp[j] = (unsigned char)HDrand(); - f = (float)d; - some_dummy_func((float)f); - } - HDexit(0); + f = (float)d; + some_dummy_func((float)f); + } + HDexit(EXIT_SUCCESS); } - while (pid!=waitpid(pid, &status, 0)) + while (pid != waitpid(pid, &status, 0)) /*void*/; - if (WIFEXITED(status) && 0==WEXITSTATUS(status)) { - HDputs("Floating-point overflow cases will be tested."); - skip_overflow_tests_g = FALSE; - } else if (WIFSIGNALED(status) && SIGFPE==WTERMSIG(status)) { - HDputs("Floating-point overflow cases cannot be safely tested."); - skip_overflow_tests_g = TRUE; - /* delete the core dump file that SIGFPE may have created */ - HDunlink("core"); + if (WIFEXITED(status) && 0 == WEXITSTATUS(status)) { + HDputs("Floating-point overflow cases will be tested."); + skip_overflow_tests_g = FALSE; + } + else if (WIFSIGNALED(status) && SIGFPE == WTERMSIG(status)) { + HDputs("Floating-point overflow cases cannot be safely tested."); + skip_overflow_tests_g = TRUE; + /* delete the core dump file that SIGFPE may have created */ + HDunlink("core"); } #else HDputs("Cannot determine if floating-point overflows generate a SIGFPE;"); @@ -592,7 +600,6 @@ generates_sigfpe(void) #endif } - /*------------------------------------------------------------------------- * Function: test_hard_query * @@ -616,29 +623,31 @@ test_hard_query(void) TESTING("query functions of compiler conversion"); /* Verify the conversion from int to float is a hard conversion. */ - if(H5Tcompiler_conv(H5T_NATIVE_INT, H5T_NATIVE_FLOAT) != TRUE) { + if (H5Tcompiler_conv(H5T_NATIVE_INT, H5T_NATIVE_FLOAT) != TRUE) { H5_FAILED(); - printf("Can't query conversion function\n"); + HDprintf("Can't query conversion function\n"); goto error; - } /* end if */ + } /* Unregister the hard conversion from int to float. Verify the conversion * is a soft conversion. */ - H5Tunregister(H5T_PERS_HARD, NULL, H5T_NATIVE_INT, H5T_NATIVE_FLOAT, H5T__conv_int_float); - if(H5Tcompiler_conv(H5T_NATIVE_INT, H5T_NATIVE_FLOAT) != FALSE) { + H5Tunregister(H5T_PERS_HARD, NULL, H5T_NATIVE_INT, H5T_NATIVE_FLOAT, + (H5T_conv_t)((void (*)(void))H5T__conv_int_float)); + if (H5Tcompiler_conv(H5T_NATIVE_INT, H5T_NATIVE_FLOAT) != FALSE) { H5_FAILED(); - printf("Can't query conversion function\n"); + HDprintf("Can't query conversion function\n"); goto error; - } /* end if */ + } /* Register the hard conversion from int to float. Verify the conversion * is a hard conversion. */ - H5Tregister(H5T_PERS_HARD, "int_flt", H5T_NATIVE_INT, H5T_NATIVE_FLOAT, H5T__conv_int_float); - if(H5Tcompiler_conv(H5T_NATIVE_INT, H5T_NATIVE_FLOAT) != TRUE) { + H5Tregister(H5T_PERS_HARD, "int_flt", H5T_NATIVE_INT, H5T_NATIVE_FLOAT, + (H5T_conv_t)((void (*)(void))H5T__conv_int_float)); + if (H5Tcompiler_conv(H5T_NATIVE_INT, H5T_NATIVE_FLOAT) != TRUE) { H5_FAILED(); - printf("Can't query conversion function\n"); + HDprintf("Can't query conversion function\n"); goto error; - } /* end if */ + } PASSED(); @@ -655,18 +664,17 @@ error: reset_hdf5(); return 1; -} /* end test_hard_query() */ +} - /*------------------------------------------------------------------------- - * Function: expt_handle + * Function: expt_handle * - * Purpose: Gets called from test_particular_fp_integer() for data type + * Purpose: Gets called from test_particular_fp_integer() for data type * conversion exceptions. * - * Return: H5T_CONV_HANDLED 1 + * Return: H5T_CONV_HANDLED 1 * - * Programmer: Raymond Lu + * Programmer: Raymond Lu * Sept 7, 2005 * * Modifications: @@ -674,24 +682,23 @@ error: *------------------------------------------------------------------------- */ static H5T_conv_ret_t -expt_handle(H5T_conv_except_t except_type, hid_t H5_ATTR_UNUSED src_id, hid_t H5_ATTR_UNUSED dst_id, void H5_ATTR_UNUSED *src_buf, - void *dst_buf, void *user_data) +expt_handle(H5T_conv_except_t except_type, hid_t H5_ATTR_UNUSED src_id, hid_t H5_ATTR_UNUSED dst_id, + void H5_ATTR_UNUSED *src_buf, void *dst_buf, void *user_data) { - signed char fill_value1 = 7; - int fill_value2 = 13; + signed char fill_value1 = 7; + int fill_value2 = 13; - if(except_type == H5T_CONV_EXCEPT_RANGE_HI || except_type == H5T_CONV_EXCEPT_RANGE_LOW || - except_type == H5T_CONV_EXCEPT_TRUNCATE) { - if(*(hbool_t*)user_data) - *(signed char*)dst_buf = fill_value1; + if (except_type == H5T_CONV_EXCEPT_RANGE_HI || except_type == H5T_CONV_EXCEPT_RANGE_LOW || + except_type == H5T_CONV_EXCEPT_TRUNCATE) { + if (*(hbool_t *)user_data) + *(signed char *)dst_buf = fill_value1; else - *(int*)dst_buf = fill_value2; + *(int *)dst_buf = fill_value2; } /* end if */ return H5T_CONV_HANDLED; } - /*------------------------------------------------------------------------- * Function: test_particular_fp_integer * @@ -711,95 +718,90 @@ expt_handle(H5T_conv_except_t except_type, hid_t H5_ATTR_UNUSED src_id, hid_t H5 * Return: Success: 0 * * Failure: number of errors - * - * Programmer: Raymond Lu - * Sept 7, 2005 - * - * Modifications: - * *------------------------------------------------------------------------- */ -static int test_particular_fp_integer(void) +static int +test_particular_fp_integer(void) { - hid_t dxpl_id; - hbool_t flag; - double src_d = (double)SCHAR_MAX; - signed char dst_c; + hid_t dxpl_id; + hbool_t flag; + double src_d = (double)SCHAR_MAX; + signed char dst_c; unsigned char *buf1 = NULL, *buf2 = NULL; unsigned char *saved_buf1 = NULL, *saved_buf2 = NULL; - size_t src_size1, src_size2; - size_t dst_size1, dst_size2; - float src_f = (float)INT_MAX; - int dst_i; - int fill_value = 13; - int endian; /*endianess */ - unsigned int fails_this_test = 0; - size_t j; + size_t src_size1, src_size2; + size_t dst_size1, dst_size2; + float src_f = (float)INT_MAX; + int dst_i; + int fill_value = 13; + int endian; /*endianess */ + unsigned int fails_this_test = 0; + size_t j; TESTING("hard particular floating number -> integer conversions"); - if((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) { + if ((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) { H5_FAILED(); - printf("Can't create data transfer property list\n"); + HDprintf("Can't create data transfer property list\n"); goto error; } /* Test conversion from double (the value is SCHAR_MAX) to signed char. */ - endian = H5Tget_order(H5T_NATIVE_DOUBLE); - src_size1 = H5Tget_size(H5T_NATIVE_DOUBLE); - dst_size1 = H5Tget_size(H5T_NATIVE_SCHAR); - buf1 = (unsigned char*)HDcalloc((size_t)1, (size_t)MAX(src_size1, dst_size1)); - saved_buf1 = (unsigned char*)HDcalloc((size_t)1, (size_t)MAX(src_size1, dst_size1)); + endian = H5Tget_order(H5T_NATIVE_DOUBLE); + src_size1 = H5Tget_size(H5T_NATIVE_DOUBLE); + dst_size1 = H5Tget_size(H5T_NATIVE_SCHAR); + buf1 = (unsigned char *)HDcalloc((size_t)1, (size_t)MAX(src_size1, dst_size1)); + saved_buf1 = (unsigned char *)HDcalloc((size_t)1, (size_t)MAX(src_size1, dst_size1)); - memcpy(buf1, &src_d, src_size1); - memcpy(saved_buf1, &src_d, src_size1); + HDmemcpy(buf1, &src_d, src_size1); + HDmemcpy(saved_buf1, &src_d, src_size1); /* Register exception handling function and signal the destination is "signed char". */ flag = 1; - if(H5Pset_type_conv_cb(dxpl_id, expt_handle, &flag) < 0) { + if (H5Pset_type_conv_cb(dxpl_id, expt_handle, &flag) < 0) { H5_FAILED(); - printf("Can't register conversion callback\n"); + HDprintf("Can't register conversion callback\n"); goto error; } /* Do conversion */ - if(H5Tconvert(H5T_NATIVE_DOUBLE, H5T_NATIVE_SCHAR, (size_t)1, buf1, NULL, dxpl_id) < 0) { + if (H5Tconvert(H5T_NATIVE_DOUBLE, H5T_NATIVE_SCHAR, (size_t)1, buf1, NULL, dxpl_id) < 0) { H5_FAILED(); - printf("Can't convert data\n"); + HDprintf("Can't convert data\n"); goto error; } - memcpy(&dst_c, buf1, dst_size1); + HDmemcpy(&dst_c, buf1, dst_size1); /* Print errors */ - if(dst_c != SCHAR_MAX) { - double x; - signed char y; + if (dst_c != SCHAR_MAX) { + double x; + signed char y; - if(0 == fails_this_test++) + if (0 == fails_this_test++) H5_FAILED(); - printf(" test double to signed char:\n"); - printf(" src = "); - for (j=0; j<src_size1; j++) - printf(" %02x", saved_buf1[ENDIAN(src_size1, j, endian)]); + HDprintf(" test double to signed char:\n"); + HDprintf(" src = "); + for (j = 0; j < src_size1; j++) + HDprintf(" %02x", saved_buf1[ENDIAN(src_size1, j, endian)]); HDmemcpy(&x, saved_buf1, src_size1); - printf(" %29.20e\n", x); + HDprintf(" %29.20e\n", x); - printf(" dst = "); - for (j=0; j<dst_size1; j++) - printf(" %02x", buf1[ENDIAN(dst_size1, j, endian)]); + HDprintf(" dst = "); + for (j = 0; j < dst_size1; j++) + HDprintf(" %02x", buf1[ENDIAN(dst_size1, j, endian)]); HDmemcpy(&y, buf1, dst_size1); - printf(" %29d\n", y); + HDprintf(" %29d\n", y); } /* Test conversion from float (the value is INT_MAX) to int. */ - src_size2 = H5Tget_size(H5T_NATIVE_FLOAT); - dst_size2 = H5Tget_size(H5T_NATIVE_INT); - buf2 = (unsigned char*)HDcalloc((size_t)1, (size_t)MAX(src_size2, dst_size2)); - saved_buf2 = (unsigned char*)HDcalloc((size_t)1, (size_t)MAX(src_size2, dst_size2)); + src_size2 = H5Tget_size(H5T_NATIVE_FLOAT); + dst_size2 = H5Tget_size(H5T_NATIVE_INT); + buf2 = (unsigned char *)HDcalloc((size_t)1, (size_t)MAX(src_size2, dst_size2)); + saved_buf2 = (unsigned char *)HDcalloc((size_t)1, (size_t)MAX(src_size2, dst_size2)); HDmemcpy(buf2, &src_f, src_size2); HDmemcpy(saved_buf2, &src_f, src_size2); @@ -807,54 +809,54 @@ static int test_particular_fp_integer(void) flag = 0; /* Do conversion */ - if(H5Tconvert(H5T_NATIVE_FLOAT, H5T_NATIVE_INT, (size_t)1, buf2, NULL, dxpl_id) < 0) { + if (H5Tconvert(H5T_NATIVE_FLOAT, H5T_NATIVE_INT, (size_t)1, buf2, NULL, dxpl_id) < 0) { H5_FAILED(); - printf("Can't convert data\n"); + HDprintf("Can't convert data\n"); goto error; } - memcpy(&dst_i, buf2, dst_size2); + HDmemcpy(&dst_i, buf2, dst_size2); /* Print errors */ - if(dst_i != fill_value) { + if (dst_i != fill_value) { float x; int y; - if(0 == fails_this_test++) + if (0 == fails_this_test++) H5_FAILED(); - printf(" test float to int:\n"); - printf(" src = "); - for (j=0; j<src_size2; j++) - printf(" %02x", saved_buf2[ENDIAN(src_size2, j, endian)]); + HDprintf(" test float to int:\n"); + HDprintf(" src = "); + for (j = 0; j < src_size2; j++) + HDprintf(" %02x", saved_buf2[ENDIAN(src_size2, j, endian)]); HDmemcpy(&x, saved_buf2, src_size2); - printf(" %29.20e\n", x); + HDprintf(" %29.20e\n", (double)x); - printf(" dst = "); - for (j=0; j<dst_size2; j++) - printf(" %02x", buf2[ENDIAN(dst_size2, j, endian)]); + HDprintf(" dst = "); + for (j = 0; j < dst_size2; j++) + HDprintf(" %02x", buf2[ENDIAN(dst_size2, j, endian)]); HDmemcpy(&y, buf2, dst_size2); - printf(" %29d\n", y); + HDprintf(" %29d\n", y); } - if(fails_this_test) + if (fails_this_test) goto error; - if(H5Pclose(dxpl_id) < 0) { + if (H5Pclose(dxpl_id) < 0) { H5_FAILED(); - printf("Can't close property list\n"); + HDprintf("Can't close property list\n"); goto error; } - if(buf1) + if (buf1) HDfree(buf1); - if(buf2) + if (buf2) HDfree(buf2); - if(saved_buf1) + if (saved_buf1) HDfree(saved_buf1); - if(saved_buf2) + if (saved_buf2) HDfree(saved_buf2); PASSED(); @@ -862,16 +864,15 @@ static int test_particular_fp_integer(void) error: HDfflush(stdout); - H5E_BEGIN_TRY { - H5Pclose(dxpl_id); - } H5E_END_TRY; - if(buf1) + H5E_BEGIN_TRY { H5Pclose(dxpl_id); } + H5E_END_TRY; + if (buf1) HDfree(buf1); - if(buf2) + if (buf2) HDfree(buf2); - if(saved_buf1) + if (saved_buf1) HDfree(saved_buf1); - if(saved_buf2) + if (saved_buf2) HDfree(saved_buf2); /* Restore the default error handler (set in h5_reset()) */ @@ -882,7 +883,6 @@ error: return MAX((int)fails_this_test, 1); } - /*------------------------------------------------------------------------- * Function: test_derived_flt * @@ -902,45 +902,45 @@ error: static int test_derived_flt(void) { - hid_t file=-1, tid1=-1, tid2=-1; - hid_t dxpl_id=-1; - char filename[1024]; - size_t spos, epos, esize, mpos, msize, size; - size_t src_size, dst_size; - unsigned char *buf=NULL, *saved_buf=NULL; - int *aligned=NULL; - int endian; /*endianess */ - size_t nelmts = NTESTELEM; - unsigned int fails_this_test = 0; - const size_t max_fails=40; /*max number of failures*/ - char str[256]; /*message string */ - unsigned int i, j; + hid_t file = -1, tid1 = -1, tid2 = -1; + hid_t dxpl_id = -1; + char filename[1024]; + size_t spos, epos, esize, mpos, msize, size; + size_t src_size, dst_size; + unsigned char *buf = NULL, *saved_buf = NULL; + int * aligned = NULL; + int endian; /*endianess */ + size_t nelmts = NTESTELEM; + unsigned int fails_this_test = 0; + const size_t max_fails = 40; /*max number of failures*/ + char str[256]; /*message string */ + unsigned int i, j; TESTING("user-define and query functions of floating-point types"); /* Create File */ h5_fixname(FILENAME[0], H5P_DEFAULT, filename, sizeof filename); - if((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) { + if ((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) { H5_FAILED(); - printf("Can't create file\n"); + HDprintf("Can't create file\n"); goto error; } - if((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) { + if ((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) { H5_FAILED(); - printf("Can't create data transfer property list\n"); + HDprintf("Can't create data transfer property list\n"); goto error; } - if((tid1 = H5Tcopy(H5T_IEEE_F64LE)) < 0) { + if ((tid1 = H5Tcopy(H5T_IEEE_F64LE)) < 0) { H5_FAILED(); - printf("Can't copy data type\n"); + HDprintf("Can't copy data type\n"); goto error; } - if((tid2 = H5Tcopy(H5T_IEEE_F32LE)) < 0) { + if ((tid2 = H5Tcopy(H5T_IEEE_F32LE)) < 0) { H5_FAILED(); - printf("Can't copy data type\n"); + HDprintf("Can't copy data type\n"); goto error; } @@ -962,80 +962,80 @@ test_derived_flt(void) * holes among the significant bits. Exponent bias usually is set * 2^(n-1)-1, where n is the exponent size. *-----------------------------------------------------------------------*/ - if(H5Tset_fields(tid1, (size_t)44, (size_t)34, (size_t)10, (size_t)3, (size_t)31) < 0) { + if (H5Tset_fields(tid1, (size_t)44, (size_t)34, (size_t)10, (size_t)3, (size_t)31) < 0) { H5_FAILED(); - printf("Can't set fields\n"); + HDprintf("Can't set fields\n"); goto error; } - if(H5Tset_offset(tid1, (size_t)3) < 0) { + if (H5Tset_offset(tid1, (size_t)3) < 0) { H5_FAILED(); - printf("Can't set offset\n"); + HDprintf("Can't set offset\n"); goto error; } - if(H5Tset_precision(tid1, (size_t)42) < 0) { + if (H5Tset_precision(tid1, (size_t)42) < 0) { H5_FAILED(); - printf("Can't set precision 1\n"); + HDprintf("Can't set precision 1\n"); goto error; } - if(H5Tset_size(tid1, (size_t)7) < 0) { + if (H5Tset_size(tid1, (size_t)7) < 0) { H5_FAILED(); - printf("Can't set size\n"); + HDprintf("Can't set size\n"); goto error; } - if(H5Tset_ebias(tid1, (size_t)511) < 0) { + if (H5Tset_ebias(tid1, (size_t)511) < 0) { H5_FAILED(); - printf("Can't set exponent bias\n"); + HDprintf("Can't set exponent bias\n"); goto error; } - if(H5Tset_pad(tid1, H5T_PAD_ZERO, H5T_PAD_ZERO) < 0) { + if (H5Tset_pad(tid1, H5T_PAD_ZERO, H5T_PAD_ZERO) < 0) { H5_FAILED(); - printf("Can't set padding\n"); + HDprintf("Can't set padding\n"); goto error; } - if(H5Tcommit2(file, "new float type 1", tid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0) { + if (H5Tcommit2(file, "new float type 1", tid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0) { H5_FAILED(); - printf("Can't set inpad\n"); + HDprintf("Can't set inpad\n"); goto error; } - if(H5Tclose(tid1) < 0) { + if (H5Tclose(tid1) < 0) { H5_FAILED(); - printf("Can't close datatype\n"); + HDprintf("Can't close datatype\n"); goto error; } - if((tid1 = H5Topen2(file, "new float type 1", H5P_DEFAULT)) < 0) + if ((tid1 = H5Topen2(file, "new float type 1", H5P_DEFAULT)) < 0) FAIL_PUTS_ERROR("Can't open datatype") - if(H5Tget_fields(tid1, &spos, &epos, &esize, &mpos, &msize) < 0) { + if (H5Tget_fields(tid1, &spos, &epos, &esize, &mpos, &msize) < 0) { H5_FAILED(); - printf("Can't get fields\n"); + HDprintf("Can't get fields\n"); goto error; } - if(spos != 44 || epos != 34 || esize != 10 || mpos != 3 || msize != 31) { + if (spos != 44 || epos != 34 || esize != 10 || mpos != 3 || msize != 31) { H5_FAILED(); - printf("Wrong field values\n"); + HDprintf("Wrong field values\n"); goto error; } - if(H5Tget_precision(tid1) != 42) { + if (H5Tget_precision(tid1) != 42) { H5_FAILED(); - printf("Can't get precision or wrong precision\n"); + HDprintf("Can't get precision or wrong precision\n"); goto error; } - if(H5Tget_offset(tid1)!=3) { + if (H5Tget_offset(tid1) != 3) { H5_FAILED(); - printf("Can't get offset or wrong offset\n"); + HDprintf("Can't get offset or wrong offset\n"); goto error; } - if((size = H5Tget_size(tid1))!=7) { + if ((size = H5Tget_size(tid1)) != 7) { H5_FAILED(); - printf("Can't get size or wrong size\n"); + HDprintf("Can't get size or wrong size\n"); goto error; } - if(H5Tget_ebias(tid1)!=511) { + if (H5Tget_ebias(tid1) != 511) { H5_FAILED(); - printf("Can't get exponent bias or wrong bias\n"); + HDprintf("Can't get exponent bias or wrong bias\n"); goto error; } @@ -1043,63 +1043,64 @@ test_derived_flt(void) * Then convert data from the floating-point type back to native integer. * Compare the final data with the original data. */ - src_size = H5Tget_size(H5T_NATIVE_INT); - endian = H5Tget_order(H5T_NATIVE_INT); - buf = (unsigned char *)HDmalloc(nelmts * (MAX(src_size, size))); + src_size = H5Tget_size(H5T_NATIVE_INT); + endian = H5Tget_order(H5T_NATIVE_INT); + buf = (unsigned char *)HDmalloc(nelmts * (MAX(src_size, size))); saved_buf = (unsigned char *)HDmalloc(nelmts * src_size); HDmemset(buf, 0, nelmts * MAX(src_size, size)); HDmemset(saved_buf, 0, nelmts * src_size); aligned = (int *)HDcalloc((size_t)1, src_size); - for(i = 0; i < nelmts * src_size; i++) + for (i = 0; i < nelmts * src_size; i++) buf[i] = saved_buf[i] = (unsigned char)HDrand(); /* Convert data from native integer to derived floating-point type. * The mantissa is big enough to retain the integer's precision. */ - if(H5Tconvert(H5T_NATIVE_INT, tid1, nelmts, buf, NULL, dxpl_id) < 0) { + if (H5Tconvert(H5T_NATIVE_INT, tid1, nelmts, buf, NULL, dxpl_id) < 0) { H5_FAILED(); - printf("Can't convert data\n"); + HDprintf("Can't convert data\n"); goto error; } /* Convert data from the derived floating-point type back to native integer. */ - if(H5Tconvert(tid1, H5T_NATIVE_INT, nelmts, buf, NULL, dxpl_id) < 0) { + if (H5Tconvert(tid1, H5T_NATIVE_INT, nelmts, buf, NULL, dxpl_id) < 0) { H5_FAILED(); - printf("Can't convert data\n"); + HDprintf("Can't convert data\n"); goto error; } /* Are the values still the same?*/ - for(i=0; i<nelmts; i++) { - for(j=0; j<src_size; j++) - if(buf[i*src_size+j]!=saved_buf[i*src_size+j]) - break; - if(j==src_size) - continue; /*no error*/ + for (i = 0; i < nelmts; i++) { + for (j = 0; j < src_size; j++) + if (buf[i * src_size + j] != saved_buf[i * src_size + j]) + break; + if (j == src_size) + continue; /*no error*/ /* Print errors */ - if (0==fails_this_test++) { - HDsnprintf(str, sizeof(str), "\nTesting random sw derived floating-point -> derived floating-point conversions"); - printf("%-70s", str); - HDfflush(stdout); + if (0 == fails_this_test++) { + HDsnprintf(str, sizeof(str), + "\nTesting random sw derived floating-point -> derived floating-point conversions"); + HDprintf("%-70s", str); + HDfflush(stdout); H5_FAILED(); } - printf(" test %u elmt %u: \n", 1, (unsigned)i); + HDprintf(" test %u elmt %u: \n", 1, (unsigned)i); - printf(" src = "); - for (j=0; j<src_size; j++) - printf(" %02x", saved_buf[i*src_size+ENDIAN(src_size, j, endian)]); + HDprintf(" src = "); + for (j = 0; j < src_size; j++) + HDprintf(" %02x", saved_buf[i * src_size + ENDIAN(src_size, j, endian)]); - HDmemcpy(aligned, saved_buf+i*sizeof(int), sizeof(int)); - printf(" %29d\n", *aligned); + HDmemcpy(aligned, saved_buf + i * sizeof(int), sizeof(int)); + HDprintf(" %29d\n", *aligned); - printf(" dst = "); - for (j=0; j<src_size; j++) - printf(" %02x", buf[i*src_size+ENDIAN(src_size, j, endian)]); + HDprintf(" dst = "); + for (j = 0; j < src_size; j++) + HDprintf(" %02x", buf[i * src_size + ENDIAN(src_size, j, endian)]); - HDmemcpy(aligned, buf+i*sizeof(int), sizeof(int)); - printf(" %29d\n", *aligned); + HDmemcpy(aligned, buf + i * sizeof(int), sizeof(int)); + HDprintf(" %29d\n", *aligned); - if (fails_this_test>=max_fails) { + if (fails_this_test >= max_fails) { HDputs(" maximum failures reached, aborting test..."); goto error; } @@ -1109,9 +1110,9 @@ test_derived_flt(void) HDfree(buf); HDfree(saved_buf); HDfree(aligned); - buf = NULL; + buf = NULL; saved_buf = NULL; - aligned = NULL; + aligned = NULL; /*-------------------------------------------------------------------------- * 2nd floating-point type @@ -1122,79 +1123,79 @@ test_derived_flt(void) * 2 1 0 * SEEEEEEE MMMMMMMM MMMMMMMM *--------------------------------------------------------------------------*/ - if(H5Tset_fields(tid2, (size_t)23, (size_t)16, (size_t)7, (size_t)0, (size_t)16) < 0) { + if (H5Tset_fields(tid2, (size_t)23, (size_t)16, (size_t)7, (size_t)0, (size_t)16) < 0) { H5_FAILED(); - printf("Can't set fields\n"); + HDprintf("Can't set fields\n"); goto error; } - if(H5Tset_offset(tid2, (size_t)0) < 0) { + if (H5Tset_offset(tid2, (size_t)0) < 0) { H5_FAILED(); - printf("Can't set offset\n"); + HDprintf("Can't set offset\n"); goto error; } - if(H5Tset_precision(tid2, (size_t)24) < 0) { + if (H5Tset_precision(tid2, (size_t)24) < 0) { H5_FAILED(); - printf("Can't set precision 2\n"); + HDprintf("Can't set precision 2\n"); goto error; } - if(H5Tset_size(tid2, (size_t)3) < 0) { + if (H5Tset_size(tid2, (size_t)3) < 0) { H5_FAILED(); - printf("Can't set size\n"); + HDprintf("Can't set size\n"); goto error; } - if(H5Tset_ebias(tid2, (size_t)63) < 0) { + if (H5Tset_ebias(tid2, (size_t)63) < 0) { H5_FAILED(); - printf("Can't set size\n"); + HDprintf("Can't set size\n"); goto error; } - if(H5Tset_pad(tid2, H5T_PAD_ZERO, H5T_PAD_ZERO) < 0) { + if (H5Tset_pad(tid2, H5T_PAD_ZERO, H5T_PAD_ZERO) < 0) { H5_FAILED(); - printf("Can't set padding\n"); + HDprintf("Can't set padding\n"); goto error; } - if(H5Tcommit2(file, "new float type 2", tid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0) { + if (H5Tcommit2(file, "new float type 2", tid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0) { H5_FAILED(); - printf("Can't set inpad\n"); + HDprintf("Can't set inpad\n"); goto error; } - if(H5Tclose(tid2) < 0) { + if (H5Tclose(tid2) < 0) { H5_FAILED(); - printf("Can't close datatype\n"); + HDprintf("Can't close datatype\n"); goto error; } - if((tid2 = H5Topen2(file, "new float type 2", H5P_DEFAULT)) < 0) + if ((tid2 = H5Topen2(file, "new float type 2", H5P_DEFAULT)) < 0) FAIL_PUTS_ERROR("Can't open datatype") - if(H5Tget_fields(tid2, &spos, &epos, &esize, &mpos, &msize) < 0) { + if (H5Tget_fields(tid2, &spos, &epos, &esize, &mpos, &msize) < 0) { H5_FAILED(); - printf("Can't get fields\n"); + HDprintf("Can't get fields\n"); goto error; } - if(spos != 23 || epos != 16 || esize != 7 || mpos != 0 || msize != 16) { + if (spos != 23 || epos != 16 || esize != 7 || mpos != 0 || msize != 16) { H5_FAILED(); - printf("Wrong field values\n"); + HDprintf("Wrong field values\n"); goto error; } - if(H5Tget_precision(tid2) != 24) { + if (H5Tget_precision(tid2) != 24) { H5_FAILED(); - printf("Can't get precision or wrong precision\n"); + HDprintf("Can't get precision or wrong precision\n"); goto error; } - if(H5Tget_offset(tid2)!=0) { + if (H5Tget_offset(tid2) != 0) { H5_FAILED(); - printf("Can't get offset or wrong offset\n"); + HDprintf("Can't get offset or wrong offset\n"); goto error; } - if((size = H5Tget_size(tid2))!=3) { + if ((size = H5Tget_size(tid2)) != 3) { H5_FAILED(); - printf("Can't get size or wrong size\n"); + HDprintf("Can't get size or wrong size\n"); goto error; } - if(H5Tget_ebias(tid2)!=63) { + if (H5Tget_ebias(tid2) != 63) { H5_FAILED(); - printf("Can't get exponent bias or wrong bias\n"); + HDprintf("Can't get exponent bias or wrong bias\n"); goto error; } @@ -1202,97 +1203,100 @@ test_derived_flt(void) * Then convert data from the 1st type back to the 2nd type. * Compare the final data with the original data. */ - src_size = H5Tget_size(tid2); - dst_size = H5Tget_size(tid1); - endian = H5Tget_order(tid2); - buf = (unsigned char *)HDmalloc(nelmts * (MAX(src_size, dst_size))); + src_size = H5Tget_size(tid2); + dst_size = H5Tget_size(tid1); + endian = H5Tget_order(tid2); + buf = (unsigned char *)HDmalloc(nelmts * (MAX(src_size, dst_size))); saved_buf = (unsigned char *)HDmalloc(nelmts * src_size); HDmemset(buf, 0, nelmts * MAX(src_size, dst_size)); - HDmemset(saved_buf, 0, nelmts*src_size); + HDmemset(saved_buf, 0, nelmts * src_size); - for(i=0; i<nelmts*src_size; i++) + for (i = 0; i < nelmts * src_size; i++) buf[i] = saved_buf[i] = (unsigned char)HDrand(); /* Convert data from the 2nd to the 1st derived floating-point type. * The mantissa and exponent of the 2nd type are big enough to retain * the precision and exponent power. */ - if(H5Tconvert(tid2, tid1, nelmts, buf, NULL, dxpl_id) < 0) { + if (H5Tconvert(tid2, tid1, nelmts, buf, NULL, dxpl_id) < 0) { H5_FAILED(); - printf("Can't convert data\n"); + HDprintf("Can't convert data\n"); goto error; } /* Convert data from the 1st back to the 2nd derived floating-point type. */ - if(H5Tconvert(tid1, tid2, nelmts, buf, NULL, dxpl_id) < 0) { + if (H5Tconvert(tid1, tid2, nelmts, buf, NULL, dxpl_id) < 0) { H5_FAILED(); - printf("Can't convert data\n"); + HDprintf("Can't convert data\n"); goto error; } /* Are the values still the same?*/ - for(i=0; i<nelmts; i++) { - for(j=0; j<src_size; j++) - if(buf[i*src_size+j]!=saved_buf[i*src_size+j]) - break; - if(j==src_size) - continue; /*no error*/ + for (i = 0; i < nelmts; i++) { + for (j = 0; j < src_size; j++) + if (buf[i * src_size + j] != saved_buf[i * src_size + j]) + break; + if (j == src_size) + continue; /*no error*/ /* If original value is NaN(exponent bits are all ones, 11..11), * the library simply sets all mantissa bits to ones. So don't * compare values in this case. */ - if((buf[i*src_size+2]==0x7f && saved_buf[i*src_size+2]==0x7f) || - (buf[i*src_size+2]==0xff && saved_buf[i*src_size+2]==0xff)) + if ((buf[i * src_size + 2] == 0x7f && saved_buf[i * src_size + 2] == 0x7f) || + (buf[i * src_size + 2] == 0xff && saved_buf[i * src_size + 2] == 0xff)) continue; /* Print errors */ - if (0==fails_this_test++) { - HDsnprintf(str, sizeof(str), "\nTesting random sw derived floating-point -> derived floating-point conversions"); - printf("%-70s", str); - HDfflush(stdout); + if (0 == fails_this_test++) { + HDsnprintf(str, sizeof(str), + "\nTesting random sw derived floating-point -> derived floating-point conversions"); + HDprintf("%-70s", str); + HDfflush(stdout); H5_FAILED(); } - printf(" test %u elmt %u: \n", 1, (unsigned)i); + HDprintf(" test %u elmt %u: \n", 1, (unsigned)i); - printf(" src = "); - for (j=0; j<src_size; j++) - printf(" %02x", saved_buf[i*src_size+ENDIAN(src_size, j, endian)]); - printf("\n"); + HDprintf(" src = "); + for (j = 0; j < src_size; j++) + HDprintf(" %02x", saved_buf[i * src_size + ENDIAN(src_size, j, endian)]); + HDprintf("\n"); - printf(" dst = "); - for (j=0; j<src_size; j++) - printf(" %02x", buf[i*src_size+ENDIAN(src_size, j, endian)]); - printf("\n"); + HDprintf(" dst = "); + for (j = 0; j < src_size; j++) + HDprintf(" %02x", buf[i * src_size + ENDIAN(src_size, j, endian)]); + HDprintf("\n"); - if (fails_this_test>=max_fails) { + if (fails_this_test >= max_fails) { HDputs(" maximum failures reached, aborting test..."); goto error; } } - if (buf) HDfree(buf); - if (saved_buf) HDfree(saved_buf); + if (buf) + HDfree(buf); + if (saved_buf) + HDfree(saved_buf); - if(H5Tclose(tid1) < 0) { + if (H5Tclose(tid1) < 0) { H5_FAILED(); - printf("Can't close datatype\n"); + HDprintf("Can't close datatype\n"); goto error; } - if(H5Tclose(tid2) < 0) { + if (H5Tclose(tid2) < 0) { H5_FAILED(); - printf("Can't close datatype\n"); + HDprintf("Can't close datatype\n"); goto error; } - if(H5Pclose(dxpl_id) < 0) { + if (H5Pclose(dxpl_id) < 0) { H5_FAILED(); - printf("Can't close property list\n"); + HDprintf("Can't close property list\n"); goto error; } - if(H5Fclose(file) < 0) { + if (H5Fclose(file) < 0) { H5_FAILED(); - printf("Can't close file\n"); + HDprintf("Can't close file\n"); goto error; } /* end if */ @@ -1301,21 +1305,26 @@ test_derived_flt(void) /* Restore the default error handler (set in h5_reset()) */ h5_restore_err(); - reset_hdf5(); /*print statistics*/ + reset_hdf5(); /*print statistics*/ return 0; - error: - if (buf) HDfree(buf); - if (saved_buf) HDfree(saved_buf); - if (aligned) HDfree(aligned); +error: + if (buf) + HDfree(buf); + if (saved_buf) + HDfree(saved_buf); + if (aligned) + HDfree(aligned); HDfflush(stdout); - H5E_BEGIN_TRY { - H5Tclose (tid1); - H5Tclose (tid2); - H5Pclose (dxpl_id); - H5Fclose (file); - } H5E_END_TRY; + H5E_BEGIN_TRY + { + H5Tclose(tid1); + H5Tclose(tid2); + H5Pclose(dxpl_id); + H5Fclose(file); + } + H5E_END_TRY; /* Restore the default error handler (set in h5_reset()) */ h5_restore_err(); @@ -1325,7 +1334,6 @@ test_derived_flt(void) return MAX((int)fails_this_test, 1); } - /*------------------------------------------------------------------------- * Function: test_derived_integer * @@ -1345,43 +1353,43 @@ test_derived_flt(void) static int test_derived_integer(void) { - hid_t file=-1, tid1=-1, tid2=-1; - hid_t dxpl_id=-1; - char filename[1024]; - size_t src_size, dst_size; - unsigned char *buf=NULL, *saved_buf=NULL; - int endian; /*endianess */ - size_t nelmts = NTESTELEM; - unsigned int fails_this_test = 0; - const size_t max_fails=40; /*max number of failures*/ - char str[256]; /*message string */ - unsigned int i, j; + hid_t file = -1, tid1 = -1, tid2 = -1; + hid_t dxpl_id = -1; + char filename[1024]; + size_t src_size, dst_size; + unsigned char *buf = NULL, *saved_buf = NULL; + int endian; /*endianess */ + size_t nelmts = NTESTELEM; + unsigned int fails_this_test = 0; + const size_t max_fails = 40; /*max number of failures*/ + char str[256]; /*message string */ + unsigned int i, j; TESTING("user-define and query functions of integer types"); /* Create File */ h5_fixname(FILENAME[1], H5P_DEFAULT, filename, sizeof filename); - if((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) { + if ((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) { H5_FAILED(); - printf("Can't create file\n"); + HDprintf("Can't create file\n"); goto error; } - if((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) { + if ((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) { H5_FAILED(); - printf("Can't create data transfer property list\n"); + HDprintf("Can't create data transfer property list\n"); goto error; } - if((tid1 = H5Tcopy(H5T_STD_I32LE)) < 0) { + if ((tid1 = H5Tcopy(H5T_STD_I32LE)) < 0) { H5_FAILED(); - printf("Can't copy data type\n"); + HDprintf("Can't copy data type\n"); goto error; } - if((tid2 = H5Tcopy(H5T_STD_U64LE)) < 0) { + if ((tid2 = H5Tcopy(H5T_STD_U64LE)) < 0) { H5_FAILED(); - printf("Can't copy data type\n"); + HDprintf("Can't copy data type\n"); goto error; } @@ -1397,62 +1405,62 @@ test_derived_integer(void) * of a new integer type, H5Tset_precision, H5Tset_offset, H5Tset_size, * H5Tset_order, H5Tset_pad, H5Tset_sign. *--------------------------------------------------------------------------*/ - if(H5Tset_offset(tid1, (size_t)0) < 0) { + if (H5Tset_offset(tid1, (size_t)0) < 0) { H5_FAILED(); - printf("Can't set offset\n"); + HDprintf("Can't set offset\n"); goto error; } - if(H5Tset_size(tid1, (size_t)3) < 0) { + if (H5Tset_size(tid1, (size_t)3) < 0) { H5_FAILED(); - printf("Can't set size\n"); + HDprintf("Can't set size\n"); goto error; } - if(H5Tset_precision(tid1, (size_t)24) < 0) { + if (H5Tset_precision(tid1, (size_t)24) < 0) { H5_FAILED(); - printf("Can't set precision\n"); + HDprintf("Can't set precision\n"); goto error; } - if(H5Tset_order(tid1, H5T_ORDER_BE) < 0) { + if (H5Tset_order(tid1, H5T_ORDER_BE) < 0) { H5_FAILED(); - printf("Can't set order\n"); + HDprintf("Can't set order\n"); goto error; } - if(H5Tcommit2(file, "new integer type 1", tid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0) { + if (H5Tcommit2(file, "new integer type 1", tid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0) { H5_FAILED(); - printf("Can't commit data type\n"); + HDprintf("Can't commit data type\n"); goto error; } - if(H5Tclose(tid1) < 0) { + if (H5Tclose(tid1) < 0) { H5_FAILED(); - printf("Can't close datatype\n"); + HDprintf("Can't close datatype\n"); goto error; } - if((tid1 = H5Topen2(file, "new integer type 1", H5P_DEFAULT)) < 0) + if ((tid1 = H5Topen2(file, "new integer type 1", H5P_DEFAULT)) < 0) FAIL_PUTS_ERROR("Can't open datatype") - if(H5Tget_precision(tid1) != 24) { + if (H5Tget_precision(tid1) != 24) { H5_FAILED(); - printf("Can't get precision or wrong precision\n"); + HDprintf("Can't get precision or wrong precision\n"); goto error; } - if(H5Tget_offset(tid1) != 0) { + if (H5Tget_offset(tid1) != 0) { H5_FAILED(); - printf("Can't get offset or wrong offset\n"); + HDprintf("Can't get offset or wrong offset\n"); goto error; } - if(H5Tget_size(tid1) != 3) { + if (H5Tget_size(tid1) != 3) { H5_FAILED(); - printf("Can't get size or wrong size\n"); + HDprintf("Can't get size or wrong size\n"); goto error; } - if(H5Tget_order(tid1)!=H5T_ORDER_BE) { + if (H5Tget_order(tid1) != H5T_ORDER_BE) { H5_FAILED(); - printf("Can't get order or wrong order\n"); + HDprintf("Can't get order or wrong order\n"); goto error; } @@ -1464,56 +1472,56 @@ test_derived_integer(void) * 7 6 5 4 3 2 1 0 * ??????SI IIIIIIII IIIIIIII IIIIIIII IIIIIIII IIIIIIII IIIIII?? ???????? *--------------------------------------------------------------------------*/ - if(H5Tset_precision(tid2, (size_t)48) < 0) { + if (H5Tset_precision(tid2, (size_t)48) < 0) { H5_FAILED(); - printf("Can't set precision\n"); + HDprintf("Can't set precision\n"); goto error; } - if(H5Tset_offset(tid2, (size_t)10) < 0) { + if (H5Tset_offset(tid2, (size_t)10) < 0) { H5_FAILED(); - printf("Can't set offset\n"); + HDprintf("Can't set offset\n"); goto error; } - if(H5Tset_sign(tid2, H5T_SGN_2) < 0) { + if (H5Tset_sign(tid2, H5T_SGN_2) < 0) { H5_FAILED(); - printf("Can't set offset\n"); + HDprintf("Can't set offset\n"); goto error; } - if(H5Tcommit2(file, "new integer type 2", tid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0) { + if (H5Tcommit2(file, "new integer type 2", tid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0) { H5_FAILED(); - printf("Can't commit data type\n"); + HDprintf("Can't commit data type\n"); goto error; } - if(H5Tclose(tid2) < 0) { + if (H5Tclose(tid2) < 0) { H5_FAILED(); - printf("Can't close datatype\n"); + HDprintf("Can't close datatype\n"); goto error; } - if((tid2 = H5Topen2(file, "new integer type 2", H5P_DEFAULT)) < 0) + if ((tid2 = H5Topen2(file, "new integer type 2", H5P_DEFAULT)) < 0) FAIL_PUTS_ERROR("Can't open datatype") - if(H5Tget_precision(tid2) != 48) { + if (H5Tget_precision(tid2) != 48) { H5_FAILED(); - printf("Can't get precision or wrong precision\n"); + HDprintf("Can't get precision or wrong precision\n"); goto error; } - if(H5Tget_offset(tid2) != 10) { + if (H5Tget_offset(tid2) != 10) { H5_FAILED(); - printf("Can't get offset or wrong offset\n"); + HDprintf("Can't get offset or wrong offset\n"); goto error; } - if(H5Tget_size(tid2) != 8) { + if (H5Tget_size(tid2) != 8) { H5_FAILED(); - printf("Can't get size or wrong size\n"); + HDprintf("Can't get size or wrong size\n"); goto error; } - if(H5Tget_sign(tid2)!=H5T_SGN_2) { + if (H5Tget_sign(tid2) != H5T_SGN_2) { H5_FAILED(); - printf("Can't get sign or wrong sign\n"); + HDprintf("Can't get sign or wrong sign\n"); goto error; } @@ -1521,86 +1529,87 @@ test_derived_integer(void) * Then convert data from the 2nd type back to the 1st type. * Compare the final data with the original data. */ - src_size = H5Tget_size(tid1); - dst_size = H5Tget_size(tid2); - endian = H5Tget_order(tid1); - buf = (unsigned char *)HDmalloc(nelmts*(MAX(src_size, dst_size))); - saved_buf = (unsigned char *)HDmalloc(nelmts*src_size); + src_size = H5Tget_size(tid1); + dst_size = H5Tget_size(tid2); + endian = H5Tget_order(tid1); + buf = (unsigned char *)HDmalloc(nelmts * (MAX(src_size, dst_size))); + saved_buf = (unsigned char *)HDmalloc(nelmts * src_size); HDmemset(buf, 0, nelmts * MAX(src_size, dst_size)); - HDmemset(saved_buf, 0, nelmts*src_size); + HDmemset(saved_buf, 0, nelmts * src_size); - for(i=0; i<nelmts * src_size; i++) + for (i = 0; i < nelmts * src_size; i++) buf[i] = saved_buf[i] = (unsigned char)HDrand(); /* Convert data from the 1st to the 2nd derived integer type. * The precision of the 2nd type are big enough to retain * the 1st type's precision. */ - if(H5Tconvert(tid1, tid2, nelmts, buf, NULL, dxpl_id) < 0) { + if (H5Tconvert(tid1, tid2, nelmts, buf, NULL, dxpl_id) < 0) { H5_FAILED(); - printf("Can't convert data\n"); + HDprintf("Can't convert data\n"); goto error; } /* Convert data from the 2nd back to the 1st derived integer type. */ - if(H5Tconvert(tid2, tid1, nelmts, buf, NULL, dxpl_id) < 0) { + if (H5Tconvert(tid2, tid1, nelmts, buf, NULL, dxpl_id) < 0) { H5_FAILED(); - printf("Can't convert data\n"); + HDprintf("Can't convert data\n"); goto error; } /* Are the values still the same?*/ - for(i=0; i<nelmts; i++) { - for(j=0; j<src_size; j++) - if(buf[i*src_size+j]!=saved_buf[i*src_size+j]) - break; - if(j==src_size) - continue; /*no error*/ + for (i = 0; i < nelmts; i++) { + for (j = 0; j < src_size; j++) + if (buf[i * src_size + j] != saved_buf[i * src_size + j]) + break; + if (j == src_size) + continue; /*no error*/ /* Print errors */ - if (0==fails_this_test++) { - HDsnprintf(str, sizeof(str), "\nTesting random sw derived integer -> derived integer conversions"); - printf("%-70s", str); - HDfflush(stdout); + if (0 == fails_this_test++) { + HDsnprintf(str, sizeof(str), + "\nTesting random sw derived integer -> derived integer conversions"); + HDprintf("%-70s", str); + HDfflush(stdout); H5_FAILED(); } - printf(" test %u elmt %u: \n", 1, (unsigned)i); + HDprintf(" test %u elmt %u: \n", 1, (unsigned)i); - printf(" src = "); - for (j=0; j<src_size; j++) - printf(" %02x", saved_buf[i*src_size+ENDIAN(src_size, j, endian)]); - printf("\n"); + HDprintf(" src = "); + for (j = 0; j < src_size; j++) + HDprintf(" %02x", saved_buf[i * src_size + ENDIAN(src_size, j, endian)]); + HDprintf("\n"); - printf(" dst = "); - for (j=0; j<src_size; j++) - printf(" %02x", buf[i*src_size+ENDIAN(src_size, j, endian)]); - printf("\n"); + HDprintf(" dst = "); + for (j = 0; j < src_size; j++) + HDprintf(" %02x", buf[i * src_size + ENDIAN(src_size, j, endian)]); + HDprintf("\n"); - if (fails_this_test>=max_fails) { + if (fails_this_test >= max_fails) { HDputs(" maximum failures reached, aborting test..."); goto error; } } - if(H5Tclose(tid1) < 0) { + if (H5Tclose(tid1) < 0) { H5_FAILED(); - printf("Can't close datatype\n"); + HDprintf("Can't close datatype\n"); goto error; } - if(H5Tclose(tid2) < 0) { + if (H5Tclose(tid2) < 0) { H5_FAILED(); - printf("Can't close datatype\n"); + HDprintf("Can't close datatype\n"); goto error; } - if(H5Pclose(dxpl_id) < 0) { + if (H5Pclose(dxpl_id) < 0) { H5_FAILED(); - printf("Can't close property list\n"); + HDprintf("Can't close property list\n"); goto error; } - if(H5Fclose(file) < 0) { + if (H5Fclose(file) < 0) { H5_FAILED(); - printf("Can't close file\n"); + HDprintf("Can't close file\n"); goto error; } /* end if */ @@ -1612,20 +1621,24 @@ test_derived_integer(void) /* Restore the default error handler (set in h5_reset()) */ h5_restore_err(); - reset_hdf5(); /*print statistics*/ + reset_hdf5(); /*print statistics*/ return 0; - error: - if (buf) HDfree(buf); - if (saved_buf) HDfree(saved_buf); +error: + if (buf) + HDfree(buf); + if (saved_buf) + HDfree(saved_buf); HDfflush(stdout); - H5E_BEGIN_TRY { - H5Tclose (tid1); - H5Tclose (tid2); - H5Pclose (dxpl_id); - H5Fclose (file); - } H5E_END_TRY; + H5E_BEGIN_TRY + { + H5Tclose(tid1); + H5Tclose(tid2); + H5Pclose(dxpl_id); + H5Fclose(file); + } + H5E_END_TRY; /* Restore the default error handler (set in h5_reset()) */ h5_restore_err(); @@ -1635,24 +1648,23 @@ test_derived_integer(void) return MAX((int)fails_this_test, 1); } - /*------------------------------------------------------------------------- - * Function: test_conv_int_1 + * Function: test_conv_int_1 * - * Purpose: Test conversion of integer values from SRC to DST. - * These types should be any combination of: + * Purpose: Test conversion of integer values from SRC to DST. + * These types should be any combination of: * - * H5T_NATIVE_SCHAR H5T_NATIVE_UCHAR - * H5T_NATIVE_SHORT H5T_NATIVE_USHORT - * H5T_NATIVE_INT H5T_NATIVE_UINT - * H5T_NATIVE_LONG H5T_NATIVE_ULONG - * H5T_NATIVE_LLONG H5T_NATIVE_ULLONG + * H5T_NATIVE_SCHAR H5T_NATIVE_UCHAR + * H5T_NATIVE_SHORT H5T_NATIVE_USHORT + * H5T_NATIVE_INT H5T_NATIVE_UINT + * H5T_NATIVE_LONG H5T_NATIVE_ULONG + * H5T_NATIVE_LLONG H5T_NATIVE_ULLONG * - * Return: Success: 0 + * Return: Success: 0 * - * Failure: number of errors + * Failure: number of errors * - * Programmer: Robb Matzke + * Programmer: Robb Matzke * Monday, November 16, 1998 * * Modifications: @@ -1662,160 +1674,189 @@ test_derived_integer(void) static int test_conv_int_1(const char *name, hid_t src, hid_t dst) { - size_t nelmts=0; /*num values per test */ - const size_t max_fails=8; /*max number of failures*/ - size_t fails_all_tests=0; /*number of failures */ - size_t fails_this_test; /*fails for this test */ - char str[256]; /*hello string */ - dtype_t src_type, dst_type; /*data types */ - const char *src_type_name=NULL; /*source type name */ - const char *dst_type_name=NULL; /*destination type name */ - int endian; /*machine endianess */ - size_t src_size, dst_size; /*type sizes */ - unsigned char *buf=NULL; /*buffer for conversion */ - unsigned char *saved=NULL; /*original values */ - size_t j, k; /*counters */ - unsigned char *hw=NULL; /*hardware conv result */ - unsigned char src_bits[32]; /*src value in LE order */ - unsigned char dst_bits[32]; /*dest value in LE order*/ - size_t src_nbits; /*source length in bits */ - size_t dst_nbits; /*dst length in bits */ - H5T_sign_t src_sign; /*source sign type */ - H5T_sign_t dst_sign; /*dst sign type */ - void *aligned=NULL; /*aligned temp buffer */ - signed char hw_char; - unsigned char hw_uchar; - short hw_short; - unsigned short hw_ushort; - int hw_int; - unsigned hw_uint; - long hw_long; - unsigned long hw_ulong; - long long hw_llong; - unsigned long long hw_ullong; + size_t nelmts = 0; /*num values per test */ + const size_t max_fails = 8; /*max number of failures*/ + size_t fails_all_tests = 0; /*number of failures */ + size_t fails_this_test; /*fails for this test */ + char str[256]; /*hello string */ + dtype_t src_type, dst_type; /*data types */ + const char * src_type_name = NULL; /*source type name */ + const char * dst_type_name = NULL; /*destination type name */ + int endian; /*machine endianess */ + size_t src_size, dst_size; /*type sizes */ + unsigned char * buf = NULL; /*buffer for conversion */ + unsigned char * saved = NULL; /*original values */ + size_t j, k; /*counters */ + unsigned char * hw = NULL; /*hardware conv result */ + unsigned char src_bits[32]; /*src value in LE order */ + unsigned char dst_bits[32]; /*dest value in LE order*/ + size_t src_nbits; /*source length in bits */ + size_t dst_nbits; /*dst length in bits */ + H5T_sign_t src_sign; /*source sign type */ + H5T_sign_t dst_sign; /*dst sign type */ + void * aligned = NULL; /*aligned temp buffer */ + signed char hw_char; + unsigned char hw_uchar; + short hw_short; + unsigned short hw_ushort; + int hw_int; + unsigned hw_uint; + long hw_long; + unsigned long hw_ulong; + long long hw_llong; + unsigned long long hw_ullong; /* What are the names of the source and destination types */ if (H5Tequal(src, H5T_NATIVE_SCHAR)) { - src_type_name = "signed char"; - src_type = INT_SCHAR; - } else if (H5Tequal(src, H5T_NATIVE_UCHAR)) { - src_type_name = "unsigned char"; - src_type = INT_UCHAR; - } else if (H5Tequal(src, H5T_NATIVE_SHORT)) { - src_type_name = "short"; - src_type = INT_SHORT; - } else if (H5Tequal(src, H5T_NATIVE_USHORT)) { - src_type_name = "unsigned short"; - src_type = INT_USHORT; - } else if (H5Tequal(src, H5T_NATIVE_INT)) { - src_type_name = "int"; - src_type = INT_INT; - } else if (H5Tequal(src, H5T_NATIVE_UINT)) { - src_type_name = "unsigned int"; - src_type = INT_UINT; - } else if (H5Tequal(src, H5T_NATIVE_LONG)) { - src_type_name = "long"; - src_type = INT_LONG; - } else if (H5Tequal(src, H5T_NATIVE_ULONG)) { - src_type_name = "unsigned long"; - src_type = INT_ULONG; - } else if (H5Tequal(src, H5T_NATIVE_LLONG)) { - src_type_name = "long long"; - src_type = INT_LLONG; - } else if (H5Tequal(src, H5T_NATIVE_ULLONG)) { - src_type_name = "unsigned long long"; - src_type = INT_ULLONG; - } else { - src_type_name = "UNKNOWN"; - src_type = OTHER; + src_type_name = "signed char"; + src_type = INT_SCHAR; + } + else if (H5Tequal(src, H5T_NATIVE_UCHAR)) { + src_type_name = "unsigned char"; + src_type = INT_UCHAR; + } + else if (H5Tequal(src, H5T_NATIVE_SHORT)) { + src_type_name = "short"; + src_type = INT_SHORT; + } + else if (H5Tequal(src, H5T_NATIVE_USHORT)) { + src_type_name = "unsigned short"; + src_type = INT_USHORT; + } + else if (H5Tequal(src, H5T_NATIVE_INT)) { + src_type_name = "int"; + src_type = INT_INT; + } + else if (H5Tequal(src, H5T_NATIVE_UINT)) { + src_type_name = "unsigned int"; + src_type = INT_UINT; + } + else if (H5Tequal(src, H5T_NATIVE_LONG)) { + src_type_name = "long"; + src_type = INT_LONG; + } + else if (H5Tequal(src, H5T_NATIVE_ULONG)) { + src_type_name = "unsigned long"; + src_type = INT_ULONG; + } + else if (H5Tequal(src, H5T_NATIVE_LLONG)) { + src_type_name = "long long"; + src_type = INT_LLONG; + } + else if (H5Tequal(src, H5T_NATIVE_ULLONG)) { + src_type_name = "unsigned long long"; + src_type = INT_ULLONG; + } + else { + src_type_name = "UNKNOWN"; + src_type = OTHER; } if (H5Tequal(dst, H5T_NATIVE_SCHAR)) { - dst_type_name = "signed char"; - dst_type = INT_SCHAR; - } else if (H5Tequal(dst, H5T_NATIVE_UCHAR)) { - dst_type_name = "unsigned char"; - dst_type = INT_UCHAR; - } else if (H5Tequal(dst, H5T_NATIVE_SHORT)) { - dst_type_name = "short"; - dst_type = INT_SHORT; - } else if (H5Tequal(dst, H5T_NATIVE_USHORT)) { - dst_type_name = "unsigned short"; - dst_type = INT_USHORT; - } else if (H5Tequal(dst, H5T_NATIVE_INT)) { - dst_type_name = "int"; - dst_type = INT_INT; - } else if (H5Tequal(dst, H5T_NATIVE_UINT)) { - dst_type_name = "unsigned int"; - dst_type = INT_UINT; - } else if (H5Tequal(dst, H5T_NATIVE_LONG)) { - dst_type_name = "long"; - dst_type = INT_LONG; - } else if (H5Tequal(dst, H5T_NATIVE_ULONG)) { - dst_type_name = "unsigned long"; - dst_type = INT_ULONG; - } else if (H5Tequal(dst, H5T_NATIVE_LLONG)) { - dst_type_name = "long long"; - dst_type = INT_LLONG; - } else if (H5Tequal(dst, H5T_NATIVE_ULLONG)) { - dst_type_name = "unsigned long long"; - dst_type = INT_ULLONG; - } else { - dst_type_name = "UNKNOWN"; - dst_type = OTHER; + dst_type_name = "signed char"; + dst_type = INT_SCHAR; + } + else if (H5Tequal(dst, H5T_NATIVE_UCHAR)) { + dst_type_name = "unsigned char"; + dst_type = INT_UCHAR; + } + else if (H5Tequal(dst, H5T_NATIVE_SHORT)) { + dst_type_name = "short"; + dst_type = INT_SHORT; + } + else if (H5Tequal(dst, H5T_NATIVE_USHORT)) { + dst_type_name = "unsigned short"; + dst_type = INT_USHORT; + } + else if (H5Tequal(dst, H5T_NATIVE_INT)) { + dst_type_name = "int"; + dst_type = INT_INT; + } + else if (H5Tequal(dst, H5T_NATIVE_UINT)) { + dst_type_name = "unsigned int"; + dst_type = INT_UINT; + } + else if (H5Tequal(dst, H5T_NATIVE_LONG)) { + dst_type_name = "long"; + dst_type = INT_LONG; + } + else if (H5Tequal(dst, H5T_NATIVE_ULONG)) { + dst_type_name = "unsigned long"; + dst_type = INT_ULONG; + } + else if (H5Tequal(dst, H5T_NATIVE_LLONG)) { + dst_type_name = "long long"; + dst_type = INT_LLONG; + } + else if (H5Tequal(dst, H5T_NATIVE_ULLONG)) { + dst_type_name = "unsigned long long"; + dst_type = INT_ULLONG; + } + else { + dst_type_name = "UNKNOWN"; + dst_type = OTHER; } /* Sanity checks */ - if (OTHER==src_type || OTHER==dst_type) { - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, src_type_name, dst_type_name); - printf("%-70s", str); - H5_FAILED(); - HDputs(" Unknown data type."); - goto error; - } else { - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, src_type_name, dst_type_name); - printf("%-70s", str); + if (OTHER == src_type || OTHER == dst_type) { + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, src_type_name, dst_type_name); + HDprintf("%-70s", str); + H5_FAILED(); + HDputs(" Unknown data type."); + goto error; + } + else { + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, src_type_name, dst_type_name); + HDprintf("%-70s", str); HDfflush(stdout); - fails_this_test=0; + fails_this_test = 0; } /* Some information about datatypes */ - endian = H5Tget_order(H5T_NATIVE_INT); - src_size = H5Tget_size(src); - dst_size = H5Tget_size(dst); + endian = H5Tget_order(H5T_NATIVE_INT); + src_size = H5Tget_size(src); + dst_size = H5Tget_size(dst); src_nbits = H5Tget_precision(src); /* not 8*src_size, esp on J90 - QAK */ dst_nbits = H5Tget_precision(dst); /* not 8*dst_size, esp on J90 - QAK */ - src_sign = H5Tget_sign(src); - dst_sign = H5Tget_sign(dst); - aligned = HDcalloc((size_t)1, sizeof(long long)); + src_sign = H5Tget_sign(src); + dst_sign = H5Tget_sign(dst); + aligned = HDcalloc((size_t)1, sizeof(long long)); /* Allocate and initialize the source buffer through macro INIT_INTEGER. The BUF * will be used for the conversion while the SAVED buffer will be * used for the comparison later. */ - if(src_type == INT_SCHAR) { + if (src_type == INT_SCHAR) { INIT_INTEGER(signed char, SCHAR_MAX, SCHAR_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_UCHAR) { + } + else if (src_type == INT_UCHAR) { INIT_INTEGER(unsigned char, UCHAR_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_SHORT) { + } + else if (src_type == INT_SHORT) { INIT_INTEGER(short, SHRT_MAX, SHRT_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_USHORT) { + } + else if (src_type == INT_USHORT) { INIT_INTEGER(unsigned short, USHRT_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_INT) { + } + else if (src_type == INT_INT) { INIT_INTEGER(int, INT_MAX, INT_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_UINT) { + } + else if (src_type == INT_UINT) { INIT_INTEGER(unsigned int, UINT_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_LONG) { + } + else if (src_type == INT_LONG) { INIT_INTEGER(long, LONG_MAX, LONG_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_ULONG) { + } + else if (src_type == INT_ULONG) { INIT_INTEGER(unsigned long, ULONG_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_LLONG) { + } + else if (src_type == INT_LLONG) { INIT_INTEGER(long long, LLONG_MAX, LLONG_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_ULLONG) { + } + else if (src_type == INT_ULLONG) { INIT_INTEGER(unsigned long long, ULLONG_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else + } + else goto error; /* Perform the conversion */ @@ -1823,528 +1864,537 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst) goto error; /* Check the results from the library against hardware */ - for (j=0; j<nelmts; j++) { - if (INT_SCHAR==dst_type) { - hw = (unsigned char*)&hw_char; + for (j = 0; j < nelmts; j++) { + if (INT_SCHAR == dst_type) { + hw = (unsigned char *)&hw_char; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_char = (signed char)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_char = (signed char)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_char = (signed char)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_char = (signed char)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_char = (signed char)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_char = (signed char)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_char = (signed char)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_char = (signed char)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_char = (signed char)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_char = (signed char)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_char = (signed char)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_char = (signed char)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_char = (signed char)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_char = (signed char)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_char = (signed char)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_char = (signed char)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_char = (signed char)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_char = (signed char)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_char = (signed char)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_char = (signed char)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_UCHAR==dst_type) { - hw = (unsigned char*)&hw_uchar; + } + else if (INT_UCHAR == dst_type) { + hw = (unsigned char *)&hw_uchar; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_uchar = (unsigned char)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_uchar = (unsigned char)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_uchar = (unsigned char)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_uchar = (unsigned char)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_uchar = (unsigned char)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_uchar = (unsigned char)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_uchar = (unsigned char)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_uchar = (unsigned char)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_uchar = (unsigned char)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_uchar = (unsigned char)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_uchar = (unsigned char)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_uchar = (unsigned char)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_uchar = (unsigned char)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_uchar = (unsigned char)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_uchar = (unsigned char)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_uchar = (unsigned char)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_uchar = (unsigned char)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_uchar = (unsigned char)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_uchar = (unsigned char)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_uchar = (unsigned char)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_SHORT==dst_type) { - hw = (unsigned char*)&hw_short; + } + else if (INT_SHORT == dst_type) { + hw = (unsigned char *)&hw_short; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(char), sizeof(char)); - hw_short = (short)(*((char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_short = (short)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_short = (short)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_short = (short)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_short = (short)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_short = (short)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_short = (short)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_short = (short)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_short = (short)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_short = (short)(*((unsigned long long*)aligned)); - break; - - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(char), sizeof(char)); + hw_short = (short)(*((char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_short = (short)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_short = (short)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_short = (short)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_short = (short)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_short = (short)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_short = (short)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_short = (short)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_short = (short)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_short = (short)(*((unsigned long long *)aligned)); + break; + + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_USHORT==dst_type) { - hw = (unsigned char*)&hw_ushort; + } + else if (INT_USHORT == dst_type) { + hw = (unsigned char *)&hw_ushort; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_ushort = (unsigned short)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_ushort = (unsigned short)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_ushort = (unsigned short)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_ushort = (unsigned short)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_ushort = (unsigned short)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_ushort = (unsigned short)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_ushort = (unsigned short)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_ushort = (unsigned short)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_ushort = (unsigned short)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_ushort = (unsigned short)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_ushort = (unsigned short)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_ushort = (unsigned short)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_ushort = (unsigned short)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_ushort = (unsigned short)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_ushort = (unsigned short)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_ushort = (unsigned short)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_ushort = (unsigned short)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_ushort = (unsigned short)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_ushort = (unsigned short)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_ushort = (unsigned short)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_INT==dst_type) { - hw = (unsigned char*)&hw_int; + } + else if (INT_INT == dst_type) { + hw = (unsigned char *)&hw_int; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_int = (int)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_int = (int)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_int = (int)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_int = (int)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_int = (int)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_int = (int)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_int = (int)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_int = (int)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_int = (int)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_int = (int)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_int = (int)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_int = (int)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_int = (int)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_int = (int)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_int = (int)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_int = (int)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_int = (int)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_int = (int)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_int = (int)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_int = (int)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_UINT==dst_type) { - hw = (unsigned char*)&hw_uint; + } + else if (INT_UINT == dst_type) { + hw = (unsigned char *)&hw_uint; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_uint = (unsigned int)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_uint = (unsigned int)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_uint = (unsigned int)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_uint = (unsigned int)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_uint = (unsigned int)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_uint = (unsigned int)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_uint = (unsigned int)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_uint = (unsigned int)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_uint = (unsigned int)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_uint = (unsigned int)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_uint = (unsigned int)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_uint = (unsigned int)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_uint = (unsigned int)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_uint = (unsigned int)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_uint = (unsigned int)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_uint = (unsigned int)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_uint = (unsigned int)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_uint = (unsigned int)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_uint = (unsigned int)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_uint = (unsigned int)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_LONG==dst_type) { - hw = (unsigned char*)&hw_long; + } + else if (INT_LONG == dst_type) { + hw = (unsigned char *)&hw_long; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_long = (long int)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_long = (long int)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_long = (long int)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_long = (long int)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_long = (long int)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_long = (long int)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_long = (long int)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_long = (long int)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_long = (long int)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_long = (long int)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_long = (long int)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_long = (long int)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_long = (long int)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_long = (long int)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_long = (long int)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_long = (long int)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_long = (long int)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_long = (long int)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_long = (long int)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_long = (long int)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_ULONG==dst_type) { - hw = (unsigned char*)&hw_ulong; + } + else if (INT_ULONG == dst_type) { + hw = (unsigned char *)&hw_ulong; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_ulong = (unsigned long)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_ulong = (unsigned long)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_ulong = (unsigned long)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_ulong = (unsigned long)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_ulong = (unsigned long)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_ulong = (unsigned long)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_ulong = (unsigned long)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_ulong = (unsigned long)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_ulong = (unsigned long)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_ulong = (unsigned long)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_ulong = (unsigned long)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_ulong = (unsigned long)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_ulong = (unsigned long)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_ulong = (unsigned long)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_ulong = (unsigned long)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_ulong = (unsigned long)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_ulong = (unsigned long)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_ulong = (unsigned long)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_ulong = (unsigned long)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_ulong = (unsigned long)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_LLONG==dst_type) { - hw = (unsigned char*)&hw_llong; + } + else if (INT_LLONG == dst_type) { + hw = (unsigned char *)&hw_llong; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(char), sizeof(char)); - hw_llong = (long long)(*((char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_llong = (long long)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_llong = (long long)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_llong = (long long)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_llong = (long long)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_llong = (long long)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_llong = (long long)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_llong = (long long)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_llong = (long long)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_llong = (long long)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(char), sizeof(char)); + hw_llong = (long long)(*((char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_llong = (long long)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_llong = (long long)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_llong = (long long)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_llong = (long long)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_llong = (long long)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_llong = (long long)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_llong = (long long)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_llong = (long long)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_llong = (long long)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_ULLONG==dst_type) { - hw = (unsigned char*)&hw_ullong; + } + else if (INT_ULLONG == dst_type) { + hw = (unsigned char *)&hw_ullong; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_ullong = (unsigned long long)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_ullong = (unsigned long long)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_ullong = (unsigned long long)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_ullong = (unsigned long long)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_ullong = (unsigned long long)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_ullong = (unsigned long long)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_ullong = (unsigned long long)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_ullong = (unsigned long long)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_ullong = (unsigned long long)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_ullong = (unsigned long long)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_ullong = (unsigned long long)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_ullong = (unsigned long long)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_ullong = (unsigned long long)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_ullong = (unsigned long long)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_ullong = (unsigned long long)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_ullong = (unsigned long long)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_ullong = (unsigned long long)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_ullong = (unsigned long long)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_ullong = (unsigned long long)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_ullong = (unsigned long long)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } } /* Make certain that there isn't some weird number of destination bits */ - assert(dst_nbits%8==0); + assert(dst_nbits % 8 == 0); /* Are the two results the same? */ - for (k=(dst_size-(dst_nbits/8)); k<dst_size; k++) - if (buf[j*dst_size+k]!=hw[k]) + for (k = (dst_size - (dst_nbits / 8)); k < dst_size; k++) + if (buf[j * dst_size + k] != hw[k]) break; - if (k==dst_size) + if (k == dst_size) continue; /*no error*/ /* @@ -2353,64 +2403,67 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst) * certain things. These routines have already been tested by * the `bittests' program. */ - for (k=0; k<src_size; k++) - src_bits[src_size-(k+1)] = saved[j*src_size+ENDIAN(src_size, k, endian)]; + for (k = 0; k < src_size; k++) + src_bits[src_size - (k + 1)] = saved[j * src_size + ENDIAN(src_size, k, endian)]; - for (k=0; k<dst_size; k++) - dst_bits[dst_size-(k+1)] = buf[j*dst_size+ENDIAN(dst_size, k, endian)]; + for (k = 0; k < dst_size; k++) + dst_bits[dst_size - (k + 1)] = buf[j * dst_size + ENDIAN(dst_size, k, endian)]; /* * Hardware usually doesn't handle overflows too gracefully. The * hardware conversion result during overflows is usually garbage * so we must handle those cases differetly when checking results. */ - if (H5T_SGN_2==src_sign && H5T_SGN_2==dst_sign) { - if (src_nbits>dst_nbits) { - if(0==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) && - H5T__bit_find(src_bits, dst_nbits-1, (src_nbits-dst_nbits), - H5T_BIT_MSB, 1)>=0) { + if (H5T_SGN_2 == src_sign && H5T_SGN_2 == dst_sign) { + if (src_nbits > dst_nbits) { + if (0 == H5T__bit_get_d(src_bits, src_nbits - 1, (size_t)1) && + H5T__bit_find(src_bits, dst_nbits - 1, (src_nbits - dst_nbits), H5T_BIT_MSB, 1) >= 0) { /* * Source is positive and the magnitude is too large for * the destination. The destination should be set to the * maximum possible value: 0x7f...f */ - if (0==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) && - H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0) + if (0 == H5T__bit_get_d(dst_bits, dst_nbits - 1, (size_t)1) && + H5T__bit_find(dst_bits, (size_t)0, dst_nbits - 1, H5T_BIT_LSB, 0) < 0) continue; /*no error*/ - } else if (1==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) && - H5T__bit_find(src_bits, (size_t)0, src_nbits-1, H5T_BIT_MSB, - 0)+1>=(ssize_t)dst_nbits) { + } + else if (1 == H5T__bit_get_d(src_bits, src_nbits - 1, (size_t)1) && + H5T__bit_find(src_bits, (size_t)0, src_nbits - 1, H5T_BIT_MSB, 0) + 1 >= + (ssize_t)dst_nbits) { /* * Source is negative but the magnitude is too large for * the destination. The destination should be set to the * smallest possible value: 0x80...0 */ - if (1==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) && - H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 1) < 0) + if (1 == H5T__bit_get_d(dst_bits, dst_nbits - 1, (size_t)1) && + H5T__bit_find(dst_bits, (size_t)0, dst_nbits - 1, H5T_BIT_LSB, 1) < 0) continue; /*no error*/ } - } else if(src_nbits<dst_nbits) { + } + else if (src_nbits < dst_nbits) { /* Source is smaller than the destination */ - if(0==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1)) { + if (0 == H5T__bit_get_d(src_bits, src_nbits - 1, (size_t)1)) { /* * Source is positive, so the excess bits in the * destination should be set to 0's. */ - if (0==H5T__bit_get_d(dst_bits, src_nbits-1, (size_t)1) && - H5T__bit_find(dst_bits, src_nbits, dst_nbits-src_nbits, H5T_BIT_LSB, 1) < 0) + if (0 == H5T__bit_get_d(dst_bits, src_nbits - 1, (size_t)1) && + H5T__bit_find(dst_bits, src_nbits, dst_nbits - src_nbits, H5T_BIT_LSB, 1) < 0) continue; /*no error*/ - } else { + } + else { /* * Source is negative, so the excess bits in the * destination should be set to 1's. */ - if (1==H5T__bit_get_d(dst_bits, src_nbits-1, (size_t)1) && - H5T__bit_find(dst_bits, src_nbits, dst_nbits-src_nbits, H5T_BIT_LSB, 0) < 0) + if (1 == H5T__bit_get_d(dst_bits, src_nbits - 1, (size_t)1) && + H5T__bit_find(dst_bits, src_nbits, dst_nbits - src_nbits, H5T_BIT_LSB, 0) < 0) continue; /*no error*/ } } - } else if (H5T_SGN_2==src_sign && H5T_SGN_NONE==dst_sign) { - if (H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1)) { + } + else if (H5T_SGN_2 == src_sign && H5T_SGN_NONE == dst_sign) { + if (H5T__bit_get_d(src_bits, src_nbits - 1, (size_t)1)) { /* * The source is negative so the result should be zero. * The source is negative if the most significant bit is @@ -2418,9 +2471,9 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst) */ if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 1) < 0) continue; /*no error*/ - } else if (src_nbits>dst_nbits && - H5T__bit_find(src_bits, dst_nbits-1, - src_nbits-dst_nbits, H5T_BIT_LSB, 1)>=0) { + } + else if (src_nbits > dst_nbits && + H5T__bit_find(src_bits, dst_nbits - 1, src_nbits - dst_nbits, H5T_BIT_LSB, 1) >= 0) { /* * The source is a value with a magnitude too large for * the destination. The destination should be the @@ -2429,23 +2482,23 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst) if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0) continue; /*no error*/ } - } else if (H5T_SGN_NONE==src_sign && H5T_SGN_2==dst_sign) { - if (src_nbits>=dst_nbits && - H5T__bit_find(src_bits, dst_nbits-1, (src_nbits-dst_nbits)+1, - H5T_BIT_LSB, 1)>=0) { + } + else if (H5T_SGN_NONE == src_sign && H5T_SGN_2 == dst_sign) { + if (src_nbits >= dst_nbits && + H5T__bit_find(src_bits, dst_nbits - 1, (src_nbits - dst_nbits) + 1, H5T_BIT_LSB, 1) >= 0) { /* * The source value has a magnitude that is larger than * the destination can handle. The destination should be * set to the largest possible positive value: 0x7f...f */ - if (0==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) && - H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0) + if (0 == H5T__bit_get_d(dst_bits, dst_nbits - 1, (size_t)1) && + H5T__bit_find(dst_bits, (size_t)0, dst_nbits - 1, H5T_BIT_LSB, 0) < 0) continue; /*no error*/ } - } else { - if (src_nbits>dst_nbits && - H5T__bit_find(src_bits, dst_nbits, src_nbits-dst_nbits, - H5T_BIT_LSB, 1)>=0) { + } + else { + if (src_nbits > dst_nbits && + H5T__bit_find(src_bits, dst_nbits, src_nbits - dst_nbits, H5T_BIT_LSB, 1) >= 0) { /* * The unsigned source has a value which is too large for * the unsigned destination. The destination should be @@ -2457,54 +2510,54 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst) } /* Print errors */ - if (0==fails_this_test++) + if (0 == fails_this_test++) H5_FAILED(); - printf(" elmt %u\n", (unsigned)j); + HDprintf(" elmt %u\n", (unsigned)j); - printf(" src = "); - for (k=0; k<src_size; k++) - printf(" %02x", saved[j*src_size+ENDIAN(src_size, k, endian)]); - printf("%*s", (int)(3*MAX(0, (ssize_t)dst_size-(ssize_t)src_size)), ""); + HDprintf(" src = "); + for (k = 0; k < src_size; k++) + HDprintf(" %02x", saved[j * src_size + ENDIAN(src_size, k, endian)]); + HDprintf("%*s", (int)(3 * MAX(0, (ssize_t)dst_size - (ssize_t)src_size)), ""); switch (src_type) { case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - printf(" %29d\n", (int)*((signed char*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + HDprintf(" %29d\n", (int)*((signed char *)aligned)); break; case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - printf(" %29u\n", (unsigned)*((unsigned char*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + HDprintf(" %29u\n", (unsigned)*((unsigned char *)aligned)); break; case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - printf(" %29hd\n", *((short*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + HDprintf(" %29hd\n", *((short *)aligned)); break; case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - printf(" %29hu\n", *((unsigned short*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + HDprintf(" %29hu\n", *((unsigned short *)aligned)); break; case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - printf(" %29d\n", *((int*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + HDprintf(" %29d\n", *((int *)aligned)); break; case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - printf(" %29u\n", *((unsigned*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + HDprintf(" %29u\n", *((unsigned *)aligned)); break; case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - printf(" %29ld\n", *((long*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + HDprintf(" %29ld\n", *((long *)aligned)); break; case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - printf(" %29lu\n", *((unsigned long*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + HDprintf(" %29lu\n", *((unsigned long *)aligned)); break; case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - HDfprintf(stdout," %29"H5_PRINTF_LL_WIDTH"d\n", *((long long*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "d\n", *((long long *)aligned)); break; case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - HDfprintf(stdout," %29"H5_PRINTF_LL_WIDTH"u\n", *((unsigned long long*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "u\n", *((unsigned long long *)aligned)); break; case FLT_FLOAT: case FLT_DOUBLE: @@ -2515,50 +2568,50 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst) break; } - printf(" dst = "); - for (k=0; k<dst_size; k++) - printf(" %02x", buf[j*dst_size+ENDIAN(dst_size, k, endian)]); - printf("%*s", (int)(3*MAX(0, (ssize_t)src_size-(ssize_t)dst_size)), ""); + HDprintf(" dst = "); + for (k = 0; k < dst_size; k++) + HDprintf(" %02x", buf[j * dst_size + ENDIAN(dst_size, k, endian)]); + HDprintf("%*s", (int)(3 * MAX(0, (ssize_t)src_size - (ssize_t)dst_size)), ""); switch (dst_type) { case INT_SCHAR: - HDmemcpy(aligned, buf+j*sizeof(signed char), sizeof(signed char)); - printf(" %29d\n", (int)*((signed char*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(signed char), sizeof(signed char)); + HDprintf(" %29d\n", (int)*((signed char *)aligned)); break; case INT_UCHAR: - HDmemcpy(aligned, buf+j*sizeof(unsigned char), sizeof(unsigned char)); - printf(" %29u\n", (unsigned)*((unsigned char*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(unsigned char), sizeof(unsigned char)); + HDprintf(" %29u\n", (unsigned)*((unsigned char *)aligned)); break; case INT_SHORT: - HDmemcpy(aligned, buf+j*sizeof(short), sizeof(short)); - printf(" %29hd\n", *((short*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(short), sizeof(short)); + HDprintf(" %29hd\n", *((short *)aligned)); break; case INT_USHORT: - HDmemcpy(aligned, buf+j*sizeof(unsigned short), sizeof(unsigned short)); - printf(" %29hu\n", *((unsigned short*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(unsigned short), sizeof(unsigned short)); + HDprintf(" %29hu\n", *((unsigned short *)aligned)); break; case INT_INT: - HDmemcpy(aligned, buf+j*sizeof(int), sizeof(int)); - printf(" %29d\n", *((int*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(int), sizeof(int)); + HDprintf(" %29d\n", *((int *)aligned)); break; case INT_UINT: - HDmemcpy(aligned, buf+j*sizeof(unsigned), sizeof(unsigned)); - printf(" %29u\n", *((unsigned*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(unsigned), sizeof(unsigned)); + HDprintf(" %29u\n", *((unsigned *)aligned)); break; case INT_LONG: - HDmemcpy(aligned, buf+j*sizeof(long), sizeof(long)); - printf(" %29ld\n", *((long*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(long), sizeof(long)); + HDprintf(" %29ld\n", *((long *)aligned)); break; case INT_ULONG: - HDmemcpy(aligned, buf+j*sizeof(unsigned long), sizeof(unsigned long)); - printf(" %29lu\n", *((unsigned long*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(unsigned long), sizeof(unsigned long)); + HDprintf(" %29lu\n", *((unsigned long *)aligned)); break; case INT_LLONG: - HDmemcpy(aligned, buf+j*sizeof(long long), sizeof(long long)); - HDfprintf(stdout," %29"H5_PRINTF_LL_WIDTH"d\n", *((long long*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(long long), sizeof(long long)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "d\n", *((long long *)aligned)); break; case INT_ULLONG: - HDmemcpy(aligned, buf+j*sizeof(long long), sizeof(unsigned long long)); - HDfprintf(stdout," %29"H5_PRINTF_LL_WIDTH"u\n", *((unsigned long long*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(long long), sizeof(unsigned long long)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "u\n", *((unsigned long long *)aligned)); break; case FLT_FLOAT: case FLT_DOUBLE: @@ -2569,40 +2622,40 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst) break; } - printf(" ans = "); - for (k=0; k<dst_size; k++) - printf(" %02x", hw[ENDIAN(dst_size, k, endian)]); - printf("%*s", (int)(3*MAX(0, (ssize_t)src_size-(ssize_t)dst_size)), ""); + HDprintf(" ans = "); + for (k = 0; k < dst_size; k++) + HDprintf(" %02x", hw[ENDIAN(dst_size, k, endian)]); + HDprintf("%*s", (int)(3 * MAX(0, (ssize_t)src_size - (ssize_t)dst_size)), ""); switch (dst_type) { case INT_SCHAR: - printf(" %29d\n", (int)*((signed char*)hw)); + HDprintf(" %29d\n", (int)*((signed char *)((void *)hw))); break; case INT_UCHAR: - printf(" %29u\n", (unsigned)*((unsigned char*)hw)); + HDprintf(" %29u\n", (unsigned)*((unsigned char *)((void *)hw))); break; case INT_SHORT: - printf(" %29hd\n", *((short*)hw)); + HDprintf(" %29hd\n", *((short *)((void *)hw))); break; case INT_USHORT: - printf(" %29hu\n", *((unsigned short*)hw)); + HDprintf(" %29hu\n", *((unsigned short *)((void *)hw))); break; case INT_INT: - printf(" %29d\n", *((int*)hw)); + HDprintf(" %29d\n", *((int *)((void *)hw))); break; case INT_UINT: - printf(" %29u\n", *((unsigned*)hw)); + HDprintf(" %29u\n", *((unsigned *)((void *)hw))); break; case INT_LONG: - printf(" %29ld\n", *((long*)hw)); + HDprintf(" %29ld\n", *((long *)((void *)hw))); break; case INT_ULONG: - printf(" %29lu\n", *((unsigned long*)hw)); + HDprintf(" %29lu\n", *((unsigned long *)((void *)hw))); break; case INT_LLONG: - HDfprintf(stdout," %29"H5_PRINTF_LL_WIDTH"d\n", *((long long*)hw)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "d\n", *((long long *)((void *)hw))); break; case INT_ULLONG: - HDfprintf(stdout," %29"H5_PRINTF_LL_WIDTH"u\n", *((unsigned long long*)hw)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "u\n", *((unsigned long long *)((void *)hw))); break; case FLT_FLOAT: case FLT_DOUBLE: @@ -2613,7 +2666,7 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst) break; } - if (++fails_all_tests>=max_fails) { + if (++fails_all_tests >= max_fails) { HDputs(" maximum failures reached, aborting test..."); HDputs(" (dst is library's conversion output. ans is compiler's conversion output.)"); goto done; @@ -2622,44 +2675,49 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst) PASSED(); done: - if (buf) aligned_free(buf); - if (saved) aligned_free(saved); - if (aligned) HDfree(aligned); + if (buf) + aligned_free(buf); + if (saved) + aligned_free(saved); + if (aligned) + HDfree(aligned); HDfflush(stdout); /* Restore the default error handler (set in h5_reset()) */ h5_restore_err(); - reset_hdf5(); /*print statistics*/ + reset_hdf5(); /*print statistics*/ return (int)fails_all_tests; error: - if (buf) aligned_free(buf); - if (saved) aligned_free(saved); - if (aligned) HDfree(aligned); + if (buf) + aligned_free(buf); + if (saved) + aligned_free(saved); + if (aligned) + HDfree(aligned); HDfflush(stdout); /* Restore the default error handler (set in h5_reset()) */ h5_restore_err(); - reset_hdf5(); /*print statistics*/ + reset_hdf5(); /*print statistics*/ return MAX((int)fails_all_tests, 1); } - /*------------------------------------------------------------------------- - * Function: test_conv_int_2 + * Function: test_conv_int_2 * - * Purpose: Tests overlap calculates in H5T__conv_i_i(), which should be - * the same as for H5T__conv_f_f() and H5T__conv_s_s(). + * Purpose: Tests overlap calculates in H5T__conv_i_i(), which should be + * the same as for H5T__conv_f_f() and H5T__conv_s_s(). * - * Return: Success: 0 + * Return: Success: 0 * - * Failure: number of errors + * Failure: number of errors * - * Programmer: Robb Matzke + * Programmer: Robb Matzke * Friday, April 30, 1999 * * Modifications: @@ -2669,47 +2727,49 @@ error: static int test_conv_int_2(void) { - int i, j; - hid_t src_type, dst_type; - char buf[32*100]; + int i, j; + hid_t src_type, dst_type; + char *buf; - printf("%-70s", "Testing overlap calculations"); + HDprintf("%-70s", "Testing overlap calculations"); HDfflush(stdout); - HDmemset(buf, 0, sizeof buf); - for (i=1; i<=32; i++) { - for (j=1; j<=32; j++) { + buf = (char *)HDcalloc(TMP_BUF_DIM1, TMP_BUF_DIM2); + HDassert(buf); - /* Source type */ - src_type = H5Tcopy(H5T_NATIVE_CHAR); - H5Tset_size(src_type, (size_t)i); + for (i = 1; i <= TMP_BUF_DIM1; i++) { + for (j = 1; j <= TMP_BUF_DIM1; j++) { - /* Destination type */ - dst_type = H5Tcopy(H5T_NATIVE_CHAR); - H5Tset_size(dst_type, (size_t)j); + /* Source type */ + src_type = H5Tcopy(H5T_NATIVE_CHAR); + H5Tset_size(src_type, (size_t)i); - /* - * Conversion. If overlap calculations aren't right then an - * assertion will fail in H5T__conv_i_i() - */ - H5Tconvert(src_type, dst_type, (size_t)100, buf, NULL, H5P_DEFAULT); - H5Tclose(src_type); - H5Tclose(dst_type); - } + /* Destination type */ + dst_type = H5Tcopy(H5T_NATIVE_CHAR); + H5Tset_size(dst_type, (size_t)j); + + /* + * Conversion. If overlap calculations aren't right then an + * assertion will fail in H5T__conv_i_i() + */ + H5Tconvert(src_type, dst_type, (size_t)TMP_BUF_DIM2, buf, NULL, H5P_DEFAULT); + H5Tclose(src_type); + H5Tclose(dst_type); + } } PASSED(); + HDfree(buf); return 0; } - /*------------------------------------------------------------------------- - * Function: my_isnan + * Function: my_isnan * - * Purpose: Determines whether VAL points to NaN. + * Purpose: Determines whether VAL points to NaN. * - * Return: TRUE or FALSE + * Return: TRUE or FALSE * - * Programmer: Robb Matzke + * Programmer: Robb Matzke * Monday, July 6, 1998 * * Modifications: @@ -2719,25 +2779,28 @@ test_conv_int_2(void) static int my_isnan(dtype_t type, void *val) { - int retval = 0; + int retval = 0; char s[256]; - if (FLT_FLOAT==type) { - float x; - HDmemcpy(&x, val, sizeof(float)); - retval = (x!=x); - } else if (FLT_DOUBLE==type) { - double x; - HDmemcpy(&x, val, sizeof(double)); - retval = (x!=x); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if (FLT_LDOUBLE==type) { - long double x; - HDmemcpy(&x, val, sizeof(long double)); - retval = (x!=x); + if (FLT_FLOAT == type) { + float x; + HDmemcpy(&x, val, sizeof(float)); + retval = (x != x); + } + else if (FLT_DOUBLE == type) { + double x; + HDmemcpy(&x, val, sizeof(double)); + retval = (x != x); +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (FLT_LDOUBLE == type) { + long double x; + HDmemcpy(&x, val, sizeof(long double)); + retval = (x != x); #endif - } else { - return 0; + } + else { + return 0; } /* @@ -2745,42 +2808,44 @@ my_isnan(dtype_t type, void *val) * the result contains a NaN string. */ if (!retval) { - if (FLT_FLOAT==type) { - float x; - - HDmemcpy(&x, val, sizeof(float)); - HDsnprintf(s, sizeof(s), "%g", x); - } else if (FLT_DOUBLE==type) { - double x; - - HDmemcpy(&x, val, sizeof(double)); - HDsnprintf(s, sizeof(s), "%g", x); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if (FLT_LDOUBLE==type) { - long double x; - - HDmemcpy(&x, val, sizeof(long double)); - HDsnprintf(s, sizeof(s), "%Lg", x); + if (FLT_FLOAT == type) { + float x; + + HDmemcpy(&x, val, sizeof(float)); + HDsnprintf(s, sizeof(s), "%g", (double)x); + } + else if (FLT_DOUBLE == type) { + double x; + + HDmemcpy(&x, val, sizeof(double)); + HDsnprintf(s, sizeof(s), "%g", x); +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (FLT_LDOUBLE == type) { + long double x; + + HDmemcpy(&x, val, sizeof(long double)); + HDsnprintf(s, sizeof(s), "%Lg", x); #endif - } else { - return 0; - } - if (HDstrstr(s, "NaN") || HDstrstr(s, "NAN") || HDstrstr(s, "nan")) - retval = 1; + } + else { + return 0; + } + if (HDstrstr(s, "NaN") || HDstrstr(s, "NAN") || HDstrstr(s, "nan")) + retval = 1; } return retval; } - /*------------------------------------------------------------------------- - * Function: my_isinf + * Function: my_isinf * - * Purpose: Determines whether VAL points to +/-infinity. + * Purpose: Determines whether VAL points to +/-infinity. * - * Return: TRUE or FALSE + * Return: TRUE or FALSE * - * Programmer: Raymond Lu + * Programmer: Raymond Lu * Monday, June 20, 2005 * * Modifications: @@ -2788,20 +2853,19 @@ my_isnan(dtype_t type, void *val) *------------------------------------------------------------------------- */ static int -my_isinf(int endian, unsigned char *val, size_t size, - size_t mpos, size_t msize, size_t epos, size_t esize) +my_isinf(int endian, unsigned char *val, size_t size, size_t mpos, size_t msize, size_t epos, size_t esize) { unsigned char *bits; - int retval = 0; - size_t i; + int retval = 0; + size_t i; - bits = (unsigned char*)HDcalloc((size_t)1, size); + bits = (unsigned char *)HDcalloc((size_t)1, size); - for (i=0; i<size; i++) - bits[size-(i+1)] = *(val + ENDIAN(size, i, endian)); + for (i = 0; i < size; i++) + bits[size - (i + 1)] = *(val + ENDIAN(size, i, endian)); - if(H5T__bit_find(bits, mpos, msize, H5T_BIT_LSB, 1) < 0 && - H5T__bit_find(bits, epos, esize, H5T_BIT_LSB, 0) < 0) + if (H5T__bit_find(bits, mpos, msize, H5T_BIT_LSB, 1) < 0 && + H5T__bit_find(bits, epos, esize, H5T_BIT_LSB, 0) < 0) retval = 1; HDfree(bits); @@ -2809,70 +2873,69 @@ my_isinf(int endian, unsigned char *val, size_t size, return retval; } - /*------------------------------------------------------------------------- - * Function: test_conv_flt_1 + * Function: test_conv_flt_1 * - * Purpose: Test conversion of floating point values from SRC to - * DST. These types should be H5T_NATIVE_FLOAT, - * H5T_NATIVE_DOUBLE, or H5T_NATIVE_LDOUBLE. + * Purpose: Test conversion of floating point values from SRC to + * DST. These types should be H5T_NATIVE_FLOAT, + * H5T_NATIVE_DOUBLE, or H5T_NATIVE_LDOUBLE. * - * Return: Success: 0 + * Return: Success: 0 * - * Failure: number of errors + * Failure: number of errors * - * Programmer: Robb Matzke + * Programmer: Robb Matzke * Tuesday, June 23, 1998 * * Modifications: - * Albert Cheng, Apr 16, 2004 - * Check for underflow condition. If the src number is - * smaller than the dst MIN float number, consider it okay - * if the converted sw and hw dst are both less than or - * equal to the dst MIN float number. + * Albert Cheng, Apr 16, 2004 + * Check for underflow condition. If the src number is + * smaller than the dst MIN float number, consider it okay + * if the converted sw and hw dst are both less than or + * equal to the dst MIN float number. * *------------------------------------------------------------------------- */ static int -test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst) +test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) { - dtype_t src_type, dst_type; /*data types */ - size_t nelmts=0; /*num values per test */ - const size_t max_fails=8; /*max number of failures*/ - size_t fails_all_tests=0; /*number of failures */ - size_t fails_this_test; /*fails for this test */ - const char *src_type_name = NULL; /*source type name */ - const char *dst_type_name = NULL; /*destination type name */ - size_t src_size, dst_size; /*type sizes */ - unsigned char *buf = NULL; /*buffer for conversion */ - unsigned char *saved = NULL; /*original values */ - char str[256]; /*hello string */ - void *aligned=NULL; /*aligned buffer */ - float hw_f; /*hardware-converted */ - double hw_d; /*hardware-converted */ -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE - long double hw_ld; /*hardware-converted */ + dtype_t src_type, dst_type; /*data types */ + size_t nelmts = 0; /*num values per test */ + const size_t max_fails = 8; /*max number of failures*/ + size_t fails_all_tests = 0; /*number of failures */ + size_t fails_this_test; /*fails for this test */ + const char * src_type_name = NULL; /*source type name */ + const char * dst_type_name = NULL; /*destination type name */ + size_t src_size, dst_size; /*type sizes */ + unsigned char *buf = NULL; /*buffer for conversion */ + unsigned char *saved = NULL; /*original values */ + char str[256]; /*hello string */ + void * aligned = NULL; /*aligned buffer */ + float hw_f; /*hardware-converted */ + double hw_d; /*hardware-converted */ +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE + long double hw_ld; /*hardware-converted */ #endif - unsigned char *hw=NULL; /*ptr to hardware-conv'd*/ - int underflow; /*underflow occurred */ - int overflow; /*overflow occurred */ - int uflow=0; /*underflow debug counters*/ - size_t j, k; /*counters */ - int sendian; /* source type endianess */ - int dendian; /* Destination type endianess */ - size_t dst_ebias; /* Destination type's exponent bias */ - size_t src_epos; /* Source type's exponent position */ - size_t src_esize; /* Source type's exponent size */ - size_t dst_epos; /* Destination type's exponent position */ - size_t dst_esize; /* Destination type's exponent size */ - size_t dst_mpos; /* Destination type's mantissa position */ - size_t dst_msize; /* Destination type's mantissa size */ - size_t src_nbits; /* source length in bits */ - size_t dst_nbits; /* dst length in bits */ + unsigned char *hw = NULL; /*ptr to hardware-conv'd*/ + int underflow; /*underflow occurred */ + int overflow = 0; /*overflow occurred */ + int uflow = 0; /*underflow debug counters*/ + size_t j, k; /*counters */ + int sendian; /* source type endianess */ + int dendian; /* Destination type endianess */ + size_t dst_ebias; /* Destination type's exponent bias */ + size_t src_epos; /* Source type's exponent position */ + size_t src_esize; /* Source type's exponent size */ + size_t dst_epos; /* Destination type's exponent position */ + size_t dst_esize; /* Destination type's exponent size */ + size_t dst_mpos; /* Destination type's mantissa position */ + size_t dst_msize; /* Destination type's mantissa size */ + size_t src_nbits; /* source length in bits */ + size_t dst_nbits; /* dst length in bits */ #ifdef HANDLE_SIGFPE - pid_t child_pid; /*process ID of child */ - int status; /*child exit status */ + pid_t child_pid; /*process ID of child */ + int status; /*child exit status */ /* * Some systems generage SIGFPE during floating point overflow and we @@ -2882,23 +2945,28 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst) */ HDfflush(stdout); HDfflush(stderr); - if ((child_pid=fork()) < 0) { - HDperror("fork"); - return 1; - } else if (child_pid>0) { - while (child_pid!=waitpid(child_pid, &status, 0)) /*void*/; - if (WIFEXITED(status) && 255==WEXITSTATUS(status)) { - return 0; /*child exit after catching SIGFPE*/ - } else if (WIFEXITED(status)) { - return WEXITSTATUS(status); - } else if (WIFSIGNALED(status)) { - HDsnprintf(str, sizeof(str), " Child caught signal %d.", WTERMSIG(status)); - HDputs(str); - return 1; /*child exit after catching non-SIGFPE signal */ - } else { - HDputs(" Child didn't exit normally."); - return 1; - } + if ((child_pid = fork()) < 0) { + HDperror("fork"); + return 1; + } + else if (child_pid > 0) { + while (child_pid != waitpid(child_pid, &status, 0)) /*void*/ + ; + if (WIFEXITED(status) && 255 == WEXITSTATUS(status)) { + return 0; /*child exit after catching SIGFPE*/ + } + else if (WIFEXITED(status)) { + return WEXITSTATUS(status); + } + else if (WIFSIGNALED(status)) { + HDsnprintf(str, sizeof(str), " Child caught signal %d.", WTERMSIG(status)); + HDputs(str); + return 1; /*child exit after catching non-SIGFPE signal */ + } + else { + HDputs(" Child didn't exit normally."); + return 1; + } } #endif @@ -2906,89 +2974,96 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst) * The remainder of this function is executed only by the child if * HANDLE_SIGFPE is defined. */ - HDsignal(SIGFPE,fpe_handler); + HDsignal(SIGFPE, fpe_handler); /* What are the names of the source and destination types */ if (H5Tequal(src, H5T_NATIVE_FLOAT)) { - src_type_name = "float"; - src_type = FLT_FLOAT; - } else if (H5Tequal(src, H5T_NATIVE_DOUBLE)) { - src_type_name = "double"; - src_type = FLT_DOUBLE; -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if (H5Tequal(src, H5T_NATIVE_LDOUBLE)) { - src_type_name = "long double"; - src_type = FLT_LDOUBLE; + src_type_name = "float"; + src_type = FLT_FLOAT; + } + else if (H5Tequal(src, H5T_NATIVE_DOUBLE)) { + src_type_name = "double"; + src_type = FLT_DOUBLE; +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (H5Tequal(src, H5T_NATIVE_LDOUBLE)) { + src_type_name = "long double"; + src_type = FLT_LDOUBLE; #endif - } else { - src_type_name = "UNKNOWN"; - src_type = OTHER; + } + else { + src_type_name = "UNKNOWN"; + src_type = OTHER; } if (H5Tequal(dst, H5T_NATIVE_FLOAT)) { - dst_type_name = "float"; - dst_type = FLT_FLOAT; - } else if (H5Tequal(dst, H5T_NATIVE_DOUBLE)) { - dst_type_name = "double"; - dst_type = FLT_DOUBLE; -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if (H5Tequal(dst, H5T_NATIVE_LDOUBLE)) { - dst_type_name = "long double"; - dst_type = FLT_LDOUBLE; + dst_type_name = "float"; + dst_type = FLT_FLOAT; + } + else if (H5Tequal(dst, H5T_NATIVE_DOUBLE)) { + dst_type_name = "double"; + dst_type = FLT_DOUBLE; +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (H5Tequal(dst, H5T_NATIVE_LDOUBLE)) { + dst_type_name = "long double"; + dst_type = FLT_LDOUBLE; #endif - } else { - dst_type_name = "UNKNOWN"; - dst_type = OTHER; + } + else { + dst_type_name = "UNKNOWN"; + dst_type = OTHER; } /* Sanity checks */ - if(sizeof(float)==sizeof(double)) + if (sizeof(float) == sizeof(double)) HDputs("Sizeof(float)==sizeof(double) - some tests may not be sensible."); - if (OTHER==src_type || OTHER==dst_type) { - if(!strcmp(name, "noop")) - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, src_type_name, dst_type_name); - else if(run_test==TEST_SPECIAL) - HDsnprintf(str, sizeof(str), "Testing %s special %s -> %s conversions", - name, src_type_name, dst_type_name); - else if(run_test==TEST_NORMAL) - HDsnprintf(str, sizeof(str), "Testing %s normalized %s -> %s conversions", - name, src_type_name, dst_type_name); - else if(run_test==TEST_DENORM) - HDsnprintf(str, sizeof(str), "Testing %s denormalized %s -> %s conversions", - name, src_type_name, dst_type_name); - - printf("%-70s", str); - H5_FAILED(); - HDputs(" Unknown data type."); - goto error; - } else { - if(!strcmp(name, "noop")) - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, src_type_name, dst_type_name); - else if(run_test==TEST_SPECIAL) - HDsnprintf(str, sizeof(str), "Testing %s special %s -> %s conversions", - name, src_type_name, dst_type_name); - else if(run_test==TEST_NORMAL) - HDsnprintf(str, sizeof(str), "Testing %s normalized %s -> %s conversions", - name, src_type_name, dst_type_name); - else if(run_test==TEST_DENORM) - HDsnprintf(str, sizeof(str), "Testing %s denormalized %s -> %s conversions", - name, src_type_name, dst_type_name); - - printf("%-70s", str); + if (OTHER == src_type || OTHER == dst_type) { + if (!strcmp(name, "noop")) + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, src_type_name, + dst_type_name); + else if (run_test == TEST_SPECIAL) + HDsnprintf(str, sizeof(str), "Testing %s special %s -> %s conversions", name, src_type_name, + dst_type_name); + else if (run_test == TEST_NORMAL) + HDsnprintf(str, sizeof(str), "Testing %s normalized %s -> %s conversions", name, src_type_name, + dst_type_name); + else if (run_test == TEST_DENORM) + HDsnprintf(str, sizeof(str), "Testing %s denormalized %s -> %s conversions", name, src_type_name, + dst_type_name); + + HDprintf("%-70s", str); + H5_FAILED(); + HDputs(" Unknown data type."); + goto error; + } + else { + if (!strcmp(name, "noop")) + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, src_type_name, + dst_type_name); + else if (run_test == TEST_SPECIAL) + HDsnprintf(str, sizeof(str), "Testing %s special %s -> %s conversions", name, src_type_name, + dst_type_name); + else if (run_test == TEST_NORMAL) + HDsnprintf(str, sizeof(str), "Testing %s normalized %s -> %s conversions", name, src_type_name, + dst_type_name); + else if (run_test == TEST_DENORM) + HDsnprintf(str, sizeof(str), "Testing %s denormalized %s -> %s conversions", name, src_type_name, + dst_type_name); + + HDprintf("%-70s", str); HDfflush(stdout); fails_this_test = 0; } /* Get "interesting" values */ - src_size = H5Tget_size(src); - dst_size = H5Tget_size(dst); + src_size = H5Tget_size(src); + dst_size = H5Tget_size(dst); src_nbits = H5Tget_precision(src); /* not 8*src_size, esp on J90 - QAK */ dst_nbits = H5Tget_precision(dst); /* not 8*dst_size, esp on J90 - QAK */ - dst_ebias=H5Tget_ebias(dst); - H5Tget_fields(src,NULL,&src_epos,&src_esize,NULL,NULL); - H5Tget_fields(dst,NULL,&dst_epos,&dst_esize,&dst_mpos,&dst_msize); + dst_ebias = H5Tget_ebias(dst); + H5Tget_fields(src, NULL, &src_epos, &src_esize, NULL, NULL); + H5Tget_fields(dst, NULL, &dst_epos, &dst_esize, &dst_mpos, &dst_msize); sendian = H5Tget_order(src); dendian = H5Tget_order(dst); @@ -3004,51 +3079,57 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst) switch (run_test) { case TEST_NOOP: case TEST_NORMAL: - if(src_type == FLT_FLOAT) { - INIT_FP_NORM(float, FLT_MAX, FLT_MIN, FLT_MAX_10_EXP, FLT_MIN_10_EXP, - src_size, dst_size, buf, saved, nelmts); - } else if(src_type == FLT_DOUBLE) { - INIT_FP_NORM(double, DBL_MAX, DBL_MIN, DBL_MAX_10_EXP, DBL_MIN_10_EXP, - src_size, dst_size, buf, saved, nelmts); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if(src_type == FLT_LDOUBLE) { - INIT_FP_NORM(long double, LDBL_MAX, LDBL_MIN, LDBL_MAX_10_EXP, LDBL_MIN_10_EXP, - src_size, dst_size, buf, saved, nelmts); + if (src_type == FLT_FLOAT) { + INIT_FP_NORM(float, FLT_MAX, FLT_MIN, FLT_MAX_10_EXP, FLT_MIN_10_EXP, src_size, dst_size, buf, + saved, nelmts); + } + else if (src_type == FLT_DOUBLE) { + INIT_FP_NORM(double, DBL_MAX, DBL_MIN, DBL_MAX_10_EXP, DBL_MIN_10_EXP, src_size, dst_size, + buf, saved, nelmts); +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (src_type == FLT_LDOUBLE) { + INIT_FP_NORM(long double, LDBL_MAX, LDBL_MIN, LDBL_MAX_10_EXP, LDBL_MIN_10_EXP, src_size, + dst_size, buf, saved, nelmts); #endif - } else + } + else goto error; break; case TEST_DENORM: - if(src_type == FLT_FLOAT) { - INIT_FP_DENORM(float, FLT_MANT_DIG, src_size, src_nbits, sendian, dst_size, - buf, saved, nelmts); - } else if(src_type == FLT_DOUBLE) { - INIT_FP_DENORM(double, DBL_MANT_DIG, src_size, src_nbits, sendian, dst_size, - buf, saved, nelmts); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if(src_type == FLT_LDOUBLE) { - INIT_FP_DENORM(long double, LDBL_MANT_DIG, src_size, src_nbits, sendian, dst_size, - buf, saved, nelmts); + if (src_type == FLT_FLOAT) { + INIT_FP_DENORM(float, FLT_MANT_DIG, src_size, src_nbits, sendian, dst_size, buf, saved, + nelmts); + } + else if (src_type == FLT_DOUBLE) { + INIT_FP_DENORM(double, DBL_MANT_DIG, src_size, src_nbits, sendian, dst_size, buf, saved, + nelmts); +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (src_type == FLT_LDOUBLE) { + INIT_FP_DENORM(long double, LDBL_MANT_DIG, src_size, src_nbits, sendian, dst_size, buf, saved, + nelmts); #endif - } else + } + else goto error; break; case TEST_SPECIAL: - if(src_type == FLT_FLOAT) { - INIT_FP_SPECIAL(src_size, src_nbits, sendian, FLT_MANT_DIG, dst_size, - buf, saved, nelmts); - } else if(src_type == FLT_DOUBLE) { - INIT_FP_SPECIAL(src_size, src_nbits, sendian, DBL_MANT_DIG, dst_size, - buf, saved, nelmts); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if(src_type == FLT_LDOUBLE) { - INIT_FP_SPECIAL(src_size, src_nbits, sendian, LDBL_MANT_DIG, dst_size, - buf, saved, nelmts); + if (src_type == FLT_FLOAT) { + INIT_FP_SPECIAL(src_size, src_nbits, sendian, FLT_MANT_DIG, dst_size, buf, saved, nelmts); + } + else if (src_type == FLT_DOUBLE) { + INIT_FP_SPECIAL(src_size, src_nbits, sendian, DBL_MANT_DIG, dst_size, buf, saved, nelmts); +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (src_type == FLT_LDOUBLE) { + INIT_FP_SPECIAL(src_size, src_nbits, sendian, LDBL_MANT_DIG, dst_size, buf, saved, nelmts); #endif - } else + } + else goto error; break; @@ -3061,66 +3142,74 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst) goto error; /* Check the software results against the hardware */ - for (j=0; j<nelmts; j++) { + for (j = 0; j < nelmts; j++) { underflow = 0; - hw_f = 911.0f; - hw_d = 911.0f; -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE + hw_f = 911.0f; + hw_d = 911.0f; +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE hw_ld = 911.0f; #endif /* The hardware conversion */ /* Check for underflow when src is a "larger" float than dst.*/ - if (FLT_FLOAT==src_type) { - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - if (FLT_FLOAT==dst_type) { - hw_f = *((float*)aligned); - hw = (unsigned char*)&hw_f; - } else if (FLT_DOUBLE==dst_type) { - hw_d = *((float*)aligned); - hw = (unsigned char*)&hw_d; -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE - } else { - hw_ld = *((float*)aligned); - hw = (unsigned char*)&hw_ld; + if (FLT_FLOAT == src_type) { + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + if (FLT_FLOAT == dst_type) { + hw_f = *((float *)aligned); + hw = (unsigned char *)&hw_f; + } + else if (FLT_DOUBLE == dst_type) { + hw_d = *((float *)aligned); + hw = (unsigned char *)&hw_d; +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE + } + else { + hw_ld = *((float *)aligned); + hw = (unsigned char *)&hw_ld; #endif } - } else if (FLT_DOUBLE==src_type) { - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - if (FLT_FLOAT==dst_type) { - hw_f = (float)(*((double*)aligned)); - hw = (unsigned char*)&hw_f; - underflow = HDfabs(*((double*)aligned)) < FLT_MIN; - overflow = HDfabs(*((double*)aligned)) > FLT_MAX; - } else if (FLT_DOUBLE==dst_type) { - hw_d = *((double*)aligned); - hw = (unsigned char*)&hw_d; -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE - } else { - hw_ld = *((double*)aligned); - hw = (unsigned char*)&hw_ld; + } + else if (FLT_DOUBLE == src_type) { + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + if (FLT_FLOAT == dst_type) { + hw_f = (float)(*((double *)aligned)); + hw = (unsigned char *)&hw_f; + underflow = HDfabs(*((double *)aligned)) < (double)FLT_MIN; + overflow = HDfabs(*((double *)aligned)) > (double)FLT_MAX; + } + else if (FLT_DOUBLE == dst_type) { + hw_d = *((double *)aligned); + hw = (unsigned char *)&hw_d; +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE + } + else { + hw_ld = *((double *)aligned); + hw = (unsigned char *)&hw_ld; #endif } -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE - } else { - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - if (FLT_FLOAT==dst_type) { - hw_f = *((long double*)aligned); - hw = (unsigned char*)&hw_f; - underflow = HDfabsl(*((long double*)aligned)) < FLT_MIN; - overflow = HDfabsl(*((long double*)aligned)) > FLT_MAX; - } else if (FLT_DOUBLE==dst_type) { - hw_d = *((long double*)aligned); - hw = (unsigned char*)&hw_d; - underflow = HDfabsl(*((long double*)aligned)) < DBL_MIN; - overflow = HDfabsl(*((long double*)aligned)) > DBL_MAX; - } else { - hw_ld = *((long double*)aligned); - hw = (unsigned char*)&hw_ld; +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE + } + else { + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + if (FLT_FLOAT == dst_type) { + hw_f = (float)*((long double *)aligned); + hw = (unsigned char *)&hw_f; + underflow = HDfabsl(*((long double *)aligned)) < FLT_MIN; + overflow = HDfabsl(*((long double *)aligned)) > FLT_MAX; + } + else if (FLT_DOUBLE == dst_type) { + hw_d = (double)*((long double *)aligned); + hw = (unsigned char *)&hw_d; + underflow = HDfabsl(*((long double *)aligned)) < DBL_MIN; + overflow = HDfabsl(*((long double *)aligned)) > DBL_MAX; + } + else { + hw_ld = *((long double *)aligned); + hw = (unsigned char *)&hw_ld; } #endif } - if (underflow){ + if (underflow) { uflow++; } @@ -3130,43 +3219,40 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst) * last few unused bytes may have garbage in them. Clean them out with * 0s before compare the values. */ -#if H5_SIZEOF_LONG_DOUBLE !=0 - if(sendian == H5T_ORDER_LE && dst_type == FLT_LDOUBLE) { +#if H5_SIZEOF_LONG_DOUBLE != 0 + if (sendian == H5T_ORDER_LE && dst_type == FLT_LDOUBLE) { size_t q; - for(q = dst_nbits / 8; q < dst_size; q++) { + for (q = dst_nbits / 8; q < dst_size; q++) { buf[j * dst_size + q] = 0x00; - hw[q] = 0x00; + hw[q] = 0x00; } } #endif /* Are the two results the same? */ - for (k=(dst_size-(dst_nbits/8)); k<dst_size; k++) - if (buf[j*dst_size+k]!=hw[k]) + for (k = (dst_size - (dst_nbits / 8)); k < dst_size; k++) + if (buf[j * dst_size + k] != hw[k]) break; - if (k==dst_size) + if (k == dst_size) continue; /*no error*/ - /* * Assume same if both results are NaN. There are many NaN bit * patterns and the software doesn't attemt to emulate the * hardware in this regard. Instead, software uses a single bit * pattern for NaN by setting the significand to all ones. */ - if (FLT_FLOAT==dst_type && - my_isnan(dst_type, buf+j*sizeof(float)) && - my_isnan(dst_type, hw)) { + if (FLT_FLOAT == dst_type && my_isnan(dst_type, buf + j * sizeof(float)) && my_isnan(dst_type, hw)) { continue; - } else if (FLT_DOUBLE==dst_type && - my_isnan(dst_type, buf+j*sizeof(double)) && - my_isnan(dst_type, hw)) { + } + else if (FLT_DOUBLE == dst_type && my_isnan(dst_type, buf + j * sizeof(double)) && + my_isnan(dst_type, hw)) { continue; -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if (FLT_LDOUBLE==dst_type && - my_isnan(dst_type, buf+j*sizeof(long double)) && - my_isnan(dst_type, hw)) { +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (FLT_LDOUBLE == dst_type && my_isnan(dst_type, buf + j * sizeof(long double)) && + my_isnan(dst_type, hw)) { continue; #endif } @@ -3193,132 +3279,138 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst) * the SGI compiler assigns the dst's maximal value. */ { - double check_mant[2]; - int check_expo[2]; + double check_mant[2]; + int check_expo[2]; - if (FLT_FLOAT==dst_type) { + if (FLT_FLOAT == dst_type) { float x; - HDmemcpy(&x, &buf[j*dst_size], sizeof(float)); - if (underflow && - HDfabsf(x) <= FLT_MIN && HDfabsf(hw_f) <= FLT_MIN) - continue; /* all underflowed, no error */ - if (overflow && my_isinf(dendian, buf+j*sizeof(float), - dst_size, dst_mpos, dst_msize, dst_epos, dst_esize)) - continue; /* all overflowed, no error */ - check_mant[0] = HDfrexpf(x, check_expo+0); - check_mant[1] = HDfrexpf(hw_f, check_expo+1); - } else if (FLT_DOUBLE==dst_type) { + HDmemcpy(&x, &buf[j * dst_size], sizeof(float)); + if (underflow && HDfabsf(x) <= FLT_MIN && HDfabsf(hw_f) <= FLT_MIN) + continue; /* all underflowed, no error */ + if (overflow && my_isinf(dendian, buf + j * sizeof(float), dst_size, dst_mpos, dst_msize, + dst_epos, dst_esize)) + continue; /* all overflowed, no error */ + check_mant[0] = HDfrexpf(x, check_expo + 0); + check_mant[1] = HDfrexpf(hw_f, check_expo + 1); + } + else if (FLT_DOUBLE == dst_type) { double x; - HDmemcpy(&x, &buf[j*dst_size], sizeof(double)); - if (underflow && - HDfabs(x) <= DBL_MIN && HDfabs(hw_d) <= DBL_MIN) - continue; /* all underflowed, no error */ - if (overflow && my_isinf(dendian, buf+j*sizeof(double), - dst_size, dst_mpos, dst_msize, dst_epos, dst_esize)) - continue; /* all overflowed, no error */ - check_mant[0] = HDfrexp(x, check_expo+0); - check_mant[1] = HDfrexp(hw_d, check_expo+1); -#if H5_SIZEOF_LONG_DOUBLE !=0 && (H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE) - } else { + HDmemcpy(&x, &buf[j * dst_size], sizeof(double)); + if (underflow && HDfabs(x) <= DBL_MIN && HDfabs(hw_d) <= DBL_MIN) + continue; /* all underflowed, no error */ + if (overflow && my_isinf(dendian, buf + j * sizeof(double), dst_size, dst_mpos, dst_msize, + dst_epos, dst_esize)) + continue; /* all overflowed, no error */ + check_mant[0] = HDfrexp(x, check_expo + 0); + check_mant[1] = HDfrexp(hw_d, check_expo + 1); +#if H5_SIZEOF_LONG_DOUBLE != 0 && (H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE) + } + else { long double x; - HDmemcpy(&x, &buf[j*dst_size], sizeof(long double)); + HDmemcpy(&x, &buf[j * dst_size], sizeof(long double)); /* dst is largest float, no need to check underflow. */ - check_mant[0] = HDfrexpl(x, check_expo+0); - check_mant[1] = HDfrexpl(hw_ld, check_expo+1); + check_mant[0] = (double)HDfrexpl(x, check_expo + 0); + check_mant[1] = (double)HDfrexpl(hw_ld, check_expo + 1); #endif } /* Special check for denormalized values */ - if(check_expo[0]<(-(int)dst_ebias) || check_expo[1]<(-(int)dst_ebias)) { - int expo_diff=check_expo[0]-check_expo[1]; - int valid_bits=(int)((dst_ebias+dst_msize)+MIN(check_expo[0],check_expo[1]))-1; - double epsilon=1.0F; + if (check_expo[0] < (-(int)dst_ebias) || check_expo[1] < (-(int)dst_ebias)) { + int expo_diff = check_expo[0] - check_expo[1]; + int valid_bits = + (int)((dst_ebias + dst_msize) + (size_t)MIN(check_expo[0], check_expo[1])) - 1; + double epsilon = 1.0F; /* Re-scale the mantissas based on any exponent difference */ - if(expo_diff!=0) - check_mant[0] = HDldexp(check_mant[0],expo_diff); + if (expo_diff != 0) + check_mant[0] = HDldexp(check_mant[0], expo_diff); /* Compute the proper epsilon */ - epsilon=HDldexp(epsilon,-valid_bits); + epsilon = HDldexp(epsilon, -valid_bits); /* Check for "close enough" fit with scaled epsilon value */ - if (HDfabs(check_mant[0]-check_mant[1])<=epsilon) + if (HDfabs(check_mant[0] - check_mant[1]) <= epsilon) continue; } /* end if */ else { - if (check_expo[0]==check_expo[1] && - HDfabs(check_mant[0]-check_mant[1])<FP_EPSILON) + if (check_expo[0] == check_expo[1] && + HDfabs(check_mant[0] - check_mant[1]) < (double)FP_EPSILON) continue; } /* end else */ } - if (0==fails_this_test++) { - if(run_test==TEST_NOOP || run_test==TEST_NORMAL) { + if (0 == fails_this_test++) { + if (run_test == TEST_NOOP || run_test == TEST_NORMAL) { H5_FAILED(); - } else if(run_test==TEST_DENORM || run_test==TEST_SPECIAL) { + } + else if (run_test == TEST_DENORM || run_test == TEST_SPECIAL) { H5_WARNING(); } } - printf(" elmt %u\n", (unsigned)j); + HDprintf(" elmt %u\n", (unsigned)j); - printf(" src ="); - for (k=0; k<src_size; k++) - printf(" %02x", saved[j*src_size+ENDIAN(src_size,k,sendian)]); - printf("%*s", (int)(3*MAX(0, (ssize_t)dst_size-(ssize_t)src_size)), ""); - if (FLT_FLOAT==src_type) { + HDprintf(" src ="); + for (k = 0; k < src_size; k++) + HDprintf(" %02x", saved[j * src_size + ENDIAN(src_size, k, sendian)]); + HDprintf("%*s", (int)(3 * MAX(0, (ssize_t)dst_size - (ssize_t)src_size)), ""); + if (FLT_FLOAT == src_type) { float x; - HDmemcpy(&x, &saved[j*src_size], sizeof(float)); - printf(" %29.20e\n", x); - } else if (FLT_DOUBLE==src_type) { + HDmemcpy(&x, &saved[j * src_size], sizeof(float)); + HDprintf(" %29.20e\n", (double)x); + } + else if (FLT_DOUBLE == src_type) { double x; - HDmemcpy(&x, &saved[j*src_size], sizeof(double)); - printf(" %29.20e\n", x); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE - } else { + HDmemcpy(&x, &saved[j * src_size], sizeof(double)); + HDprintf(" %29.20e\n", x); +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE + } + else { long double x; - HDmemcpy(&x, &saved[j*src_size], sizeof(long double)); - HDfprintf(stdout," %29.20Le\n", x); + HDmemcpy(&x, &saved[j * src_size], sizeof(long double)); + HDfprintf(stdout, " %29.20Le\n", x); #endif } - printf(" dst ="); - for (k=0; k<dst_size; k++) - printf(" %02x", buf[j*dst_size+ENDIAN(dst_size,k,dendian)]); - printf("%*s", (int)(3*MAX(0, (ssize_t)src_size-(ssize_t)dst_size)), ""); - if (FLT_FLOAT==dst_type) { + HDprintf(" dst ="); + for (k = 0; k < dst_size; k++) + HDprintf(" %02x", buf[j * dst_size + ENDIAN(dst_size, k, dendian)]); + HDprintf("%*s", (int)(3 * MAX(0, (ssize_t)src_size - (ssize_t)dst_size)), ""); + if (FLT_FLOAT == dst_type) { float x; - HDmemcpy(&x, &buf[j*dst_size], sizeof(float)); - printf(" %29.20e\n", x); - } else if (FLT_DOUBLE==dst_type) { + HDmemcpy(&x, &buf[j * dst_size], sizeof(float)); + HDprintf(" %29.20e\n", (double)x); + } + else if (FLT_DOUBLE == dst_type) { double x; - HDmemcpy(&x, &buf[j*dst_size], sizeof(double)); - printf(" %29.20e\n", x); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE - } else { + HDmemcpy(&x, &buf[j * dst_size], sizeof(double)); + HDprintf(" %29.20e\n", x); +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE + } + else { long double x; - HDmemcpy(&x, &buf[j*dst_size], sizeof(long double)); - HDfprintf(stdout," %29.20Le\n", x); + HDmemcpy(&x, &buf[j * dst_size], sizeof(long double)); + HDfprintf(stdout, " %29.20Le\n", x); #endif } - printf(" ans ="); - for (k=0; k<dst_size; k++) - printf(" %02x", hw[ENDIAN(dst_size,k,dendian)]); - printf("%*s", (int)(3*MAX(0, (ssize_t)src_size-(ssize_t)dst_size)), ""); - if (FLT_FLOAT==dst_type) - printf(" %29.20e\n", hw_f); - else if (FLT_DOUBLE==dst_type) - printf(" %29.20e\n", hw_d); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE + HDprintf(" ans ="); + for (k = 0; k < dst_size; k++) + HDprintf(" %02x", hw[ENDIAN(dst_size, k, dendian)]); + HDprintf("%*s", (int)(3 * MAX(0, (ssize_t)src_size - (ssize_t)dst_size)), ""); + if (FLT_FLOAT == dst_type) + HDprintf(" %29.20e\n", (double)hw_f); + else if (FLT_DOUBLE == dst_type) + HDprintf(" %29.20e\n", hw_d); +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE else - HDfprintf(stdout," %29.20Le\n", hw_ld); + HDfprintf(stdout, " %29.20Le\n", hw_ld); #endif /* If the source is normalized values, print out error message; if it is * denormalized or special values, print out warning message.*/ - if (++fails_all_tests>=max_fails) { - if(run_test==TEST_NORMAL) + if (++fails_all_tests >= max_fails) { + if (run_test == TEST_NORMAL) HDputs(" maximum failures reached, aborting test..."); - else if(run_test==TEST_DENORM || run_test==TEST_SPECIAL) + else if (run_test == TEST_DENORM || run_test == TEST_SPECIAL) HDputs(" maximum warnings reached, aborting test..."); HDputs(" (dst is library's conversion output. ans is compiler's conversion output.)"); @@ -3326,19 +3418,22 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst) } } - if(!fails_all_tests) + if (!fails_all_tests) PASSED(); done: - if (buf) aligned_free(buf); - if (saved) aligned_free(saved); - if (aligned) HDfree(aligned); + if (buf) + aligned_free(buf); + if (saved) + aligned_free(saved); + if (aligned) + HDfree(aligned); HDfflush(stdout); #ifdef HANDLE_SIGFPE - if(run_test==TEST_NOOP || run_test==TEST_NORMAL) + if (run_test == TEST_NOOP || run_test == TEST_NORMAL) HDexit(MIN((int)fails_all_tests, 254)); - else if(run_test==TEST_DENORM || run_test==TEST_SPECIAL) - HDexit(0); + else if (run_test == TEST_DENORM || run_test == TEST_SPECIAL) + HDexit(EXIT_SUCCESS); HDassert(0 && "Should not reach this point!"); return 1; #else @@ -3349,22 +3444,25 @@ done: /* If the source is normalized values, treat the failures as error; * if it is denormalized or special values, treat the failure as warning.*/ - if(run_test==TEST_NOOP || run_test==TEST_NORMAL) + if (run_test == TEST_NOOP || run_test == TEST_NORMAL) return (int)fails_all_tests; - else if(run_test==TEST_DENORM || run_test==TEST_SPECIAL) + else if (run_test == TEST_DENORM || run_test == TEST_SPECIAL) return 0; #endif error: - if (buf) aligned_free(buf); - if (saved) aligned_free(saved); - if (aligned) HDfree(aligned); + if (buf) + aligned_free(buf); + if (saved) + aligned_free(saved); + if (aligned) + HDfree(aligned); HDfflush(stdout); #ifdef HANDLE_SIGFPE - if(run_test==TEST_NOOP || run_test==TEST_NORMAL) + if (run_test == TEST_NOOP || run_test == TEST_NORMAL) HDexit(MIN(MAX((int)fails_all_tests, 1), 254)); - else if(run_test==TEST_DENORM || run_test==TEST_SPECIAL) - HDexit(1); + else if (run_test == TEST_DENORM || run_test == TEST_SPECIAL) + HDexit(EXIT_FAILURE); HDassert(0 && "Should not reach this point!"); return 1; #else @@ -3373,31 +3471,30 @@ error: reset_hdf5(); - if(run_test==TEST_NOOP || run_test==TEST_NORMAL) + if (run_test == TEST_NOOP || run_test == TEST_NORMAL) return MAX((int)fails_all_tests, 1); - else if(run_test==TEST_DENORM || run_test==TEST_SPECIAL) + else if (run_test == TEST_DENORM || run_test == TEST_SPECIAL) return 1; #endif } - /*------------------------------------------------------------------------- - * Function: test_conv_int_fp + * Function: test_conv_int_fp * - * Purpose: Test conversion between integer and float values + * Purpose: Test conversion between integer and float values * from SRC to DST. These types should be any combination of: * - * H5T_NATIVE_SCHAR H5T_NATIVE_FLOAT - * H5T_NATIVE_SHORT H5T_NATIVE_DOUBLE - * H5T_NATIVE_INT H5T_NATIVE_LDOUBLE - * H5T_NATIVE_LONG - * H5T_NATIVE_LLONG + * H5T_NATIVE_SCHAR H5T_NATIVE_FLOAT + * H5T_NATIVE_SHORT H5T_NATIVE_DOUBLE + * H5T_NATIVE_INT H5T_NATIVE_LDOUBLE + * H5T_NATIVE_LONG + * H5T_NATIVE_LLONG * - * Return: Success: 0 + * Return: Success: 0 * - * Failure: number of errors + * Failure: number of errors * - * Programmer: Raymond Lu + * Programmer: Raymond Lu * Thursday, November 6, 2003 * * Modifications: @@ -3407,216 +3504,236 @@ error: static int test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) { - hid_t dxpl_id; /*dataset transfer property list*/ - int fill_value=9; /*fill value for conversion exception*/ - H5T_conv_except_func_t op; /*returned callback function for conversion exception*/ - void *user_data; /*returned pointer to user data passed in to the callback*/ - hbool_t except_set = FALSE; /*whether user's exception handling is set*/ - size_t nelmts=0; /*num values per test */ - const size_t max_fails=40; /*max number of failures*/ - size_t fails_all_tests=0; /*number of failures */ - size_t fails_this_test; /*fails for this test */ - char str[256]; /*hello string */ - dtype_t src_type; /*data types */ - dtype_t dst_type; /*data types */ - const char *src_type_name=NULL; /*source type name */ - const char *dst_type_name=NULL; /*destination type name */ - int sendian; /*source endianess */ - int dendian; /*destination endianess */ - size_t src_size, dst_size; /*type sizes */ - unsigned char *buf=NULL; /*buffer for conversion */ - unsigned char *saved=NULL; /*original values */ - size_t j, k; /*counters */ - unsigned char *hw=NULL; /*hardware conv result */ - unsigned char src_bits[32]; /*src value in LE order */ - unsigned char dst_bits[32]; /*dest value in LE order*/ - size_t src_nbits; /*source length in bits */ - size_t dst_nbits; /*dst length in bits */ - void *aligned=NULL; /*aligned temp buffer */ - float hw_float=0; - double hw_double=0; - long double hw_ldouble=0; - signed char hw_schar=0; - unsigned char hw_uchar=0; - short hw_short=0; - unsigned short hw_ushort=0; - int hw_int=0; - unsigned hw_uint=0; - long hw_long=0; - unsigned long hw_ulong=0; - long long hw_llong=0; - unsigned long long hw_ullong=0; + hid_t dxpl_id; /*dataset transfer property list*/ + int fill_value = 9; /*fill value for conversion exception*/ + H5T_conv_except_func_t op; /*returned callback function for conversion exception*/ + void * user_data; /*returned pointer to user data passed in to the callback*/ + hbool_t except_set = FALSE; /*whether user's exception handling is set*/ + size_t nelmts = 0; /*num values per test */ + const size_t max_fails = 40; /*max number of failures*/ + size_t fails_all_tests = 0; /*number of failures */ + size_t fails_this_test; /*fails for this test */ + char str[256]; /*hello string */ + dtype_t src_type; /*data types */ + dtype_t dst_type; /*data types */ + const char * src_type_name = NULL; /*source type name */ + const char * dst_type_name = NULL; /*destination type name */ + int sendian; /*source endianess */ + int dendian; /*destination endianess */ + size_t src_size, dst_size; /*type sizes */ + unsigned char * buf = NULL; /*buffer for conversion */ + unsigned char * saved = NULL; /*original values */ + size_t j, k; /*counters */ + unsigned char * hw = NULL; /*hardware conv result */ + unsigned char src_bits[32]; /*src value in LE order */ + unsigned char dst_bits[32]; /*dest value in LE order*/ + size_t src_nbits; /*source length in bits */ + size_t dst_nbits; /*dst length in bits */ + void * aligned = NULL; /*aligned temp buffer */ + float hw_float = 0; + double hw_double = 0; + long double hw_ldouble = 0; + signed char hw_schar = 0; + unsigned char hw_uchar = 0; + short hw_short = 0; + unsigned short hw_ushort = 0; + int hw_int = 0; + unsigned hw_uint = 0; + long hw_long = 0; + unsigned long hw_ulong = 0; + long long hw_llong = 0; + unsigned long long hw_ullong = 0; /* What is the name of the source type */ if (H5Tequal(src, H5T_NATIVE_SCHAR)) { - src_type_name = "signed char"; - src_type = INT_SCHAR; - } else if (H5Tequal(src, H5T_NATIVE_UCHAR)) { - src_type_name = "unsigned char"; - src_type = INT_UCHAR; - } else if (H5Tequal(src, H5T_NATIVE_SHORT)) { - src_type_name = "short"; - src_type = INT_SHORT; - } else if (H5Tequal(src, H5T_NATIVE_USHORT)) { - src_type_name = "unsigned short"; - src_type = INT_USHORT; - } else if (H5Tequal(src, H5T_NATIVE_INT)) { - src_type_name = "int"; - src_type = INT_INT; - } else if (H5Tequal(src, H5T_NATIVE_UINT)) { - src_type_name = "unsigned int"; - src_type = INT_UINT; - } else if (H5Tequal(src, H5T_NATIVE_LONG)) { - src_type_name = "long"; - src_type = INT_LONG; - } else if (H5Tequal(src, H5T_NATIVE_ULONG)) { - src_type_name = "unsigned long"; - src_type = INT_ULONG; - } else if (H5Tequal(src, H5T_NATIVE_LLONG)) { - src_type_name = "long long"; - src_type = INT_LLONG; - } else if (H5Tequal(src, H5T_NATIVE_ULLONG)) { - src_type_name = "unsigned long long"; - src_type = INT_ULLONG; - } else if (H5Tequal(src, H5T_NATIVE_FLOAT)) { - src_type_name = "float"; - src_type = FLT_FLOAT; - } else if (H5Tequal(src, H5T_NATIVE_DOUBLE)) { - src_type_name = "double"; - src_type = FLT_DOUBLE; -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if (H5Tequal(src, H5T_NATIVE_LDOUBLE)) { - src_type_name = "long double"; - src_type = FLT_LDOUBLE; + src_type_name = "signed char"; + src_type = INT_SCHAR; + } + else if (H5Tequal(src, H5T_NATIVE_UCHAR)) { + src_type_name = "unsigned char"; + src_type = INT_UCHAR; + } + else if (H5Tequal(src, H5T_NATIVE_SHORT)) { + src_type_name = "short"; + src_type = INT_SHORT; + } + else if (H5Tequal(src, H5T_NATIVE_USHORT)) { + src_type_name = "unsigned short"; + src_type = INT_USHORT; + } + else if (H5Tequal(src, H5T_NATIVE_INT)) { + src_type_name = "int"; + src_type = INT_INT; + } + else if (H5Tequal(src, H5T_NATIVE_UINT)) { + src_type_name = "unsigned int"; + src_type = INT_UINT; + } + else if (H5Tequal(src, H5T_NATIVE_LONG)) { + src_type_name = "long"; + src_type = INT_LONG; + } + else if (H5Tequal(src, H5T_NATIVE_ULONG)) { + src_type_name = "unsigned long"; + src_type = INT_ULONG; + } + else if (H5Tequal(src, H5T_NATIVE_LLONG)) { + src_type_name = "long long"; + src_type = INT_LLONG; + } + else if (H5Tequal(src, H5T_NATIVE_ULLONG)) { + src_type_name = "unsigned long long"; + src_type = INT_ULLONG; + } + else if (H5Tequal(src, H5T_NATIVE_FLOAT)) { + src_type_name = "float"; + src_type = FLT_FLOAT; + } + else if (H5Tequal(src, H5T_NATIVE_DOUBLE)) { + src_type_name = "double"; + src_type = FLT_DOUBLE; +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (H5Tequal(src, H5T_NATIVE_LDOUBLE)) { + src_type_name = "long double"; + src_type = FLT_LDOUBLE; #endif - } else { - src_type_name = "UNKNOWN"; - src_type = OTHER; + } + else { + src_type_name = "UNKNOWN"; + src_type = OTHER; } /* What is the name of the destination type */ if (H5Tequal(dst, H5T_NATIVE_SCHAR)) { - dst_type_name = "signed char"; - dst_type = INT_SCHAR; - } else if (H5Tequal(dst, H5T_NATIVE_UCHAR)) { - dst_type_name = "unsigned char"; - dst_type = INT_UCHAR; - } else if (H5Tequal(dst, H5T_NATIVE_SHORT)) { - dst_type_name = "short"; - dst_type = INT_SHORT; - } else if (H5Tequal(dst, H5T_NATIVE_USHORT)) { - dst_type_name = "unsigned short"; - dst_type = INT_USHORT; - } else if (H5Tequal(dst, H5T_NATIVE_INT)) { - dst_type_name = "int"; - dst_type = INT_INT; - } else if (H5Tequal(dst, H5T_NATIVE_UINT)) { - dst_type_name = "unsigned int"; - dst_type = INT_UINT; - } else if (H5Tequal(dst, H5T_NATIVE_LONG)) { - dst_type_name = "long"; - dst_type = INT_LONG; - } else if (H5Tequal(dst, H5T_NATIVE_ULONG)) { - dst_type_name = "unsigned long"; - dst_type = INT_ULONG; - } else if (H5Tequal(dst, H5T_NATIVE_LLONG)) { - dst_type_name = "long long"; - dst_type = INT_LLONG; - } else if (H5Tequal(dst, H5T_NATIVE_ULLONG)) { - dst_type_name = "unsigned long long"; - dst_type = INT_ULLONG; - } else if (H5Tequal(dst, H5T_NATIVE_FLOAT)) { - dst_type_name = "float"; - dst_type = FLT_FLOAT; - } else if (H5Tequal(dst, H5T_NATIVE_DOUBLE)) { - dst_type_name = "double"; - dst_type = FLT_DOUBLE; -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if (H5Tequal(dst, H5T_NATIVE_LDOUBLE)) { - dst_type_name = "long double"; - dst_type = FLT_LDOUBLE; + dst_type_name = "signed char"; + dst_type = INT_SCHAR; + } + else if (H5Tequal(dst, H5T_NATIVE_UCHAR)) { + dst_type_name = "unsigned char"; + dst_type = INT_UCHAR; + } + else if (H5Tequal(dst, H5T_NATIVE_SHORT)) { + dst_type_name = "short"; + dst_type = INT_SHORT; + } + else if (H5Tequal(dst, H5T_NATIVE_USHORT)) { + dst_type_name = "unsigned short"; + dst_type = INT_USHORT; + } + else if (H5Tequal(dst, H5T_NATIVE_INT)) { + dst_type_name = "int"; + dst_type = INT_INT; + } + else if (H5Tequal(dst, H5T_NATIVE_UINT)) { + dst_type_name = "unsigned int"; + dst_type = INT_UINT; + } + else if (H5Tequal(dst, H5T_NATIVE_LONG)) { + dst_type_name = "long"; + dst_type = INT_LONG; + } + else if (H5Tequal(dst, H5T_NATIVE_ULONG)) { + dst_type_name = "unsigned long"; + dst_type = INT_ULONG; + } + else if (H5Tequal(dst, H5T_NATIVE_LLONG)) { + dst_type_name = "long long"; + dst_type = INT_LLONG; + } + else if (H5Tequal(dst, H5T_NATIVE_ULLONG)) { + dst_type_name = "unsigned long long"; + dst_type = INT_ULLONG; + } + else if (H5Tequal(dst, H5T_NATIVE_FLOAT)) { + dst_type_name = "float"; + dst_type = FLT_FLOAT; + } + else if (H5Tequal(dst, H5T_NATIVE_DOUBLE)) { + dst_type_name = "double"; + dst_type = FLT_DOUBLE; +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (H5Tequal(dst, H5T_NATIVE_LDOUBLE)) { + dst_type_name = "long double"; + dst_type = FLT_LDOUBLE; #endif - } else { - dst_type_name = "UNKNOWN"; - dst_type = OTHER; + } + else { + dst_type_name = "UNKNOWN"; + dst_type = OTHER; } /* Sanity checks */ - if (OTHER==src_type || OTHER==dst_type) { - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, src_type_name, dst_type_name); - printf("%-70s", str); - H5_FAILED(); - HDputs(" Unknown data type."); - goto error; - } - - if ((INT_SCHAR==src_type || INT_UCHAR==src_type || INT_SHORT==src_type || - INT_USHORT==src_type || INT_INT==src_type || INT_UINT==src_type || - INT_LONG==src_type || INT_ULONG==src_type || INT_LLONG==src_type || - INT_ULLONG==src_type) && - (FLT_FLOAT!=dst_type && FLT_DOUBLE!=dst_type -#if H5_SIZEOF_LONG_DOUBLE !=0 - && FLT_LDOUBLE!=dst_type + if (OTHER == src_type || OTHER == dst_type) { + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, src_type_name, dst_type_name); + HDprintf("%-70s", str); + H5_FAILED(); + HDputs(" Unknown data type."); + goto error; + } + + if ((INT_SCHAR == src_type || INT_UCHAR == src_type || INT_SHORT == src_type || INT_USHORT == src_type || + INT_INT == src_type || INT_UINT == src_type || INT_LONG == src_type || INT_ULONG == src_type || + INT_LLONG == src_type || INT_ULLONG == src_type) && + (FLT_FLOAT != dst_type && FLT_DOUBLE != dst_type +#if H5_SIZEOF_LONG_DOUBLE != 0 + && FLT_LDOUBLE != dst_type #endif - )) { - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, src_type_name, dst_type_name); - printf("%-70s", str); - H5_FAILED(); - HDputs(" 1. Not an integer-float conversion."); - goto error; - } - - if ((FLT_FLOAT==src_type || FLT_DOUBLE==src_type -#if H5_SIZEOF_LONG_DOUBLE !=0 - || FLT_LDOUBLE==src_type + )) { + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, src_type_name, dst_type_name); + HDprintf("%-70s", str); + H5_FAILED(); + HDputs(" 1. Not an integer-float conversion."); + goto error; + } + + if ((FLT_FLOAT == src_type || FLT_DOUBLE == src_type +#if H5_SIZEOF_LONG_DOUBLE != 0 + || FLT_LDOUBLE == src_type #endif - ) - && (INT_SCHAR!=dst_type && INT_UCHAR!=dst_type && INT_SHORT!=dst_type - && INT_USHORT!=dst_type && INT_INT!=dst_type && INT_UINT!=dst_type - && INT_LONG!=dst_type && INT_ULONG!=dst_type && INT_LLONG!=dst_type - && INT_ULLONG!=dst_type)) { - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, src_type_name, dst_type_name); - printf("%-70s", str); - H5_FAILED(); - HDputs(" 2. Not a float-integer conversion."); - goto error; - } - - if (INT_SCHAR==src_type || INT_UCHAR==src_type || INT_SHORT==src_type || - INT_USHORT==src_type || INT_INT==src_type || INT_UINT==src_type || - INT_LONG==src_type || INT_ULONG==src_type || INT_LLONG==src_type || - INT_ULLONG==src_type) { - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, src_type_name, dst_type_name); - printf("%-70s", str); + ) && + (INT_SCHAR != dst_type && INT_UCHAR != dst_type && INT_SHORT != dst_type && INT_USHORT != dst_type && + INT_INT != dst_type && INT_UINT != dst_type && INT_LONG != dst_type && INT_ULONG != dst_type && + INT_LLONG != dst_type && INT_ULLONG != dst_type)) { + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, src_type_name, dst_type_name); + HDprintf("%-70s", str); + H5_FAILED(); + HDputs(" 2. Not a float-integer conversion."); + goto error; + } + + if (INT_SCHAR == src_type || INT_UCHAR == src_type || INT_SHORT == src_type || INT_USHORT == src_type || + INT_INT == src_type || INT_UINT == src_type || INT_LONG == src_type || INT_ULONG == src_type || + INT_LLONG == src_type || INT_ULLONG == src_type) { + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, src_type_name, dst_type_name); + HDprintf("%-70s", str); HDfflush(stdout); - fails_this_test=0; - } else { - if(run_test==TEST_NORMAL) - HDsnprintf(str, sizeof(str), "Testing %s normalized %s -> %s conversions", - name, src_type_name, dst_type_name); - else if(run_test==TEST_DENORM) - HDsnprintf(str, sizeof(str), "Testing %s denormalized %s -> %s conversions", - name, src_type_name, dst_type_name); + fails_this_test = 0; + } + else { + if (run_test == TEST_NORMAL) + HDsnprintf(str, sizeof(str), "Testing %s normalized %s -> %s conversions", name, src_type_name, + dst_type_name); + else if (run_test == TEST_DENORM) + HDsnprintf(str, sizeof(str), "Testing %s denormalized %s -> %s conversions", name, src_type_name, + dst_type_name); else - HDsnprintf(str, sizeof(str), "Testing %s special %s -> %s conversions", - name, src_type_name, dst_type_name); - printf("%-70s", str); + HDsnprintf(str, sizeof(str), "Testing %s special %s -> %s conversions", name, src_type_name, + dst_type_name); + HDprintf("%-70s", str); HDfflush(stdout); - fails_this_test=0; + fails_this_test = 0; } /* Some information about datatypes */ - sendian = H5Tget_order(src); - dendian = H5Tget_order(dst); - src_size = H5Tget_size(src); - dst_size = H5Tget_size(dst); + sendian = H5Tget_order(src); + dendian = H5Tget_order(dst); + src_size = H5Tget_size(src); + dst_size = H5Tget_size(dst); src_nbits = H5Tget_precision(src); /* not 8*src_size, esp on J90 - QAK */ dst_nbits = H5Tget_precision(dst); /* not 8*dst_size, esp on J90 - QAK */ - aligned = HDcalloc((size_t)1, MAX(sizeof(long double), sizeof(long long))); + aligned = HDcalloc((size_t)1, MAX(sizeof(long double), sizeof(long long))); #ifdef SHOW_OVERFLOWS noverflows_g = 0; #endif @@ -3633,22 +3750,20 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) * conversion exception happens. We only test (unsigned) int - float * and float - (unsigned) int conversions, which should cover more cases. */ - if((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) + if ((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) goto error; - if((src_type == INT_INT && dst_type == FLT_FLOAT) || - (src_type == INT_UINT && dst_type == FLT_FLOAT) || - (src_type == FLT_FLOAT && dst_type == INT_UINT) || - (src_type == FLT_FLOAT && dst_type == INT_INT)) { - if(H5Pset_type_conv_cb(dxpl_id, except_func, &fill_value) < 0) + if ((src_type == INT_INT && dst_type == FLT_FLOAT) || (src_type == INT_UINT && dst_type == FLT_FLOAT) || + (src_type == FLT_FLOAT && dst_type == INT_UINT) || (src_type == FLT_FLOAT && dst_type == INT_INT)) { + if (H5Pset_type_conv_cb(dxpl_id, except_func, &fill_value) < 0) goto error; else except_set = TRUE; - if(H5Pget_type_conv_cb(dxpl_id, &op, &user_data) < 0) + if (H5Pget_type_conv_cb(dxpl_id, &op, &user_data) < 0) goto error; - if(op != except_func || *(int*)user_data != fill_value) + if (op != except_func || *(int *)user_data != fill_value) goto error; } @@ -3656,554 +3771,583 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) * INIT_FP_NORM if floating-point. The BUF will be used for the conversion while the SAVED buffer will be * used for the comparison later. */ - if(src_type == INT_SCHAR) { + if (src_type == INT_SCHAR) { INIT_INTEGER(signed char, SCHAR_MAX, SCHAR_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_UCHAR) { + } + else if (src_type == INT_UCHAR) { INIT_INTEGER(unsigned char, UCHAR_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_SHORT) { + } + else if (src_type == INT_SHORT) { INIT_INTEGER(short, SHRT_MAX, SHRT_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_USHORT) { + } + else if (src_type == INT_USHORT) { INIT_INTEGER(unsigned short, USHRT_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_INT) { + } + else if (src_type == INT_INT) { INIT_INTEGER(int, INT_MAX, INT_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_UINT) { + } + else if (src_type == INT_UINT) { INIT_INTEGER(unsigned int, UINT_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_LONG) { + } + else if (src_type == INT_LONG) { INIT_INTEGER(long, LONG_MAX, LONG_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_ULONG) { + } + else if (src_type == INT_ULONG) { INIT_INTEGER(unsigned long, ULONG_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_LLONG) { + } + else if (src_type == INT_LLONG) { INIT_INTEGER(long long, LLONG_MAX, LLONG_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == INT_ULLONG) { + } + else if (src_type == INT_ULLONG) { INIT_INTEGER(unsigned long long, ULLONG_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == FLT_FLOAT) { - if(run_test==TEST_NORMAL) { - INIT_FP_NORM(float, FLT_MAX, FLT_MIN, FLT_MAX_10_EXP, FLT_MIN_10_EXP, - src_size, dst_size, buf, saved, nelmts); - } else if(run_test==TEST_DENORM) { - INIT_FP_DENORM(float, FLT_MANT_DIG, src_size, src_nbits, sendian, dst_size, - buf, saved, nelmts); - } else { + } + else if (src_type == FLT_FLOAT) { + if (run_test == TEST_NORMAL) { + INIT_FP_NORM(float, FLT_MAX, FLT_MIN, FLT_MAX_10_EXP, FLT_MIN_10_EXP, src_size, dst_size, buf, + saved, nelmts); + } + else if (run_test == TEST_DENORM) { + INIT_FP_DENORM(float, FLT_MANT_DIG, src_size, src_nbits, sendian, dst_size, buf, saved, nelmts); + } + else { INIT_FP_SPECIAL(src_size, src_nbits, sendian, FLT_MANT_DIG, dst_size, buf, saved, nelmts); } - } else if(src_type == FLT_DOUBLE) { - if(run_test==TEST_NORMAL) { - INIT_FP_NORM(double, DBL_MAX, DBL_MIN, DBL_MAX_10_EXP, DBL_MIN_10_EXP, - src_size, dst_size, buf, saved, nelmts); - } else if(run_test==TEST_DENORM) { - INIT_FP_DENORM(double, DBL_MANT_DIG, src_size, src_nbits, sendian, dst_size, - buf, saved, nelmts); - } else { + } + else if (src_type == FLT_DOUBLE) { + if (run_test == TEST_NORMAL) { + INIT_FP_NORM(double, DBL_MAX, DBL_MIN, DBL_MAX_10_EXP, DBL_MIN_10_EXP, src_size, dst_size, buf, + saved, nelmts); + } + else if (run_test == TEST_DENORM) { + INIT_FP_DENORM(double, DBL_MANT_DIG, src_size, src_nbits, sendian, dst_size, buf, saved, nelmts); + } + else { INIT_FP_SPECIAL(src_size, src_nbits, sendian, DBL_MANT_DIG, dst_size, buf, saved, nelmts); } -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 - } else if(src_type == FLT_LDOUBLE) { - if(run_test==TEST_NORMAL) { - INIT_FP_NORM(long double, LDBL_MAX, LDBL_MIN, LDBL_MAX_10_EXP, LDBL_MIN_10_EXP, - src_size, dst_size, buf, saved, nelmts); - } else if(run_test==TEST_DENORM) { - INIT_FP_DENORM(long double, LDBL_MANT_DIG, src_size, src_nbits, sendian, dst_size, - buf, saved, nelmts); - } else { +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (src_type == FLT_LDOUBLE) { + if (run_test == TEST_NORMAL) { + INIT_FP_NORM(long double, LDBL_MAX, LDBL_MIN, LDBL_MAX_10_EXP, LDBL_MIN_10_EXP, src_size, + dst_size, buf, saved, nelmts); + } + else if (run_test == TEST_DENORM) { + INIT_FP_DENORM(long double, LDBL_MANT_DIG, src_size, src_nbits, sendian, dst_size, buf, saved, + nelmts); + } + else { INIT_FP_SPECIAL(src_size, src_nbits, sendian, LDBL_MANT_DIG, dst_size, buf, saved, nelmts); } #endif - } else + } + else goto error; /* Perform the conversion */ - if(H5Tconvert(src, dst, nelmts, buf, NULL, dxpl_id) < 0) + if (H5Tconvert(src, dst, nelmts, buf, NULL, dxpl_id) < 0) goto error; /* Check the results from the library against hardware */ - for (j=0; j<nelmts; j++) { - if(FLT_FLOAT==src_type || FLT_DOUBLE==src_type -#if H5_SIZEOF_LONG_DOUBLE !=0 - || FLT_LDOUBLE==src_type + for (j = 0; j < nelmts; j++) { + if (FLT_FLOAT == src_type || FLT_DOUBLE == src_type +#if H5_SIZEOF_LONG_DOUBLE != 0 + || FLT_LDOUBLE == src_type #endif - ) - if(my_isnan(src_type, saved+j*src_size)) + ) + if (my_isnan(src_type, saved + j * src_size)) continue; - if (FLT_FLOAT==dst_type) { - hw = (unsigned char*)&hw_float; + if (FLT_FLOAT == dst_type) { + hw = (unsigned char *)&hw_float; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_float = (float)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_float = (float)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_float = (float)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_float = (float)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_float = (float)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_float = (float)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_float = (float)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_float = (float)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_float = (float)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_float = (float)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_float = (float)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_float = (float)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_float = (float)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_float = (float)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_float = (float)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_float = (float)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_float = (float)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_float = (float)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_float = (float)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_float = (float)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (FLT_DOUBLE==dst_type) { - hw = (unsigned char*)&hw_double; + } + else if (FLT_DOUBLE == dst_type) { + hw = (unsigned char *)&hw_double; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_double = (double)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_double = (double)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_double = (double)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_double = (double)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_double = (double)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_double = (double)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_double = (double)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_double = (double)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_double = (double)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_double = (double)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_double = (double)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_double = (double)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_double = (double)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_double = (double)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_double = (double)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_double = (double)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_double = (double)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_double = (double)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_double = (double)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_double = (double)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } -#if H5_SIZEOF_LONG_DOUBLE !=0 - } else if (FLT_LDOUBLE==dst_type) { - hw = (unsigned char*)&hw_ldouble; +#if H5_SIZEOF_LONG_DOUBLE != 0 + } + else if (FLT_LDOUBLE == dst_type) { + hw = (unsigned char *)&hw_ldouble; switch (src_type) { - case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - hw_ldouble = (long double)(*((signed char*)aligned)); - break; - case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - hw_ldouble = (long double)(*((unsigned char*)aligned)); - break; - case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - hw_ldouble = (long double)(*((short*)aligned)); - break; - case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - hw_ldouble = (long double)(*((unsigned short*)aligned)); - break; - case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - hw_ldouble = (long double)(*((int*)aligned)); - break; - case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - hw_ldouble = (long double)(*((unsigned*)aligned)); - break; - case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - hw_ldouble = (long double)(*((long*)aligned)); - break; - case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - hw_ldouble = (long double)(*((unsigned long*)aligned)); - break; - case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - hw_ldouble = (long double)(*((long long*)aligned)); - break; - case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - hw_ldouble = (long double)(*((unsigned long long*)aligned)); - break; - case FLT_FLOAT: - case FLT_DOUBLE: - case FLT_LDOUBLE: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + hw_ldouble = (long double)(*((signed char *)aligned)); + break; + case INT_UCHAR: + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + hw_ldouble = (long double)(*((unsigned char *)aligned)); + break; + case INT_SHORT: + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + hw_ldouble = (long double)(*((short *)aligned)); + break; + case INT_USHORT: + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + hw_ldouble = (long double)(*((unsigned short *)aligned)); + break; + case INT_INT: + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + hw_ldouble = (long double)(*((int *)aligned)); + break; + case INT_UINT: + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + hw_ldouble = (long double)(*((unsigned *)aligned)); + break; + case INT_LONG: + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + hw_ldouble = (long double)(*((long *)aligned)); + break; + case INT_ULONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + hw_ldouble = (long double)(*((unsigned long *)aligned)); + break; + case INT_LLONG: + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + hw_ldouble = (long double)(*((long long *)aligned)); + break; + case INT_ULLONG: + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + hw_ldouble = (long double)(*((unsigned long long *)aligned)); + break; + case FLT_FLOAT: + case FLT_DOUBLE: + case FLT_LDOUBLE: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } #endif - } else if (INT_SCHAR==dst_type) { - hw = (unsigned char*)&hw_schar; + } + else if (INT_SCHAR == dst_type) { + hw = (unsigned char *)&hw_schar; switch (src_type) { - case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - hw_schar = (signed char)(*((float*)aligned)); - break; - case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - hw_schar = (signed char)(*((double*)aligned)); - break; -#if H5_SIZEOF_LONG_DOUBLE !=0 - case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - hw_schar = (signed char)(*((long double*)aligned)); - break; + case FLT_FLOAT: + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + hw_schar = (signed char)(*((float *)aligned)); + break; + case FLT_DOUBLE: + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + hw_schar = (signed char)(*((double *)aligned)); + break; +#if H5_SIZEOF_LONG_DOUBLE != 0 + case FLT_LDOUBLE: + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + hw_schar = (signed char)(*((long double *)aligned)); + break; #endif - case INT_SCHAR: - case INT_UCHAR: - case INT_SHORT: - case INT_USHORT: - case INT_INT: - case INT_UINT: - case INT_LONG: - case INT_ULONG: - case INT_LLONG: - case INT_ULLONG: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + case INT_UCHAR: + case INT_SHORT: + case INT_USHORT: + case INT_INT: + case INT_UINT: + case INT_LONG: + case INT_ULONG: + case INT_LLONG: + case INT_ULLONG: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_UCHAR==dst_type) { - hw = (unsigned char*)&hw_uchar; + } + else if (INT_UCHAR == dst_type) { + hw = (unsigned char *)&hw_uchar; switch (src_type) { - case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - hw_uchar = (unsigned char)(*((float*)aligned)); - break; - case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - hw_uchar = (unsigned char)(*((double*)aligned)); - break; -#if H5_SIZEOF_LONG_DOUBLE !=0 - case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - hw_uchar = (unsigned char)(*((long double*)aligned)); - break; + case FLT_FLOAT: + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + hw_uchar = (unsigned char)(*((float *)aligned)); + break; + case FLT_DOUBLE: + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + hw_uchar = (unsigned char)(*((double *)aligned)); + break; +#if H5_SIZEOF_LONG_DOUBLE != 0 + case FLT_LDOUBLE: + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + hw_uchar = (unsigned char)(*((long double *)aligned)); + break; #endif - case INT_SCHAR: - case INT_UCHAR: - case INT_SHORT: - case INT_USHORT: - case INT_INT: - case INT_UINT: - case INT_LONG: - case INT_ULONG: - case INT_LLONG: - case INT_ULLONG: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + case INT_UCHAR: + case INT_SHORT: + case INT_USHORT: + case INT_INT: + case INT_UINT: + case INT_LONG: + case INT_ULONG: + case INT_LLONG: + case INT_ULLONG: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_SHORT==dst_type) { - hw = (unsigned char*)&hw_short; + } + else if (INT_SHORT == dst_type) { + hw = (unsigned char *)&hw_short; switch (src_type) { - case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - hw_short = (short)(*((float*)aligned)); - break; - case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - hw_short = (short)(*((double*)aligned)); - break; -#if H5_SIZEOF_LONG_DOUBLE !=0 - case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - hw_short = (short)(*((long double*)aligned)); - break; + case FLT_FLOAT: + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + hw_short = (short)(*((float *)aligned)); + break; + case FLT_DOUBLE: + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + hw_short = (short)(*((double *)aligned)); + break; +#if H5_SIZEOF_LONG_DOUBLE != 0 + case FLT_LDOUBLE: + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + hw_short = (short)(*((long double *)aligned)); + break; #endif - case INT_SCHAR: - case INT_UCHAR: - case INT_SHORT: - case INT_USHORT: - case INT_INT: - case INT_UINT: - case INT_LONG: - case INT_ULONG: - case INT_LLONG: - case INT_ULLONG: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + case INT_UCHAR: + case INT_SHORT: + case INT_USHORT: + case INT_INT: + case INT_UINT: + case INT_LONG: + case INT_ULONG: + case INT_LLONG: + case INT_ULLONG: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_USHORT==dst_type) { - hw = (unsigned char*)&hw_ushort; + } + else if (INT_USHORT == dst_type) { + hw = (unsigned char *)&hw_ushort; switch (src_type) { - case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - hw_ushort = (unsigned short)(*((float*)aligned)); - break; - case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - hw_ushort = (unsigned short)(*((double*)aligned)); - break; -#if H5_SIZEOF_LONG_DOUBLE !=0 - case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - hw_ushort = (unsigned short)(*((long double*)aligned)); - break; + case FLT_FLOAT: + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + hw_ushort = (unsigned short)(*((float *)aligned)); + break; + case FLT_DOUBLE: + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + hw_ushort = (unsigned short)(*((double *)aligned)); + break; +#if H5_SIZEOF_LONG_DOUBLE != 0 + case FLT_LDOUBLE: + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + hw_ushort = (unsigned short)(*((long double *)aligned)); + break; #endif - case INT_SCHAR: - case INT_UCHAR: - case INT_SHORT: - case INT_USHORT: - case INT_INT: - case INT_UINT: - case INT_LONG: - case INT_ULONG: - case INT_LLONG: - case INT_ULLONG: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + case INT_UCHAR: + case INT_SHORT: + case INT_USHORT: + case INT_INT: + case INT_UINT: + case INT_LONG: + case INT_ULONG: + case INT_LLONG: + case INT_ULLONG: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_INT==dst_type) { - hw = (unsigned char*)&hw_int; + } + else if (INT_INT == dst_type) { + hw = (unsigned char *)&hw_int; switch (src_type) { - case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - hw_int = (int)(*((float*)aligned)); - break; - case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - hw_int = (int)(*((double*)aligned)); - break; -#if H5_SIZEOF_LONG_DOUBLE !=0 - case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - hw_int = (int)(*((long double*)aligned)); - break; + case FLT_FLOAT: + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + hw_int = (int)(*((float *)aligned)); + break; + case FLT_DOUBLE: + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + hw_int = (int)(*((double *)aligned)); + break; +#if H5_SIZEOF_LONG_DOUBLE != 0 + case FLT_LDOUBLE: + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + hw_int = (int)(*((long double *)aligned)); + break; #endif - case INT_SCHAR: - case INT_UCHAR: - case INT_SHORT: - case INT_USHORT: - case INT_INT: - case INT_UINT: - case INT_LONG: - case INT_ULONG: - case INT_LLONG: - case INT_ULLONG: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + case INT_UCHAR: + case INT_SHORT: + case INT_USHORT: + case INT_INT: + case INT_UINT: + case INT_LONG: + case INT_ULONG: + case INT_LLONG: + case INT_ULLONG: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_UINT==dst_type) { - hw = (unsigned char*)&hw_uint; + } + else if (INT_UINT == dst_type) { + hw = (unsigned char *)&hw_uint; switch (src_type) { - case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - hw_uint = (unsigned int)(*((float*)aligned)); - break; - case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - hw_uint = (unsigned int)(*((double*)aligned)); - break; -#if H5_SIZEOF_LONG_DOUBLE !=0 - case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - hw_uint = (unsigned int)(*((long double*)aligned)); - break; + case FLT_FLOAT: + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + hw_uint = (unsigned int)(*((float *)aligned)); + break; + case FLT_DOUBLE: + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + hw_uint = (unsigned int)(*((double *)aligned)); + break; +#if H5_SIZEOF_LONG_DOUBLE != 0 + case FLT_LDOUBLE: + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + hw_uint = (unsigned int)(*((long double *)aligned)); + break; #endif - case INT_SCHAR: - case INT_UCHAR: - case INT_SHORT: - case INT_USHORT: - case INT_INT: - case INT_UINT: - case INT_LONG: - case INT_ULONG: - case INT_LLONG: - case INT_ULLONG: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + case INT_UCHAR: + case INT_SHORT: + case INT_USHORT: + case INT_INT: + case INT_UINT: + case INT_LONG: + case INT_ULONG: + case INT_LLONG: + case INT_ULLONG: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_LONG==dst_type) { - hw = (unsigned char*)&hw_long; + } + else if (INT_LONG == dst_type) { + hw = (unsigned char *)&hw_long; switch (src_type) { - case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - hw_long = (long)(*((float*)aligned)); - break; - case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - hw_long = (long)(*((double*)aligned)); - break; -#if H5_SIZEOF_LONG_DOUBLE !=0 - case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - hw_long = (long)(*((long double*)aligned)); - break; + case FLT_FLOAT: + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + hw_long = (long)(*((float *)aligned)); + break; + case FLT_DOUBLE: + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + hw_long = (long)(*((double *)aligned)); + break; +#if H5_SIZEOF_LONG_DOUBLE != 0 + case FLT_LDOUBLE: + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + hw_long = (long)(*((long double *)aligned)); + break; #endif - case INT_SCHAR: - case INT_UCHAR: - case INT_SHORT: - case INT_USHORT: - case INT_INT: - case INT_UINT: - case INT_LONG: - case INT_ULONG: - case INT_LLONG: - case INT_ULLONG: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + case INT_UCHAR: + case INT_SHORT: + case INT_USHORT: + case INT_INT: + case INT_UINT: + case INT_LONG: + case INT_ULONG: + case INT_LLONG: + case INT_ULLONG: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_ULONG==dst_type) { - hw = (unsigned char*)&hw_ulong; + } + else if (INT_ULONG == dst_type) { + hw = (unsigned char *)&hw_ulong; switch (src_type) { - case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - hw_ulong = (unsigned long)(*((float*)aligned)); - break; - case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - hw_ulong = (unsigned long)(*((double*)aligned)); - break; -#if H5_SIZEOF_LONG_DOUBLE !=0 - case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - hw_ulong = (unsigned long)(*((long double*)aligned)); - break; + case FLT_FLOAT: + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + hw_ulong = (unsigned long)(*((float *)aligned)); + break; + case FLT_DOUBLE: + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + hw_ulong = (unsigned long)(*((double *)aligned)); + break; +#if H5_SIZEOF_LONG_DOUBLE != 0 + case FLT_LDOUBLE: + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + hw_ulong = (unsigned long)(*((long double *)aligned)); + break; #endif - case INT_SCHAR: - case INT_UCHAR: - case INT_SHORT: - case INT_USHORT: - case INT_INT: - case INT_UINT: - case INT_LONG: - case INT_ULONG: - case INT_LLONG: - case INT_ULLONG: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + case INT_UCHAR: + case INT_SHORT: + case INT_USHORT: + case INT_INT: + case INT_UINT: + case INT_LONG: + case INT_ULONG: + case INT_LLONG: + case INT_ULLONG: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_LLONG==dst_type) { - hw = (unsigned char*)&hw_llong; + } + else if (INT_LLONG == dst_type) { + hw = (unsigned char *)&hw_llong; switch (src_type) { - case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - hw_llong = (long long)(*((float*)aligned)); - break; - case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - hw_llong = (long long)(*((double*)aligned)); - break; -#if H5_SIZEOF_LONG_DOUBLE !=0 - case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - hw_llong = (long long)(*((long double*)aligned)); - break; + case FLT_FLOAT: + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + hw_llong = (long long)(*((float *)aligned)); + break; + case FLT_DOUBLE: + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + hw_llong = (long long)(*((double *)aligned)); + break; +#if H5_SIZEOF_LONG_DOUBLE != 0 + case FLT_LDOUBLE: + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + hw_llong = (long long)(*((long double *)aligned)); + break; #endif - case INT_SCHAR: - case INT_UCHAR: - case INT_SHORT: - case INT_USHORT: - case INT_INT: - case INT_UINT: - case INT_LONG: - case INT_ULONG: - case INT_LLONG: - case INT_ULLONG: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + case INT_UCHAR: + case INT_SHORT: + case INT_USHORT: + case INT_INT: + case INT_UINT: + case INT_LONG: + case INT_ULONG: + case INT_LLONG: + case INT_ULLONG: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } - } else if (INT_ULLONG==dst_type) { - hw = (unsigned char*)&hw_ullong; + } + else if (INT_ULLONG == dst_type) { + hw = (unsigned char *)&hw_ullong; switch (src_type) { - case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - hw_ullong = (unsigned long long)(*((float*)aligned)); - break; - case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - hw_ullong = (unsigned long long)(*((double*)aligned)); - break; -#if H5_SIZEOF_LONG_DOUBLE !=0 - case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - hw_ullong = (unsigned long long)(*((long double*)aligned)); - break; + case FLT_FLOAT: + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + hw_ullong = (unsigned long long)(*((float *)aligned)); + break; + case FLT_DOUBLE: + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + hw_ullong = (unsigned long long)(*((double *)aligned)); + break; +#if H5_SIZEOF_LONG_DOUBLE != 0 + case FLT_LDOUBLE: + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + hw_ullong = (unsigned long long)(*((long double *)aligned)); + break; #endif - case INT_SCHAR: - case INT_UCHAR: - case INT_SHORT: - case INT_USHORT: - case INT_INT: - case INT_UINT: - case INT_LONG: - case INT_ULONG: - case INT_LLONG: - case INT_ULLONG: - case OTHER: - default: - HDassert(0 && "Unknown type"); - break; + case INT_SCHAR: + case INT_UCHAR: + case INT_SHORT: + case INT_USHORT: + case INT_INT: + case INT_UINT: + case INT_LONG: + case INT_ULONG: + case INT_LLONG: + case INT_ULLONG: + case OTHER: + default: + HDassert(0 && "Unknown type"); + break; } } /* Make certain that there isn't some weird number of destination bits */ - assert(dst_nbits%8==0); + assert(dst_nbits % 8 == 0); /* For Intel machines, the size of "long double" is 12 bytes, precision * is 80 bits; for AMD processors, the size of "long double" is 16 bytes, @@ -4211,20 +4355,20 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) * bytes may have garbage in them. Clean them out with 0s before compare * the values. */ -#if H5_SIZEOF_LONG_DOUBLE !=0 - if(dendian==H5T_ORDER_LE && dst_type==FLT_LDOUBLE) { - unsigned int q; - for(q=dst_nbits/8; q<dst_size; q++) { - buf[j*dst_size+q] = 0x00; - } +#if H5_SIZEOF_LONG_DOUBLE != 0 + if (dendian == H5T_ORDER_LE && dst_type == FLT_LDOUBLE) { + size_t q; + + for (q = dst_nbits / 8; q < dst_size; q++) + buf[j * dst_size + q] = 0x00; } #endif /* Are the two results the same? */ - for (k=(dst_size-(dst_nbits/8)); k<dst_size; k++) - if (buf[j*dst_size+k]!=hw[k]) + for (k = (dst_size - (dst_nbits / 8)); k < dst_size; k++) + if (buf[j * dst_size + k] != hw[k]) break; - if (k==dst_size) + if (k == dst_size) continue; /*no error*/ /* @@ -4234,18 +4378,19 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) * the `bittests' program. */ - if ((FLT_FLOAT==src_type || FLT_DOUBLE==src_type) && sendian==H5T_ORDER_VAX) { + if ((FLT_FLOAT == src_type || FLT_DOUBLE == src_type) && sendian == H5T_ORDER_VAX) { for (k = 0; k < src_size; k += 2) { - src_bits[k] = saved[j*src_size + (src_size - 2) - k]; - src_bits[k + 1] = saved[j*src_size + (src_size - 1) - k]; + src_bits[k] = saved[j * src_size + (src_size - 2) - k]; + src_bits[k + 1] = saved[j * src_size + (src_size - 1) - k]; } - } else { - for (k=0; k<src_size; k++) - src_bits[src_size-(k+1)] = saved[j*src_size+ENDIAN(src_size, k, sendian)]; + } + else { + for (k = 0; k < src_size; k++) + src_bits[src_size - (k + 1)] = saved[j * src_size + ENDIAN(src_size, k, sendian)]; } - for (k=0; k<dst_size; k++) - dst_bits[dst_size-(k+1)] = buf[j*dst_size+ENDIAN(dst_size, k, dendian)]; + for (k = 0; k < dst_size; k++) + dst_bits[dst_size - (k + 1)] = buf[j * dst_size + ENDIAN(dst_size, k, dendian)]; /* Test library's default overflow handling: * Hardware usually doesn't handle overflows too gracefully. The @@ -4256,77 +4401,83 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) * Try to follow the except_func callback function to check if the * desired value was set. */ - if ((FLT_FLOAT==src_type || FLT_DOUBLE==src_type -#if H5_SIZEOF_LONG_DOUBLE !=0 - || FLT_LDOUBLE==src_type + if ((FLT_FLOAT == src_type || FLT_DOUBLE == src_type +#if H5_SIZEOF_LONG_DOUBLE != 0 + || FLT_LDOUBLE == src_type #endif - ) - && (INT_SCHAR==dst_type || INT_SHORT==dst_type || INT_INT==dst_type - || INT_LONG==dst_type || INT_LLONG==dst_type)) { - if(0==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) && - overflows(src_bits, src, dst_nbits-1)) { + ) && + (INT_SCHAR == dst_type || INT_SHORT == dst_type || INT_INT == dst_type || INT_LONG == dst_type || + INT_LLONG == dst_type)) { + if (0 == H5T__bit_get_d(src_bits, src_nbits - 1, (size_t)1) && + overflows(src_bits, src, dst_nbits - 1)) { /* * Source is positive and the magnitude is too large for * the destination. The destination should be set to the * maximum possible value: 0x7f...f */ - if(!except_set) { - if (0==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) && - H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0) + if (!except_set) { + if (0 == H5T__bit_get_d(dst_bits, dst_nbits - 1, (size_t)1) && + H5T__bit_find(dst_bits, (size_t)0, dst_nbits - 1, H5T_BIT_LSB, 0) < 0) continue; /*no error*/ - } else { + } + else { /* fill_value is small so we know only the 1st byte is set */ if (dst_bits[0] == fill_value) continue; /*no error*/ } - } else if (1==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) && - overflows(src_bits, src, dst_nbits-1)) { + } + else if (1 == H5T__bit_get_d(src_bits, src_nbits - 1, (size_t)1) && + overflows(src_bits, src, dst_nbits - 1)) { /* * Source is negative but the magnitude is too large for * the destination. The destination should be set to the * smallest possible value: 0x80...0 */ - if(!except_set) { - if (1==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) && - H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 1) < 0) + if (!except_set) { + if (1 == H5T__bit_get_d(dst_bits, dst_nbits - 1, (size_t)1) && + H5T__bit_find(dst_bits, (size_t)0, dst_nbits - 1, H5T_BIT_LSB, 1) < 0) continue; /*no error*/ - } else { + } + else { if (dst_bits[0] == fill_value) continue; /*no error*/ } } } - if ((FLT_FLOAT==src_type || FLT_DOUBLE==src_type -#if H5_SIZEOF_LONG_DOUBLE !=0 - || FLT_LDOUBLE==src_type + if ((FLT_FLOAT == src_type || FLT_DOUBLE == src_type +#if H5_SIZEOF_LONG_DOUBLE != 0 + || FLT_LDOUBLE == src_type #endif - ) - && (INT_UCHAR==dst_type || INT_USHORT==dst_type || INT_UINT==dst_type - || INT_ULONG==dst_type || INT_ULLONG==dst_type)) { - if (H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1)) { + ) && + (INT_UCHAR == dst_type || INT_USHORT == dst_type || INT_UINT == dst_type || + INT_ULONG == dst_type || INT_ULLONG == dst_type)) { + if (H5T__bit_get_d(src_bits, src_nbits - 1, (size_t)1)) { /* * The source is negative so the result should be zero. * The source is negative if the most significant bit is * set. The destination is zero if all bits are zero. */ - if(!except_set) { + if (!except_set) { if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 1) < 0) continue; /*no error*/ - } else { + } + else { if (dst_bits[0] == fill_value) continue; /*no error*/ } - } else if (overflows(src_bits, src, dst_nbits)) { + } + else if (overflows(src_bits, src, dst_nbits)) { /* * The source is a value with a magnitude too large for * the destination. The destination should be the * largest possible value: 0xff...f */ - if(!except_set) { + if (!except_set) { if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0) continue; /*no error*/ - } else { + } + else { if (dst_bits[0] == fill_value) continue; /*no error*/ } @@ -4334,74 +4485,73 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) } /* Print errors */ - if (0==fails_this_test++) { - if(run_test==TEST_NORMAL) { + if (0 == fails_this_test++) { + if (run_test == TEST_NORMAL) { H5_FAILED(); - } else if(run_test==TEST_DENORM || run_test==TEST_SPECIAL) { + } + else if (run_test == TEST_DENORM || run_test == TEST_SPECIAL) { H5_WARNING(); } } + HDprintf(" elmt %u: \n", (unsigned)j); - printing: - printf(" elmt %u: \n", (unsigned)j); - - printf(" src = "); - for (k=0; k<src_size; k++) - printf(" %02x", saved[j*src_size+ENDIAN(src_size, k, sendian)]); - printf("%*s", (int)(3*MAX(0, (ssize_t)dst_size-(ssize_t)src_size)), ""); + HDprintf(" src = "); + for (k = 0; k < src_size; k++) + HDprintf(" %02x", saved[j * src_size + ENDIAN(src_size, k, sendian)]); + HDprintf("%*s", (int)(3 * MAX(0, (ssize_t)dst_size - (ssize_t)src_size)), ""); switch (src_type) { case INT_SCHAR: - HDmemcpy(aligned, saved+j*sizeof(signed char), sizeof(signed char)); - printf(" %29d\n", (int)*((signed char*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(signed char), sizeof(signed char)); + HDprintf(" %29d\n", (int)*((signed char *)aligned)); break; case INT_UCHAR: - HDmemcpy(aligned, saved+j*sizeof(unsigned char), sizeof(unsigned char)); - printf(" %29u\n", (unsigned)*((unsigned char*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(unsigned char), sizeof(unsigned char)); + HDprintf(" %29u\n", (unsigned)*((unsigned char *)aligned)); break; case INT_SHORT: - HDmemcpy(aligned, saved+j*sizeof(short), sizeof(short)); - printf(" %29hd\n", *((short*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(short), sizeof(short)); + HDprintf(" %29hd\n", *((short *)aligned)); break; case INT_USHORT: - HDmemcpy(aligned, saved+j*sizeof(unsigned short), sizeof(unsigned short)); - printf(" %29hu\n", *((unsigned short*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(unsigned short), sizeof(unsigned short)); + HDprintf(" %29hu\n", *((unsigned short *)aligned)); break; case INT_INT: - HDmemcpy(aligned, saved+j*sizeof(int), sizeof(int)); - printf(" %29d\n", *((int*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(int), sizeof(int)); + HDprintf(" %29d\n", *((int *)aligned)); break; case INT_UINT: - HDmemcpy(aligned, saved+j*sizeof(unsigned), sizeof(unsigned)); - printf(" %29u\n", *((unsigned*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(unsigned), sizeof(unsigned)); + HDprintf(" %29u\n", *((unsigned *)aligned)); break; case INT_LONG: - HDmemcpy(aligned, saved+j*sizeof(long), sizeof(long)); - printf(" %29ld\n", *((long*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(long), sizeof(long)); + HDprintf(" %29ld\n", *((long *)aligned)); break; case INT_ULONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long), sizeof(unsigned long)); - printf(" %29lu\n", *((unsigned long*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(unsigned long), sizeof(unsigned long)); + HDprintf(" %29lu\n", *((unsigned long *)aligned)); break; case INT_LLONG: - HDmemcpy(aligned, saved+j*sizeof(long long), sizeof(long long)); - HDfprintf(stdout," %29"H5_PRINTF_LL_WIDTH"d\n", *((long long*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(long long), sizeof(long long)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "d\n", *((long long *)aligned)); break; case INT_ULLONG: - HDmemcpy(aligned, saved+j*sizeof(unsigned long long), sizeof(unsigned long long)); - HDfprintf(stdout," %29"H5_PRINTF_LL_WIDTH"u\n", *((unsigned long long*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(unsigned long long), sizeof(unsigned long long)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "u\n", *((unsigned long long *)aligned)); break; case FLT_FLOAT: - HDmemcpy(aligned, saved+j*sizeof(float), sizeof(float)); - printf(" %29f\n", *((float*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(float), sizeof(float)); + HDprintf(" %29f\n", (double)*((float *)aligned)); break; case FLT_DOUBLE: - HDmemcpy(aligned, saved+j*sizeof(double), sizeof(double)); - printf(" %29f\n", *((double*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(double), sizeof(double)); + HDprintf(" %29f\n", *((double *)aligned)); break; -#if H5_SIZEOF_LONG_DOUBLE !=0 +#if H5_SIZEOF_LONG_DOUBLE != 0 case FLT_LDOUBLE: - HDmemcpy(aligned, saved+j*sizeof(long double), sizeof(long double)); - printf(" %29Lf\n", *((long double*)aligned)); + HDmemcpy(aligned, saved + j * sizeof(long double), sizeof(long double)); + HDprintf(" %29Lf\n", *((long double *)aligned)); break; #endif case OTHER: @@ -4410,63 +4560,63 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) break; } - printf(" dst = "); - for (k=0; k<dst_size; k++) - printf(" %02x", buf[j*dst_size+ENDIAN(dst_size, k, dendian)]); - printf("%*s", (int)(3*MAX(0, (ssize_t)src_size-(ssize_t)dst_size)), ""); + HDprintf(" dst = "); + for (k = 0; k < dst_size; k++) + HDprintf(" %02x", buf[j * dst_size + ENDIAN(dst_size, k, dendian)]); + HDprintf("%*s", (int)(3 * MAX(0, (ssize_t)src_size - (ssize_t)dst_size)), ""); switch (dst_type) { case INT_SCHAR: - HDmemcpy(aligned, buf+j*sizeof(signed char), sizeof(signed char)); - printf(" %29d\n", (int)*((signed char*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(signed char), sizeof(signed char)); + HDprintf(" %29d\n", (int)*((signed char *)aligned)); break; case INT_UCHAR: - HDmemcpy(aligned, buf+j*sizeof(unsigned char), sizeof(unsigned char)); - printf(" %29u\n", (unsigned)*((unsigned char*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(unsigned char), sizeof(unsigned char)); + HDprintf(" %29u\n", (unsigned)*((unsigned char *)aligned)); break; case INT_SHORT: - HDmemcpy(aligned, buf+j*sizeof(short), sizeof(short)); - printf(" %29hd\n", *((short*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(short), sizeof(short)); + HDprintf(" %29hd\n", *((short *)aligned)); break; case INT_USHORT: - HDmemcpy(aligned, buf+j*sizeof(unsigned short), sizeof(unsigned short)); - printf(" %29hu\n", *((unsigned short*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(unsigned short), sizeof(unsigned short)); + HDprintf(" %29hu\n", *((unsigned short *)aligned)); break; case INT_INT: - HDmemcpy(aligned, buf+j*sizeof(int), sizeof(int)); - printf(" %29d\n", *((int*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(int), sizeof(int)); + HDprintf(" %29d\n", *((int *)aligned)); break; case INT_UINT: - HDmemcpy(aligned, buf+j*sizeof(unsigned), sizeof(unsigned)); - printf(" %29u\n", *((unsigned*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(unsigned), sizeof(unsigned)); + HDprintf(" %29u\n", *((unsigned *)aligned)); break; case INT_LONG: - HDmemcpy(aligned, buf+j*sizeof(long), sizeof(long)); - printf(" %29ld\n", *((long*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(long), sizeof(long)); + HDprintf(" %29ld\n", *((long *)aligned)); break; case INT_ULONG: - HDmemcpy(aligned, buf+j*sizeof(unsigned long), sizeof(unsigned long)); - printf(" %29lu\n", *((unsigned long*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(unsigned long), sizeof(unsigned long)); + HDprintf(" %29lu\n", *((unsigned long *)aligned)); break; case INT_LLONG: - HDmemcpy(aligned, buf+j*sizeof(long long), sizeof(long long)); - HDfprintf(stdout," %29"H5_PRINTF_LL_WIDTH"d\n", *((long long*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(long long), sizeof(long long)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "d\n", *((long long *)aligned)); break; case INT_ULLONG: - HDmemcpy(aligned, buf+j*sizeof(unsigned long long), sizeof(unsigned long long)); - HDfprintf(stdout," %29"H5_PRINTF_LL_WIDTH"u\n", *((unsigned long long*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(unsigned long long), sizeof(unsigned long long)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "u\n", *((unsigned long long *)aligned)); break; case FLT_FLOAT: - HDmemcpy(aligned, buf+j*sizeof(float), sizeof(float)); - printf(" %29f\n", *((float*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(float), sizeof(float)); + HDprintf(" %29f\n", (double)*((float *)aligned)); break; case FLT_DOUBLE: - HDmemcpy(aligned, buf+j*sizeof(double), sizeof(double)); - printf(" %29f\n", *((double*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(double), sizeof(double)); + HDprintf(" %29f\n", *((double *)aligned)); break; -#if H5_SIZEOF_LONG_DOUBLE !=0 +#if H5_SIZEOF_LONG_DOUBLE != 0 case FLT_LDOUBLE: - HDmemcpy(aligned, buf+j*sizeof(long double), sizeof(long double)); - printf(" %29Lf\n", *((long double*)aligned)); + HDmemcpy(aligned, buf + j * sizeof(long double), sizeof(long double)); + HDprintf(" %29Lf\n", *((long double *)aligned)); break; #endif case OTHER: @@ -4475,50 +4625,50 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) break; } - printf(" ans = "); - for (k=0; k<dst_size; k++) - printf(" %02x", hw[ENDIAN(dst_size, k, dendian)]); - printf("%*s", (int)(3*MAX(0, (ssize_t)src_size-(ssize_t)dst_size)), ""); + HDprintf(" ans = "); + for (k = 0; k < dst_size; k++) + HDprintf(" %02x", hw[ENDIAN(dst_size, k, dendian)]); + HDprintf("%*s", (int)(3 * MAX(0, (ssize_t)src_size - (ssize_t)dst_size)), ""); switch (dst_type) { case INT_SCHAR: - printf(" %29d\n", (int)*((signed char*)hw)); + HDprintf(" %29d\n", (int)*((signed char *)((void *)hw))); break; case INT_UCHAR: - printf(" %29u\n", (unsigned)*((unsigned char*)hw)); + HDprintf(" %29u\n", (unsigned)*((unsigned char *)((void *)hw))); break; case INT_SHORT: - printf(" %29hd\n", *((short*)hw)); + HDprintf(" %29hd\n", *((short *)((void *)hw))); break; case INT_USHORT: - printf(" %29hu\n", *((unsigned short*)hw)); + HDprintf(" %29hu\n", *((unsigned short *)((void *)hw))); break; case INT_INT: - printf(" %29d\n", *((int*)hw)); + HDprintf(" %29d\n", *((int *)((void *)hw))); break; case INT_UINT: - printf(" %29u\n", *((unsigned int*)hw)); + HDprintf(" %29u\n", *((unsigned int *)((void *)hw))); break; case INT_LONG: - printf(" %29ld\n", *((long*)hw)); + HDprintf(" %29ld\n", *((long *)((void *)hw))); break; case INT_ULONG: - printf(" %29lu\n", *((unsigned long*)hw)); + HDprintf(" %29lu\n", *((unsigned long *)((void *)hw))); break; case INT_LLONG: - printf(" %29"H5_PRINTF_LL_WIDTH"d\n", *((long long*)hw)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "d\n", *((long long *)((void *)hw))); break; case INT_ULLONG: - printf(" %29"H5_PRINTF_LL_WIDTH"u\n", *((unsigned long long*)hw)); + HDfprintf(stdout, " %29" H5_PRINTF_LL_WIDTH "u\n", *((unsigned long long *)((void *)hw))); break; case FLT_FLOAT: - printf(" %29f\n", *((float*)hw)); + HDprintf(" %29f\n", (double)*((float *)((void *)hw))); break; case FLT_DOUBLE: - printf(" %29f\n", *((double*)hw)); + HDprintf(" %29f\n", *((double *)((void *)hw))); break; -#if H5_SIZEOF_LONG_DOUBLE !=0 +#if H5_SIZEOF_LONG_DOUBLE != 0 case FLT_LDOUBLE: - printf(" %29Lf\n", *((long double*)hw)); + HDprintf(" %29Lf\n", *((long double *)((void *)hw))); break; #endif case OTHER: @@ -4529,10 +4679,10 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) /* If the source is normalized values, print out error message; if it is * denormalized or special values, print out warning message.*/ - if (++fails_all_tests>=max_fails) { - if(run_test==TEST_NORMAL) + if (++fails_all_tests >= max_fails) { + if (run_test == TEST_NORMAL) HDputs(" maximum failures reached, aborting test..."); - else if(run_test==TEST_DENORM || run_test==TEST_SPECIAL) + else if (run_test == TEST_DENORM || run_test == TEST_SPECIAL) HDputs(" maximum warnings reached, aborting test..."); HDputs(" (dst is library's conversion output. ans is compiler's conversion output.)"); @@ -4540,58 +4690,63 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) } } - if(!fails_all_tests) + if (!fails_all_tests) PASSED(); - done: - if (buf) aligned_free(buf); - if (saved) aligned_free(saved); - if (aligned) HDfree(aligned); +done: + if (buf) + aligned_free(buf); + if (saved) + aligned_free(saved); + if (aligned) + HDfree(aligned); HDfflush(stdout); /* Restore the default error handler (set in h5_reset()) */ h5_restore_err(); - reset_hdf5(); /*print statistics*/ + reset_hdf5(); /*print statistics*/ /* If the source is normalized floating values, treat the failures as error; * if it is denormalized or special floating values, treat the failure as warning.*/ - if(run_test==TEST_NORMAL) + if (run_test == TEST_NORMAL) return (int)fails_all_tests; - else if(run_test==TEST_DENORM || run_test==TEST_SPECIAL) + else if (run_test == TEST_DENORM || run_test == TEST_SPECIAL) return 0; - error: - if (buf) aligned_free(buf); - if (saved) aligned_free(saved); - if (aligned) HDfree(aligned); +error: + if (buf) + aligned_free(buf); + if (saved) + aligned_free(saved); + if (aligned) + HDfree(aligned); HDfflush(stdout); /* Restore the default error handler (set in h5_reset()) */ h5_restore_err(); - reset_hdf5(); /*print statistics*/ + reset_hdf5(); /*print statistics*/ - if(run_test==TEST_NORMAL) + if (run_test == TEST_NORMAL) return MAX((int)fails_all_tests, 1); else { - HDassert(run_test==TEST_DENORM || run_test==TEST_SPECIAL); + HDassert(run_test == TEST_DENORM || run_test == TEST_SPECIAL); return 1; } } - /*------------------------------------------------------------------------- - * Function: overflows + * Function: overflows * - * Purpose: When convert from float or double to any integer type, + * Purpose: When convert from float or double to any integer type, * check if overflow occurs. * * - * Return: TRUE: overflow happens + * Return: TRUE: overflow happens * * FALSE: no overflow * - * Programmer: Raymond Lu + * Programmer: Raymond Lu * Monday, Nov 17, 2003 * * Modifications: @@ -4601,14 +4756,14 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) static hbool_t overflows(unsigned char *origin_bits, hid_t src_id, size_t dst_num_bits) { - hbool_t ret_value=FALSE; - hsize_t expt; - size_t mant_digits=0, expt_digits=0, bias=0; - size_t epos, mpos; - size_t src_prec=0; /*source type precision in bits*/ - H5T_norm_t norm; - ssize_t indx; - unsigned char bits[32], mant_bits[32]; + hbool_t ret_value = FALSE; + hsize_t expt; + size_t mant_digits = 0, expt_digits = 0, bias = 0; + size_t epos, mpos; + size_t src_prec = 0; /*source type precision in bits*/ + H5T_norm_t norm; + ssize_t indx; + unsigned char bits[32], mant_bits[32]; HDmemset(bits, 0, (size_t)32); HDmemset(mant_bits, 0, (size_t)32); @@ -4623,63 +4778,61 @@ overflows(unsigned char *origin_bits, hid_t src_id, size_t dst_num_bits) bias = H5Tget_ebias(src_id); norm = H5Tget_norm(src_id); - HDmemcpy(bits, origin_bits, src_prec/8+1); + HDmemcpy(bits, origin_bits, src_prec / 8 + 1); /*Check for special cases: +Inf, -Inf*/ - if (H5T__bit_find (bits, mpos, mant_digits, H5T_BIT_LSB, TRUE) < 0) { - if (H5T__bit_find (bits, epos, expt_digits, H5T_BIT_LSB, FALSE) < 0) { - ret_value=TRUE; + if (H5T__bit_find(bits, mpos, mant_digits, H5T_BIT_LSB, TRUE) < 0) { + if (H5T__bit_find(bits, epos, expt_digits, H5T_BIT_LSB, FALSE) < 0) { + ret_value = TRUE; goto done; } - } else if (H5T_NORM_NONE==norm && H5T__bit_find (bits, mpos, mant_digits-1, - H5T_BIT_LSB, TRUE) < 0 && H5T__bit_find (bits, epos, expt_digits, - H5T_BIT_LSB, FALSE) < 0) { + } + else if (H5T_NORM_NONE == norm && H5T__bit_find(bits, mpos, mant_digits - 1, H5T_BIT_LSB, TRUE) < 0 && + H5T__bit_find(bits, epos, expt_digits, H5T_BIT_LSB, FALSE) < 0) { /*This is a special case for the source of no implied mantissa bit. *If the exponent bits are all 1s and only the 1st bit of mantissa *is set to 1. It's infinity. The Intel-Linux "long double" is this case.*/ - ret_value=TRUE; - goto done; + ret_value = TRUE; + goto done; } /* get exponent */ expt = H5T__bit_get_d(bits, mant_digits, expt_digits) - bias; - if(expt>=(dst_num_bits-1)) { - ret_value=TRUE; - goto done; + if (expt >= (dst_num_bits - 1)) { + ret_value = TRUE; + goto done; } /* get significand */ - H5T__bit_copy (mant_bits, (size_t)0, bits, (size_t)0, mant_digits); - + H5T__bit_copy(mant_bits, (size_t)0, bits, (size_t)0, mant_digits); /* restore implicit bit if normalization is implied*/ - if(norm == H5T_NORM_IMPLIED) { + if (norm == H5T_NORM_IMPLIED) { H5T__bit_inc(mant_bits, mant_digits, (size_t)1); mant_digits++; } /* shift significand */ - H5T__bit_shift (mant_bits, (ssize_t)(expt-expt_digits), (size_t)0, (size_t)(32 * 8)); + H5T__bit_shift(mant_bits, (ssize_t)(expt - expt_digits), (size_t)0, (size_t)(32 * 8)); indx = H5T__bit_find(mant_bits, (size_t)0, (size_t)(32 * 8), H5T_BIT_MSB, 1); - if((size_t)indx>=dst_num_bits) - ret_value=TRUE; + if ((size_t)indx >= dst_num_bits) + ret_value = TRUE; done: return ret_value; } - /*------------------------------------------------------------------------- - * Function: run_integer_tests + * Function: run_integer_tests * - * Purpose: Runs all integer tests. + * Purpose: Runs all integer tests. * - * Return: Number of errors + * Return: Number of errors * - * Programmer: Robb Matzke + * Programmer: Robb Matzke * Tuesday, November 24, 1998 * * Modifications: @@ -4689,18 +4842,18 @@ done: static int run_integer_tests(const char *name) { - int nerrors = 0; + int nerrors = 0; nerrors += test_conv_int_1(name, H5T_NATIVE_SCHAR, H5T_NATIVE_UCHAR); nerrors += test_conv_int_1(name, H5T_NATIVE_SCHAR, H5T_NATIVE_SHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_SCHAR, H5T_NATIVE_USHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_SCHAR, H5T_NATIVE_INT); nerrors += test_conv_int_1(name, H5T_NATIVE_SCHAR, H5T_NATIVE_UINT); -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_1(name, H5T_NATIVE_SCHAR, H5T_NATIVE_LONG); nerrors += test_conv_int_1(name, H5T_NATIVE_SCHAR, H5T_NATIVE_ULONG); #endif -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_1(name, H5T_NATIVE_SCHAR, H5T_NATIVE_LLONG); nerrors += test_conv_int_1(name, H5T_NATIVE_SCHAR, H5T_NATIVE_ULLONG); #endif @@ -4710,11 +4863,11 @@ run_integer_tests(const char *name) nerrors += test_conv_int_1(name, H5T_NATIVE_UCHAR, H5T_NATIVE_USHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_UCHAR, H5T_NATIVE_INT); nerrors += test_conv_int_1(name, H5T_NATIVE_UCHAR, H5T_NATIVE_UINT); -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_1(name, H5T_NATIVE_UCHAR, H5T_NATIVE_LONG); nerrors += test_conv_int_1(name, H5T_NATIVE_UCHAR, H5T_NATIVE_ULONG); #endif -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_1(name, H5T_NATIVE_UCHAR, H5T_NATIVE_LLONG); nerrors += test_conv_int_1(name, H5T_NATIVE_UCHAR, H5T_NATIVE_ULLONG); #endif @@ -4724,11 +4877,11 @@ run_integer_tests(const char *name) nerrors += test_conv_int_1(name, H5T_NATIVE_SHORT, H5T_NATIVE_USHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_SHORT, H5T_NATIVE_INT); nerrors += test_conv_int_1(name, H5T_NATIVE_SHORT, H5T_NATIVE_UINT); -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_1(name, H5T_NATIVE_SHORT, H5T_NATIVE_LONG); nerrors += test_conv_int_1(name, H5T_NATIVE_SHORT, H5T_NATIVE_ULONG); #endif -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_1(name, H5T_NATIVE_SHORT, H5T_NATIVE_LLONG); nerrors += test_conv_int_1(name, H5T_NATIVE_SHORT, H5T_NATIVE_ULLONG); #endif @@ -4738,11 +4891,11 @@ run_integer_tests(const char *name) nerrors += test_conv_int_1(name, H5T_NATIVE_USHORT, H5T_NATIVE_SHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_USHORT, H5T_NATIVE_INT); nerrors += test_conv_int_1(name, H5T_NATIVE_USHORT, H5T_NATIVE_UINT); -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_1(name, H5T_NATIVE_USHORT, H5T_NATIVE_LONG); nerrors += test_conv_int_1(name, H5T_NATIVE_USHORT, H5T_NATIVE_ULONG); #endif -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_1(name, H5T_NATIVE_USHORT, H5T_NATIVE_LLONG); nerrors += test_conv_int_1(name, H5T_NATIVE_USHORT, H5T_NATIVE_ULLONG); #endif @@ -4752,11 +4905,11 @@ run_integer_tests(const char *name) nerrors += test_conv_int_1(name, H5T_NATIVE_INT, H5T_NATIVE_SHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_INT, H5T_NATIVE_USHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_INT, H5T_NATIVE_UINT); -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_1(name, H5T_NATIVE_INT, H5T_NATIVE_LONG); nerrors += test_conv_int_1(name, H5T_NATIVE_INT, H5T_NATIVE_ULONG); #endif -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_1(name, H5T_NATIVE_INT, H5T_NATIVE_LLONG); nerrors += test_conv_int_1(name, H5T_NATIVE_INT, H5T_NATIVE_ULLONG); #endif @@ -4766,16 +4919,16 @@ run_integer_tests(const char *name) nerrors += test_conv_int_1(name, H5T_NATIVE_UINT, H5T_NATIVE_SHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_UINT, H5T_NATIVE_USHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_UINT, H5T_NATIVE_INT); -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_1(name, H5T_NATIVE_UINT, H5T_NATIVE_LONG); nerrors += test_conv_int_1(name, H5T_NATIVE_UINT, H5T_NATIVE_ULONG); #endif -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_1(name, H5T_NATIVE_UINT, H5T_NATIVE_LLONG); nerrors += test_conv_int_1(name, H5T_NATIVE_UINT, H5T_NATIVE_ULLONG); #endif -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_1(name, H5T_NATIVE_LONG, H5T_NATIVE_SCHAR); nerrors += test_conv_int_1(name, H5T_NATIVE_LONG, H5T_NATIVE_UCHAR); nerrors += test_conv_int_1(name, H5T_NATIVE_LONG, H5T_NATIVE_SHORT); @@ -4783,13 +4936,13 @@ run_integer_tests(const char *name) nerrors += test_conv_int_1(name, H5T_NATIVE_LONG, H5T_NATIVE_INT); nerrors += test_conv_int_1(name, H5T_NATIVE_LONG, H5T_NATIVE_UINT); nerrors += test_conv_int_1(name, H5T_NATIVE_LONG, H5T_NATIVE_ULONG); -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_1(name, H5T_NATIVE_LONG, H5T_NATIVE_LLONG); nerrors += test_conv_int_1(name, H5T_NATIVE_LONG, H5T_NATIVE_ULLONG); #endif #endif -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_1(name, H5T_NATIVE_ULONG, H5T_NATIVE_SCHAR); nerrors += test_conv_int_1(name, H5T_NATIVE_ULONG, H5T_NATIVE_UCHAR); nerrors += test_conv_int_1(name, H5T_NATIVE_ULONG, H5T_NATIVE_SHORT); @@ -4797,34 +4950,34 @@ run_integer_tests(const char *name) nerrors += test_conv_int_1(name, H5T_NATIVE_ULONG, H5T_NATIVE_INT); nerrors += test_conv_int_1(name, H5T_NATIVE_ULONG, H5T_NATIVE_UINT); nerrors += test_conv_int_1(name, H5T_NATIVE_ULONG, H5T_NATIVE_LONG); -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_1(name, H5T_NATIVE_ULONG, H5T_NATIVE_LLONG); nerrors += test_conv_int_1(name, H5T_NATIVE_ULONG, H5T_NATIVE_ULLONG); #endif #endif -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_1(name, H5T_NATIVE_LLONG, H5T_NATIVE_SCHAR); nerrors += test_conv_int_1(name, H5T_NATIVE_LLONG, H5T_NATIVE_UCHAR); nerrors += test_conv_int_1(name, H5T_NATIVE_LLONG, H5T_NATIVE_SHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_LLONG, H5T_NATIVE_USHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_LLONG, H5T_NATIVE_INT); nerrors += test_conv_int_1(name, H5T_NATIVE_LLONG, H5T_NATIVE_UINT); -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_1(name, H5T_NATIVE_LLONG, H5T_NATIVE_LONG); nerrors += test_conv_int_1(name, H5T_NATIVE_LLONG, H5T_NATIVE_ULONG); #endif nerrors += test_conv_int_1(name, H5T_NATIVE_LLONG, H5T_NATIVE_ULLONG); #endif -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_1(name, H5T_NATIVE_ULLONG, H5T_NATIVE_SCHAR); nerrors += test_conv_int_1(name, H5T_NATIVE_ULLONG, H5T_NATIVE_UCHAR); nerrors += test_conv_int_1(name, H5T_NATIVE_ULLONG, H5T_NATIVE_SHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_ULLONG, H5T_NATIVE_USHORT); nerrors += test_conv_int_1(name, H5T_NATIVE_ULLONG, H5T_NATIVE_INT); nerrors += test_conv_int_1(name, H5T_NATIVE_ULLONG, H5T_NATIVE_UINT); -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_1(name, H5T_NATIVE_ULLONG, H5T_NATIVE_LONG); nerrors += test_conv_int_1(name, H5T_NATIVE_ULLONG, H5T_NATIVE_ULONG); #endif @@ -4834,15 +4987,14 @@ run_integer_tests(const char *name) return nerrors; } - /*------------------------------------------------------------------------- - * Function: run_fp_tests + * Function: run_fp_tests * - * Purpose: Runs all floating-point tests. + * Purpose: Runs all floating-point tests. * - * Return: Number of errors + * Return: Number of errors * - * Programmer: Raymond Lu + * Programmer: Raymond Lu * Tuesday, March 22, 2005 * * Modifications: @@ -4852,12 +5004,12 @@ run_integer_tests(const char *name) static int run_fp_tests(const char *name) { - int nerrors = 0; + int nerrors = 0; - if(!strcmp(name, "noop")) { + if (!strcmp(name, "noop")) { nerrors += test_conv_flt_1("noop", TEST_NOOP, H5T_NATIVE_FLOAT, H5T_NATIVE_FLOAT); nerrors += test_conv_flt_1("noop", TEST_NOOP, H5T_NATIVE_DOUBLE, H5T_NATIVE_DOUBLE); -#if H5_SIZEOF_LONG_DOUBLE !=0 +#if H5_SIZEOF_LONG_DOUBLE != 0 nerrors += test_conv_flt_1("noop", TEST_NOOP, H5T_NATIVE_LDOUBLE, H5T_NATIVE_LDOUBLE); #endif goto done; @@ -4866,7 +5018,7 @@ run_fp_tests(const char *name) /*Test normalized values. TEST_NORMAL indicates normalized values.*/ nerrors += test_conv_flt_1(name, TEST_NORMAL, H5T_NATIVE_FLOAT, H5T_NATIVE_DOUBLE); nerrors += test_conv_flt_1(name, TEST_NORMAL, H5T_NATIVE_DOUBLE, H5T_NATIVE_FLOAT); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE !=0 +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 nerrors += test_conv_flt_1(name, TEST_NORMAL, H5T_NATIVE_FLOAT, H5T_NATIVE_LDOUBLE); nerrors += test_conv_flt_1(name, TEST_NORMAL, H5T_NATIVE_DOUBLE, H5T_NATIVE_LDOUBLE); nerrors += test_conv_flt_1(name, TEST_NORMAL, H5T_NATIVE_LDOUBLE, H5T_NATIVE_FLOAT); @@ -4876,36 +5028,68 @@ run_fp_tests(const char *name) /*Test denormalized values. TEST_DENORM indicates denormalized values.*/ nerrors += test_conv_flt_1(name, TEST_DENORM, H5T_NATIVE_FLOAT, H5T_NATIVE_DOUBLE); nerrors += test_conv_flt_1(name, TEST_DENORM, H5T_NATIVE_DOUBLE, H5T_NATIVE_FLOAT); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 nerrors += test_conv_flt_1(name, TEST_DENORM, H5T_NATIVE_FLOAT, H5T_NATIVE_LDOUBLE); nerrors += test_conv_flt_1(name, TEST_DENORM, H5T_NATIVE_DOUBLE, H5T_NATIVE_LDOUBLE); +#ifndef H5_DISABLE_SOME_LDOUBLE_CONV nerrors += test_conv_flt_1(name, TEST_DENORM, H5T_NATIVE_LDOUBLE, H5T_NATIVE_FLOAT); +#else + { + char str[256]; /*string */ + + HDsnprintf(str, sizeof(str), "Testing %s denormalized %s -> %s conversions", name, "long double", + "float"); + HDprintf("%-70s", str); + SKIPPED(); +#if H5_SIZEOF_LONG_DOUBLE != 0 + HDputs(" Test skipped due to the conversion problem on IBM ppc64le cpu."); +#else + HDputs(" Test skipped due to disabled long double."); +#endif + } +#endif + nerrors += test_conv_flt_1(name, TEST_DENORM, H5T_NATIVE_LDOUBLE, H5T_NATIVE_DOUBLE); #endif /*Test special values, +/-0, +/-infinity, +/-QNaN, +/-SNaN.*/ nerrors += test_conv_flt_1(name, TEST_SPECIAL, H5T_NATIVE_FLOAT, H5T_NATIVE_DOUBLE); nerrors += test_conv_flt_1(name, TEST_SPECIAL, H5T_NATIVE_DOUBLE, H5T_NATIVE_FLOAT); -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0 +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0 nerrors += test_conv_flt_1(name, TEST_SPECIAL, H5T_NATIVE_FLOAT, H5T_NATIVE_LDOUBLE); nerrors += test_conv_flt_1(name, TEST_SPECIAL, H5T_NATIVE_DOUBLE, H5T_NATIVE_LDOUBLE); +#ifndef H5_DISABLE_SOME_LDOUBLE_CONV nerrors += test_conv_flt_1(name, TEST_SPECIAL, H5T_NATIVE_LDOUBLE, H5T_NATIVE_FLOAT); nerrors += test_conv_flt_1(name, TEST_SPECIAL, H5T_NATIVE_LDOUBLE, H5T_NATIVE_DOUBLE); +#else + { + char str[256]; /*string */ + + HDsnprintf(str, sizeof(str), "Testing %s special %s -> %s conversions", name, "long double", + "float or double"); + HDprintf("%-70s", str); + SKIPPED(); +#if H5_SIZEOF_LONG_DOUBLE != 0 + HDputs(" Test skipped due to the conversion problem on IBM ppc64le cpu."); +#else + HDputs(" Test skipped due to disabled long double."); +#endif + } +#endif #endif done: return nerrors; } - /*------------------------------------------------------------------------- - * Function: run_int_fp_conv + * Function: run_int_fp_conv * - * Purpose: Runs all integer-float tests. + * Purpose: Runs all integer-float tests. * - * Return: Number of errors + * Return: Number of errors * - * Programmer: Raymond Lu + * Programmer: Raymond Lu * Monday, November 10, 2003 * * Modifications: @@ -4915,7 +5099,7 @@ done: static int run_int_fp_conv(const char *name) { - int nerrors = 0; + int nerrors = 0; nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_SCHAR, H5T_NATIVE_FLOAT); nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_SCHAR, H5T_NATIVE_DOUBLE); @@ -4935,7 +5119,7 @@ run_int_fp_conv(const char *name) nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_UINT, H5T_NATIVE_FLOAT); nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_UINT, H5T_NATIVE_DOUBLE); -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT +#if H5_SIZEOF_LONG != H5_SIZEOF_INT nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_LONG, H5T_NATIVE_FLOAT); nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_LONG, H5T_NATIVE_DOUBLE); @@ -4943,7 +5127,7 @@ run_int_fp_conv(const char *name) nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_ULONG, H5T_NATIVE_DOUBLE); #endif -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_LLONG, H5T_NATIVE_FLOAT); nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_LLONG, H5T_NATIVE_DOUBLE); @@ -4951,26 +5135,26 @@ run_int_fp_conv(const char *name) nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_ULLONG, H5T_NATIVE_DOUBLE); #endif -#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE +#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_SCHAR, H5T_NATIVE_LDOUBLE); nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_UCHAR, H5T_NATIVE_LDOUBLE); nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_SHORT, H5T_NATIVE_LDOUBLE); nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_USHORT, H5T_NATIVE_LDOUBLE); nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_INT, H5T_NATIVE_LDOUBLE); nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_UINT, H5T_NATIVE_LDOUBLE); -#if H5_SIZEOF_LONG!=H5_SIZEOF_INT -#ifndef H5_LONG_TO_LDOUBLE_SPECIAL +#if H5_SIZEOF_LONG != H5_SIZEOF_INT +#if !defined(H5_LONG_TO_LDOUBLE_SPECIAL) && !defined(H5_DISABLE_SOME_LDOUBLE_CONV) nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_LONG, H5T_NATIVE_LDOUBLE); nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_ULONG, H5T_NATIVE_LDOUBLE); #else { - char str[256]; /*string */ + char str[256]; /*string */ - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, "(unsigned) long", "long double"); - printf("%-70s", str); + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, "(unsigned) long", + "long double"); + HDprintf("%-70s", str); SKIPPED(); -#if H5_SIZEOF_LONG_DOUBLE!=0 +#if H5_SIZEOF_LONG_DOUBLE != 0 HDputs(" Test skipped due to the special algorithm of hardware conversion."); #else HDputs(" Test skipped due to disabled long double."); @@ -4978,29 +5162,28 @@ run_int_fp_conv(const char *name) } #endif #endif /* H5_SIZEOF_LONG!=H5_SIZEOF_INT */ -#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG +#if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG #if H5_LLONG_TO_LDOUBLE_CORRECT nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_LLONG, H5T_NATIVE_LDOUBLE); -#else /* H5_LLONG_TO_LDOUBLE_CORRECT */ +#else /* H5_LLONG_TO_LDOUBLE_CORRECT */ { - char str[256]; /*hello string */ + char str[256]; /*hello string */ - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, "long long", "long double"); - printf("%-70s", str); + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, "long long", "long double"); + HDprintf("%-70s", str); SKIPPED(); HDputs(" Test skipped due to compiler error in handling conversion."); } #endif /* H5_LLONG_TO_LDOUBLE_CORRECT */ #if H5_LLONG_TO_LDOUBLE_CORRECT nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_ULLONG, H5T_NATIVE_LDOUBLE); -#else /* H5_LLONG_TO_LDOUBLE_CORRECT */ +#else /* H5_LLONG_TO_LDOUBLE_CORRECT */ { - char str[256]; /*hello string */ + char str[256]; /*hello string */ - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, "unsigned long long", "long double"); - printf("%-70s", str); + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, "unsigned long long", + "long double"); + HDprintf("%-70s", str); SKIPPED(); HDputs(" Test skipped due to compiler not handling conversion."); } @@ -5011,15 +5194,14 @@ run_int_fp_conv(const char *name) return nerrors; } - /*------------------------------------------------------------------------- - * Function: run_fp_int_conv + * Function: run_fp_int_conv * - * Purpose: Runs all float-integer tests. + * Purpose: Runs all float-integer tests. * - * Return: Number of errors + * Return: Number of errors * - * Programmer: Raymond Lu + * Programmer: Raymond Lu * Monday, November 10, 2003 * * Modifications: @@ -5029,10 +5211,10 @@ run_int_fp_conv(const char *name) static int run_fp_int_conv(const char *name) { - int nerrors = 0; - int test_values; + int nerrors = 0; + int test_values; - for(test_values = TEST_NORMAL; test_values <= TEST_SPECIAL; test_values++) { + for (test_values = TEST_NORMAL; test_values <= TEST_SPECIAL; test_values++) { nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_FLOAT, H5T_NATIVE_SCHAR); nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_DOUBLE, H5T_NATIVE_SCHAR); @@ -5058,93 +5240,122 @@ run_fp_int_conv(const char *name) nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_FLOAT, H5T_NATIVE_ULONG); nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_DOUBLE, H5T_NATIVE_ULONG); -#endif /* H5_SIZEOF_LONG != H5_SIZEOF_INT */ +#endif #if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG - if(!strcmp(name, "hw")) { /* Hardware conversion */ + if (!strcmp(name, "hw")) { /* Hardware conversion */ nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_FLOAT, H5T_NATIVE_LLONG); nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_DOUBLE, H5T_NATIVE_LLONG); - } else { /* Software conversion */ + } + else { /* Software conversion */ nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_FLOAT, H5T_NATIVE_LLONG); nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_DOUBLE, H5T_NATIVE_LLONG); } nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_FLOAT, H5T_NATIVE_ULLONG); nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_DOUBLE, H5T_NATIVE_ULLONG); -#endif /* H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG */ +#endif #if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE - nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_SCHAR); - nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_UCHAR); - nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_SHORT); - nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_USHORT); - nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_INT); - nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_UINT); + if (test_values != TEST_SPECIAL) { + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_SCHAR); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_UCHAR); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_SHORT); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_USHORT); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_INT); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_UINT); + } + else { +#ifndef H5_DISABLE_SOME_LDOUBLE_CONV + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_SCHAR); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_UCHAR); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_SHORT); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_USHORT); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_INT); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_UINT); +#else + char str[256]; /*string */ + + HDsnprintf(str, sizeof(str), "Testing %s special %s -> %s conversions", name, "long double", + "signed and unsigned char, short, int, long"); + HDprintf("%-70s", str); + SKIPPED(); +#if H5_SIZEOF_LONG_DOUBLE != 0 + HDputs(" Test skipped due to the conversion problem on IBM ppc64le cpu."); +#else + HDputs(" Test skipped due to disabled long double."); +#endif +#endif + } #if H5_SIZEOF_LONG != H5_SIZEOF_INT && H5_SIZEOF_LONG_DOUBLE != 0 #ifndef H5_LDOUBLE_TO_LONG_SPECIAL - nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_LONG); - nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_ULONG); -#else /* H5_LDOUBLE_TO_LONG_SPECIAL */ + if (test_values != TEST_SPECIAL && test_values != TEST_NORMAL) { + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_LONG); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_ULONG); + } + else { +#ifndef H5_DISABLE_SOME_LDOUBLE_CONV + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_LONG); + nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_ULONG); +#endif + } +#else { - char str[256]; /*string */ + char str[256]; /*string */ - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, "long double", "(unsigned) long"); - printf("%-70s", str); + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, "long double", + "(unsigned) long"); + HDprintf("%-70s", str); SKIPPED(); #if H5_SIZEOF_LONG_DOUBLE != 0 HDputs(" Test skipped due to the special algorithm of hardware conversion."); -#else /* H5_SIZEOF_LONG_DOUBLE */ +#else HDputs(" Test skipped due to disabled long double."); -#endif /* H5_SIZEOF_LONG_DOUBLE */ +#endif } -#endif /* H5_LDOUBLE_TO_LONG_SPECIAL */ - -#endif /*H5_SIZEOF_LONG != H5_SIZEOF_INT && H5_SIZEOF_LONG_DOUBLE != 0 */ +#endif +#endif /*H5_SIZEOF_LONG!=H5_SIZEOF_INT && H5_SIZEOF_LONG_DOUBLE!=0 */ #if H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG && H5_SIZEOF_LONG_DOUBLE != 0 #ifdef H5_LDOUBLE_TO_LLONG_ACCURATE nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_LLONG); #else /*H5_LDOUBLE_TO_LLONG_ACCURATE*/ { - char str[256]; /*string */ + char str[256]; /*string */ - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, "long double", "long long"); - printf("%-70s", str); + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, "long double", "long long"); + HDprintf("%-70s", str); SKIPPED(); #if H5_SIZEOF_LONG_DOUBLE != 0 HDputs(" Test skipped due to hardware conversion error."); -#else /* H5_SIZEOF_LONG_DOUBLE != 0 */ +#else HDputs(" Test skipped due to disabled long double."); -#endif /* H5_SIZEOF_LONG_DOUBLE != 0 */ +#endif } #endif /*H5_LDOUBLE_TO_LLONG_ACCURATE*/ #if defined(H5_LDOUBLE_TO_LLONG_ACCURATE) nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_ULLONG); #else /*H5_LDOUBLE_TO_LLONG_ACCURATE*/ { - char str[256]; /*string */ + char str[256]; /*string */ - HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", - name, "long double", "unsigned long long"); - printf("%-70s", str); + HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions", name, "long double", + "unsigned long long"); + HDprintf("%-70s", str); SKIPPED(); #if H5_SIZEOF_LONG_DOUBLE != 0 HDputs(" Test skipped due to hardware conversion error."); -#else /* H5_SIZEOF_LONG_DOUBLE != 0 */ +#else HDputs(" Test skipped due to disabled long double."); -#endif /* H5_SIZEOF_LONG_DOUBLE !=0 */ +#endif } #endif /*H5_LDOUBLE_TO_LLONG_ACCURATE*/ - -#endif /* H5_SIZEOF_LONG_LONG != H5_SIZEOF_LONG && H5_SIZEOF_LONG_DOUBLE != 0 */ -#endif /* H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE */ +#endif +#endif } /* end for */ return nerrors; -} /* end run_fp_int_conv() */ +} - /*------------------------------------------------------------------------- * Function: main * @@ -5168,7 +5379,7 @@ run_fp_int_conv(const char *name) int main(void) { - unsigned long nerrors = 0; + unsigned long nerrors = 0; /* Set the random # seed */ HDsrandom((unsigned)HDtime(NULL)); @@ -5176,41 +5387,41 @@ main(void) reset_hdf5(); if (ALIGNMENT) - printf("Testing non-aligned conversions (ALIGNMENT=%d)....\n", ALIGNMENT); + HDprintf("Testing non-aligned conversions (ALIGNMENT=%d)....\n", ALIGNMENT); /* Do the tests */ /* Test H5Tcompiler_conv() for querying hard conversion. */ - nerrors += test_hard_query(); + nerrors += (unsigned long)test_hard_query(); /* Test user-define, query functions and software conversion * for user-defined floating-point types */ - nerrors += test_derived_flt(); + nerrors += (unsigned long)test_derived_flt(); /* Test user-define, query functions and software conversion * for user-defined integer types */ - nerrors += test_derived_integer(); + nerrors += (unsigned long)test_derived_integer(); /* Does floating point overflow generate a SIGFPE? */ generates_sigfpe(); /* Test degenerate cases */ - nerrors += run_fp_tests("noop"); + nerrors += (unsigned long)run_fp_tests("noop"); /* Test hardware floating-point conversion functions */ - nerrors += run_fp_tests("hard"); + nerrors += (unsigned long)run_fp_tests("hard"); /* Test hardware integer conversion functions */ - nerrors += run_integer_tests("hard"); + nerrors += (unsigned long)run_integer_tests("hard"); /* Test hardware integer-float conversion functions */ - nerrors += run_int_fp_conv("hard"); + nerrors += (unsigned long)run_int_fp_conv("hard"); /* Test hardware float-integer conversion functions */ - nerrors += run_fp_int_conv("hard"); + nerrors += (unsigned long)run_fp_int_conv("hard"); /* Test a few special values for hardware float-integer conversions */ - nerrors += test_particular_fp_integer(); + nerrors += (unsigned long)test_particular_fp_integer(); /*---------------------------------------------------------------------- * Software tests @@ -5224,17 +5435,17 @@ main(void) reset_hdf5(); /* Test software floating-point conversion functions */ - nerrors += run_fp_tests("soft"); + nerrors += (unsigned long)run_fp_tests("soft"); /* Test software integer conversion functions */ - nerrors += test_conv_int_2(); - nerrors += run_integer_tests("soft"); + nerrors += (unsigned long)test_conv_int_2(); + nerrors += (unsigned long)run_integer_tests("soft"); /* Test software float-integer conversion functions */ - nerrors += run_fp_int_conv("soft"); + nerrors += (unsigned long)run_fp_int_conv("soft"); /* Test software integer-float conversion functions */ - nerrors += run_int_fp_conv("soft"); + nerrors += (unsigned long)run_int_fp_conv("soft"); /* Restore the default error handler (set in h5_reset()) */ h5_restore_err(); @@ -5245,11 +5456,9 @@ main(void) h5_restore_err(); if (nerrors) { - printf("***** %lu FAILURE%s! *****\n", - nerrors, 1==nerrors?"":"S"); - HDexit(1); + HDprintf("***** %lu FAILURE%s! *****\n", nerrors, 1 == nerrors ? "" : "S"); + HDexit(EXIT_FAILURE); } - printf("All data type tests passed.\n"); + HDprintf("All data type tests passed.\n"); return 0; } - |