Clean up tests.

On Windows with MSVC, just assume we have 64-bit file offset support,
including _fseeki64() and _ftelli64().

On UN*X, test for Large File Support and for fseeko()/ftello(), and for
what #defines are needed to enable them.

On Windows without MSVC, test for Large File Support, but assume we have
_fseeki64() and _ftelli64(); what *should* we be doing?

Clean up indentation and else()/endif() arguments while we're at it.

Change-Id: I801d1f4059abbed2d5123d2375a560634a9ee056
Reviewed-on: https://code.wireshark.org/review/28781
Petri-Dish: Guy Harris <guy@alum.mit.edu>
Tested-by: Petri Dish Buildbot
Reviewed-by: Guy Harris <guy@alum.mit.edu>

1 files changed, 102 insertions, 91 deletions

diff --git a/cmake/modules/gmxTestLargeFiles.cmake b/cmake/modules/gmxTestLargeFiles.cmake
index c3417edbf0..4c131299bc 100644
--- a/cmake/modules/gmxTestLargeFiles.cmake
+++ b/cmake/modules/gmxTestLargeFiles.cmake
@@ -20,102 +20,113 @@
 
 MACRO(GMX_TEST_LARGE_FILES VARIABLE)
     IF(NOT DEFINED ${VARIABLE})
-
-        # On most platforms it is probably overkill to first test the flags for 64-bit off_t,
-        # and then separately fseeko. However, in the future we might have 128-bit filesystems
-        # (ZFS), so it might be dangerous to indiscriminately set e.g. _FILE_OFFSET_BITS=64.
-
-        MESSAGE(STATUS "Checking for 64-bit off_t")
-
-	# First check without any special flags
-        TRY_COMPILE(FILE64_OK "${CMAKE_BINARY_DIR}"
-                    "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c")
-        if(FILE64_OK)
-	    MESSAGE(STATUS "64-bit off_t is present with no special flags")
-      	endif(FILE64_OK)
-
-        if(NOT FILE64_OK)
-	    # Test with _FILE_OFFSET_BITS=64
-            TRY_COMPILE(FILE64_OK "${CMAKE_BINARY_DIR}"
-                        "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c"
-                        COMPILE_DEFINITIONS "-D_FILE_OFFSET_BITS=64" )
-            if(FILE64_OK)
-	        MESSAGE(STATUS "64-bit off_t is present with _FILE_OFFSET_BITS=64")
-                set(_FILE_OFFSET_BITS 64 CACHE INTERNAL "64-bit off_t requires _FILE_OFFSET_BITS=64")
-            endif(FILE64_OK)
-        endif(NOT FILE64_OK)
-
-        if(NOT FILE64_OK)
-            # Test with _LARGE_FILES
+        if(CMAKE_C_COMPILER_ID MATCHES "MSVC")
+            #
+            # This is Visual Studio; Visual Studio has supported
+            # _fseeki64 and _ftelli64 since Visual Studio 2005 / MSVCR80,
+            # and we require newer versions, so we know we have them.
+            #
+            MESSAGE(STATUS "_fseeki64 and _ftelli64 are present")
+        else(CMAKE_C_COMPILER_ID MATCHES "MSVC")
+            #
+            # This is UN*X, or some other Windows compiler.
+            #
+            # For UN*X, we do the Large File Support tests, to see
+            # whether it's present and, if so what we need to define
+            # to enable it.
+            #
+            # XXX - what's the right thing to do on Windows with,
+            # for example, MinGW?
+            #
+            # On most platforms it is probably overkill to first test
+            # the flags for 64-bit off_t, and then separately fseeko.
+            # However, in the future we might have 128-bit seek offsets
+            # to support 128-bit filesystems that allow 128-bit offsets
+            # (ZFS), so it might be dangerous to indiscriminately set
+            # e.g. _FILE_OFFSET_BITS=64.
+            #
+            MESSAGE(STATUS "Checking for 64-bit off_t")
+
+            # First check without any special flags
             TRY_COMPILE(FILE64_OK "${CMAKE_BINARY_DIR}"
-                        "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c"
-                        COMPILE_DEFINITIONS "-D_LARGE_FILES" )
+                        "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c")
             if(FILE64_OK)
-                MESSAGE(STATUS "64-bit off_t is present with _LARGE_FILES")
-                set(_LARGE_FILES 1 CACHE INTERNAL "64-bit off_t requires _LARGE_FILES")
+                MESSAGE(STATUS "64-bit off_t is present with no special flags")
             endif(FILE64_OK)
-        endif(NOT FILE64_OK)
 
-        if(NOT FILE64_OK)
-            # Test with _LARGEFILE_SOURCE
-            TRY_COMPILE(FILE64_OK "${CMAKE_BINARY_DIR}"
-                        "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c"
-                        COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE" )
-            if(FILE64_OK)
-                MESSAGE(STATUS "64-bit off_t is present with _LARGEFILE_SOURCE")
-      		set(_LARGEFILE_SOURCE 1 CACHE INTERNAL "64-bit off_t requires _LARGEFILE_SOURCE")
-            endif(FILE64_OK)
-        endif(NOT FILE64_OK)
-
-        if(NOT FILE64_OK AND WIN32)
-            # Visual C++ has supported fseeki64 since Visual Studio 2005 / MSVCR80.
-            MESSAGE(STATUS "64-bit off_t is not present")
-            MESSAGE(STATUS "_fseeki64 is present")
-            set(HAVE__FSEEKI64 1 CACHE INTERNAL "64-bit file offsets require _fseeki64")
-        endif(NOT FILE64_OK)
-
-        if(NOT FILE64_OK)
-            MESSAGE(STATUS "64-bit file offset support not available")
-        else(NOT FILE64_OK)
-
-            # Set the flags we might have determined to be required above
-            configure_file("${CMAKE_SOURCE_DIR}/cmake/TestLargeFiles.c.cmakein"
-                           "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c")
-
-            MESSAGE(STATUS "Checking for fseeko/ftello")
-	    # Test if ftello/fseeko are	available
-	    TRY_COMPILE(FSEEKO_COMPILE_OK "${CMAKE_BINARY_DIR}"
-                        "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c")
-	    if(FSEEKO_COMPILE_OK)
-                MESSAGE(STATUS "Checking for fseeko/ftello - present")
-            endif(FSEEKO_COMPILE_OK)
-
-            if(NOT FSEEKO_COMPILE_OK)
-                # glibc 2.2 neds _LARGEFILE_SOURCE for fseeko (but not 64-bit off_t...)
-                TRY_COMPILE(FSEEKO_COMPILE_OK "${CMAKE_BINARY_DIR}"
-                            "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c"
+            if(NOT FILE64_OK)
+                # Test with _FILE_OFFSET_BITS=64
+                TRY_COMPILE(FILE64_OK "${CMAKE_BINARY_DIR}"
+                            "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c"
+                            COMPILE_DEFINITIONS "-D_FILE_OFFSET_BITS=64" )
+                if(FILE64_OK)
+                    MESSAGE(STATUS "64-bit off_t is present with _FILE_OFFSET_BITS=64")
+                    set(_FILE_OFFSET_BITS 64 CACHE INTERNAL "64-bit off_t requires _FILE_OFFSET_BITS=64")
+                endif(FILE64_OK)
+            endif(NOT FILE64_OK)
+
+            if(NOT FILE64_OK)
+                # Test with _LARGE_FILES
+                TRY_COMPILE(FILE64_OK "${CMAKE_BINARY_DIR}"
+                            "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c"
+                            COMPILE_DEFINITIONS "-D_LARGE_FILES" )
+                if(FILE64_OK)
+                    MESSAGE(STATUS "64-bit off_t is present with _LARGE_FILES")
+                    set(_LARGE_FILES 1 CACHE INTERNAL "64-bit off_t requires _LARGE_FILES")
+                endif(FILE64_OK)
+            endif(NOT FILE64_OK)
+
+            if(NOT FILE64_OK)
+                # Test with _LARGEFILE_SOURCE
+                TRY_COMPILE(FILE64_OK "${CMAKE_BINARY_DIR}"
+                            "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c"
                             COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE" )
-                if(FSEEKO_COMPILE_OK)
-                    MESSAGE(STATUS "Checking for fseeko/ftello - present with _LARGEFILE_SOURCE")
-                    set(_LARGEFILE_SOURCE 1 CACHE INTERNAL "64-bit fseeko requires _LARGEFILE_SOURCE")
-                endif(FSEEKO_COMPILE_OK)
-            endif(NOT FSEEKO_COMPILE_OK)
-
-        endif(NOT FILE64_OK)
-
-	if(FSEEKO_COMPILE_OK)
-            SET(${VARIABLE} 1 CACHE INTERNAL "Result of test for large file support" FORCE)
-            set(HAVE_FSEEKO 1 CACHE INTERNAL "64-bit fseeko is available" FORCE)
-        else(FSEEKO_COMPILE_OK)
-	    if (HAVE__FSEEKI64)
-		SET(${VARIABLE} 1 CACHE INTERNAL "Result of test for large file support" FORCE)
-		SET(HAVE__FSEEKI64 1 CACHE INTERNAL "Windows 64-bit fseek" FORCE)
-	    else (HAVE__FSEEKI64)
-                MESSAGE(STATUS "Checking for fseeko/ftello - not found")
-                SET(${VARIABLE} 0 CACHE INTERNAL "Result of test for large file support" FORCE)
-	    endif (HAVE__FSEEKI64)
-        endif(FSEEKO_COMPILE_OK)
-
+                if(FILE64_OK)
+                    MESSAGE(STATUS "64-bit off_t is present with _LARGEFILE_SOURCE")
+                    set(_LARGEFILE_SOURCE 1 CACHE INTERNAL "64-bit off_t requires _LARGEFILE_SOURCE")
+                endif(FILE64_OK)
+            endif(NOT FILE64_OK)
+
+            if(NOT FILE64_OK)
+                MESSAGE(STATUS "64-bit file offset support not available")
+            else(NOT FILE64_OK)
+                # Set the flags we might have determined to be required above
+                configure_file("${CMAKE_SOURCE_DIR}/cmake/TestLargeFiles.c.cmakein"
+                               "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c")
+
+                #
+                # If this is Windows, assume we have _fseeki64/_ftelli64
+                # available.  If this is UN*X, check for fseeko/ftello.
+                #
+                if(NOT WIN32)
+                    MESSAGE(STATUS "Checking for fseeko/ftello")
+                    # Test if ftello/fseeko are available
+                    TRY_COMPILE(FSEEKO_COMPILE_OK "${CMAKE_BINARY_DIR}"
+                                "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c")
+                    if(FSEEKO_COMPILE_OK)
+                        MESSAGE(STATUS "Checking for fseeko/ftello - present")
+                    endif(FSEEKO_COMPILE_OK)
+
+                    if(NOT FSEEKO_COMPILE_OK)
+                        # glibc 2.2 neds _LARGEFILE_SOURCE for fseeko (but not 64-bit off_t...)
+                        TRY_COMPILE(FSEEKO_COMPILE_OK "${CMAKE_BINARY_DIR}"
+                                    "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c"
+                                    COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE" )
+                        if(FSEEKO_COMPILE_OK)
+                            MESSAGE(STATUS "Checking for fseeko/ftello - present with _LARGEFILE_SOURCE")
+                            set(_LARGEFILE_SOURCE 1 CACHE INTERNAL "64-bit fseeko requires _LARGEFILE_SOURCE")
+                        endif(FSEEKO_COMPILE_OK)
+                    endif(NOT FSEEKO_COMPILE_OK)
+                    if(FSEEKO_COMPILE_OK)
+                        SET(${VARIABLE} 1 CACHE INTERNAL "Result of test for large file support" FORCE)
+                        set(HAVE_FSEEKO 1 CACHE INTERNAL "64-bit fseeko is available" FORCE)
+                    else(FSEEKO_COMPILE_OK)
+                        MESSAGE(STATUS "Checking for fseeko/ftello - not found")
+                        SET(${VARIABLE} 0 CACHE INTERNAL "Result of test for large file support" FORCE)
+                    endif(FSEEKO_COMPILE_OK)
+                endif(NOT WIN32)
+            endif(NOT FILE64_OK)
+        endif(CMAKE_C_COMPILER_ID MATCHES "MSVC")
     ENDIF(NOT DEFINED ${VARIABLE})
 ENDMACRO(GMX_TEST_LARGE_FILES VARIABLE)