new version: 2017.1.2

It is unclear to me how to correctly fix some of the remaining build
errors obtained on jenkins, therefore I am disabling it from the build
for now.

3rdparty/CMakeLists.txt

@@ -4,6 +4,6 @@ endif()
 
 add_subdirectory(utf8)
 
-if (ENABLE_DNS)
+if (ENABLE_DNS AND NOT SYSTEM_UDNS)
 	add_subdirectory(udns)
 endif()

3rdparty/udns/udns.h

@@ -45,6 +45,7 @@
 #endif
 
 #include <sys/types.h>		/* for time_t */
+#include <time.h>
 
 #ifdef __cplusplus
 extern "C" {

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 2.8.11)
+cmake_minimum_required (VERSION 3.0)
 
 if(COMMAND cmake_policy)
    if(POLICY CMP0054)
@@ -9,6 +9,17 @@ if(COMMAND cmake_policy)
    endif()
 endif()
 
+
+message(STATUS "CMAKE Build type: ${CMAKE_BUILD_TYPE}")
+# Set a default build type if none was specified
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message(STATUS "Setting build type to 'Debug' as none was specified.")
+  set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
+  # Set the possible values of build type for cmake-gui
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
+    "MinSizeRel" "RelWithDebInfo")
+endif()
+
 include (CheckFunctionExists)
 include (CheckIncludeFile)
 include (CheckLibraryExists)
@@ -16,18 +27,28 @@ include (CheckCXXSourceCompiles)
 include (CheckCXXCompilerFlag)
 include (GenerateExportHeader)
 
-# using 10.7 because boost requires libc++ and 10.6 doesn't include it
-set(CMAKE_OSX_DEPLOYMENT_TARGET 10.7)
-
 # only relevant for building shared libs but let's set it regardless
 set(CMAKE_OSX_RPATH 1)
 
-project(SimGear)
+# let's use & require C++11 - note these are only functional with CMake 3.1
+# we do manual fallbacks for CMake 3.0 in the compilers section
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED YES)
 
 # read 'version' file into a variable (stripping any newlines or spaces)
 file(READ version versionFile)
 string(STRIP ${versionFile} SIMGEAR_VERSION)
 
+project(SimGear VERSION ${SIMGEAR_VERSION} LANGUAGES C CXX)
+
+# using 10.7 because boost requires libc++ and 10.6 doesn't include it
+# Cmake documentation says we must set this before calling project(), but
+# it only seems to be picked up setting it /after/ the call to project()
+set(CMAKE_OSX_DEPLOYMENT_TARGET "10.7")
+
+# add a dependency on the versino file
+set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS version)
+
 set(FIND_LIBRARY_USE_LIB64_PATHS ON)
 
 # use simgear version also as the SO version (if building SOs)
@@ -63,8 +84,6 @@ set(CPACK_SOURCE_PACKAGE_FILE_NAME "simgear-${SIMGEAR_VERSION}" CACHE INTERNAL "
 set(CPACK_SOURCE_IGNORE_FILES
   "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
 
-message(STATUS "ignoring: ${CPACK_SOURCE_IGNORE_FILES}")
-
 include (CPack)
 
 # We have some custom .cmake scripts not in the official distribution.
@@ -87,37 +106,32 @@ message(STATUS "Library installation directory: ${CMAKE_INSTALL_LIBDIR}")
 # Configure library search paths
 #####################################################################################
 
-if(NOT "${CMAKE_LIBRARY_ARCHITECTURE}" STREQUAL "")
-    # Workaround for Ubuntu/Debian which introduced the "multiarch" library
-    # directory structure, which is unsupported by CMake < 2.8.10, so we need to
-    # add paths manually
-    # see http://www.cmake.org/Bug/view.php?id=12049 and
-    # http://www.cmake.org/Bug/view.php?id=12037
-    list(APPEND ADDITIONAL_LIBRARY_PATHS
-         /usr/local/lib/${CMAKE_LIBRARY_ARCHITECTURE}
-         /usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}
-         /lib/${CMAKE_LIBRARY_ARCHITECTURE})
-    message(STATUS "additional library directories: ${ADDITIONAL_LIBRARY_PATHS}")
-endif()
-
-#####################################################################################
-
 if (NOT MSVC)
 option(SIMGEAR_SHARED   "Set to ON to build SimGear as a shared library/framework" OFF)
-option(SYSTEM_EXPAT     "Set to ON to build SimGear using the system libExpat" OFF)
+option(SYSTEM_EXPAT     "Set to ON to build SimGear using the system expat library" OFF)
+option(SYSTEM_UDNS      "Set to ON to build SimGear using the system udns library" OFF)
 else()
 # Building SimGear DLLs is currently not supported for MSVC.
 set(SIMGEAR_SHARED OFF)
-# Using a system expat is currently not supported for MSVC - it would require shared simgear (DLL).
+# Using external 3rd party libraries is currently not supported for MSVC - it would require shared simgear (DLL).
 set(SYSTEM_EXPAT OFF)
+set(SYSTEM_UDNS OFF)
 endif()
 
 option(SIMGEAR_HEADLESS "Set to ON to build SimGear without GUI/graphics support" OFF)
 option(ENABLE_RTI       "Set to ON to build SimGear with RTI support" OFF)
 option(ENABLE_TESTS     "Set to OFF to disable building SimGear's test applications" ON)
 option(ENABLE_SOUND     "Set to OFF to disable building SimGear's sound support" ON)
+option(USE_AEONWAVE     "Set to ON to use AeonWave instead of OpenAL" OFF)
 option(ENABLE_PKGUTIL   "Set to ON to build the sg_pkgutil application (default)" ON)
 option(ENABLE_DNS       "Set to ON to use udns library and DNS service resolver" ON)
+option(ENABLE_SIMD      "Enable SSE/SSE2 support for x86 compilers" ON)
+
+include (DetectArch)
+
+# until the fstream fix is applied and generally available in OSG,
+# keep the compatability link option as the default
+option(OSG_FSTREAM_EXPORT_FIXED "Set to ON if the osgDB fstream export patch is applied" OFF)
 
 if (MSVC)
   GET_FILENAME_COMPONENT(PARENT_DIR ${PROJECT_BINARY_DIR} PATH)
@@ -137,14 +151,15 @@ endif (MSVC)
 
 if (MSVC AND MSVC_3RDPARTY_ROOT)
   message(STATUS "3rdparty files located in ${MSVC_3RDPARTY_ROOT}")
+
   set( OSG_MSVC "msvc" )
-  if (${MSVC_VERSION} EQUAL 1700)
-      set( OSG_MSVC ${OSG_MSVC}110 )
-  elseif (${MSVC_VERSION} EQUAL 1600)
-      set( OSG_MSVC ${OSG_MSVC}100 )
-  else (${MSVC_VERSION} EQUAL 1700)
-      set( OSG_MSVC ${OSG_MSVC}90 )
-  endif (${MSVC_VERSION} EQUAL 1700)
+  if (${MSVC_VERSION} EQUAL 1900)
+      set( OSG_MSVC ${OSG_MSVC}140 )
+  elseif (${MSVC_VERSION} EQUAL 1800)
+      set( OSG_MSVC ${OSG_MSVC}120 )
+  else ()
+      message(FATAL_ERROR "Visual Studio 2013/2015 is required now")
+  endif ()
   if (CMAKE_CL_64)
       set( OSG_MSVC ${OSG_MSVC}-64 )
       set( MSVC_3RDPARTY_DIR 3rdParty.x64 )
@@ -154,44 +169,34 @@ if (MSVC AND MSVC_3RDPARTY_ROOT)
 
   set (CMAKE_LIBRARY_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/lib ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenRTI/lib )
   set (CMAKE_INCLUDE_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/include ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenRTI/include)
-  find_path(BOOST_ROOT boost/version.hpp
-			${MSVC_3RDPARTY_ROOT}/boost
-			${MSVC_3RDPARTY_ROOT}/boost_1_52_0
-			${MSVC_3RDPARTY_ROOT}/boost_1_51_0
-			${MSVC_3RDPARTY_ROOT}/boost_1_50_0
-			${MSVC_3RDPARTY_ROOT}/boost_1_49_0
-			${MSVC_3RDPARTY_ROOT}/boost_1_48_0
-			${MSVC_3RDPARTY_ROOT}/boost_1_47_0
-			${MSVC_3RDPARTY_ROOT}/boost_1_46_1
-			${MSVC_3RDPARTY_ROOT}/boost_1_46_0
-			${MSVC_3RDPARTY_ROOT}/boost_1_45_0
-			${MSVC_3RDPARTY_ROOT}/boost_1_44_0
-			)
-  # set (BOOST_ROOT ${MSVC_3RDPARTY_ROOT}/boost_1_44_0)
-  message(STATUS "BOOST_ROOT is ${BOOST_ROOT}")
-  set (OPENAL_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
-  set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib)
+
+  if(NOT BOOST_INCLUDEDIR)
+    # if this variable was not set by the user, set it to 3rdparty root's
+    # parent dir, which is the normal location for people using our
+    # windows-3rd-party repo
+    GET_FILENAME_COMPONENT(MSVC_ROOT_PARENT_DIR ${MSVC_3RDPARTY_ROOT} PATH)
+    set(BOOST_INCLUDEDIR ${MSVC_ROOT_PARENT_DIR})
+    message(STATUS "BOOST_INCLUDEDIR is ${BOOST_INCLUDEDIR}")
+  endif()
+
+  if (NOT USE_AEONWAVE)
+    set (OPENAL_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
+    set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib)
+    message(STATUS "OPENAL_INCLUDE_DIR is ${OPENAL_INCLUDE_DIR}")
+  endif()
 endif (MSVC AND MSVC_3RDPARTY_ROOT)
 
 if(APPLE)
   find_library(COCOA_LIBRARY Cocoa)
-
-# this should be handled by setting CMAKE_OSX_DEPLOYMENT_TARGET
-# but it's not working reliably, so forcing it for now
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.7")
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mmacosx-version-min=10.7")
 endif()
 
-if(${CMAKE_SYSTEM_NAME} MATCHES "Linux" OR
-	${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux" OR ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
     find_package(Threads REQUIRED)
 endif()
 
-# Somehow this only works if included before searching for Boost...
-include(BoostTestTargets)
-
 find_package(Boost REQUIRED)
 set (BOOST_CXX_FLAGS "-DBOOST_BIMAP_DISABLE_SERIALIZATION")
+include(BoostTestTargets)
 
 if(SIMGEAR_HEADLESS)
     message(STATUS "SimGear mode: HEADLESS")
@@ -201,14 +206,34 @@ else()
     find_package(OpenGL REQUIRED)
 
     if (ENABLE_SOUND)
-        find_package(OpenAL REQUIRED)
+        if (USE_AEONWAVE)
+            find_package(AAX COMPONENTS aax REQUIRED)
+        else()
+            find_package(OpenAL REQUIRED)
+        endif()
+
         message(STATUS "Sound support: ENABLED")
     endif(ENABLE_SOUND)
 
     find_package(OpenSceneGraph 3.2.0 REQUIRED osgText osgSim osgDB osgParticle osgGA osgViewer osgUtil)
+
+    if (MSVC)
+      set(CMAKE_REQUIRED_INCLUDES ${OPENSCENEGRAPH_INCLUDE_DIRS})
+      # ensure OSG was compiled with OSG_USE_UTF8_FILENAME set
+      check_cxx_source_compiles(
+         "#include <osg/Config>
+         #if !defined(OSG_USE_UTF8_FILENAME)
+          #error OSG UTF8 support not enabled
+         #endif
+         int main() { return 0; }"
+         SIMGEAR_OSG_USE_UTF8_FILENAME)
+      if (NOT SIMGEAR_OSG_USE_UTF8_FILENAME)
+        message(FATAL_ERROR "Please rebuild OSG with OSG_USE_UTF8_FILENAME set to ON")
+      endif()
+    endif()
 endif(SIMGEAR_HEADLESS)
 
-find_package(ZLIB REQUIRED)
+find_package(ZLIB 1.2.4 REQUIRED)
 find_package(CURL REQUIRED)
 
 if (SYSTEM_EXPAT)
@@ -226,11 +251,8 @@ else()
 	    ${PROJECT_BINARY_DIR}/3rdparty/expat)
 endif(SYSTEM_EXPAT)
 
-include_directories(${EXPAT_INCLUDE_DIRS})
-
 check_include_file(inttypes.h HAVE_INTTYPES_H)
 check_include_file(sys/time.h HAVE_SYS_TIME_H)
-check_include_file(sys/timeb.h HAVE_SYS_TIMEB_H)
 check_include_file(unistd.h HAVE_UNISTD_H)
 check_include_file(windows.h HAVE_WINDOWS_H)
 
@@ -248,13 +270,18 @@ else()
 endif(ENABLE_RTI)
 
 check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
-check_function_exists(ftime HAVE_FTIME)
-check_function_exists(timegm HAVE_TIMEGM)
 check_function_exists(rint HAVE_RINT)
 check_function_exists(mkdtemp HAVE_MKDTEMP)
 check_function_exists(bcopy HAVE_BCOPY)
 check_function_exists(mmap HAVE_MMAP)
 
+if (NOT MSVC)
+  check_function_exists(timegm HAVE_TIMEGM)
+  if (NOT HAVE_TIMEGM)
+    message(FATAL_ERROR "Non-Windows platforms must support timegm()")
+  endif()
+endif()
+
 if(HAVE_UNISTD_H)
     set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
     check_cxx_source_compiles(
@@ -299,19 +326,33 @@ SET(CMAKE_MINSIZEREL_POSTFIX "" CACHE STRING "add a postfix, usually empty on wi
 
 # isnan might not be real symbol, so can't check using function_exists
 check_cxx_source_compiles(
-    "#include <cmath>
-    int main() { return isnan(0.0);} "
-    HAVE_ISNAN)
-
-check_cxx_source_compiles(
-    "#include <cmath>
+    "#include <cstdlib>
     int main() { return std::isnan(0.0);} "
     HAVE_STD_ISNAN)
 
+if (NOT ${HAVE_STD_ISNAN})
+  message(FATAL_ERROR "Your compiler lacks C++11 std::isnan, please update it")
+endif()
+
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(WARNING_FLAGS_CXX "-Wall")
     set(WARNING_FLAGS_C   "-Wall")
 
+    if (CMAKE_VERSION VERSION_LESS 3.1)
+       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+    endif()
+
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.4)
+      message(WARNING "GCC 4.4 will be required soon, please upgrade")
+    endif()
+
+    if(ENABLE_SIMD)
+      if (X86 OR X86_64)
+        set(CMAKE_C_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse")
+        set(CMAKE_CXX_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse")
+      endif()
+    endif()
+
     # certain GCC versions don't provide the atomic builds, and hence
     # require is to provide them in SGAtomic.cxx
     set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
@@ -320,13 +361,24 @@ if(CMAKE_COMPILER_IS_GNUCXX)
         GCC_ATOMIC_BUILTINS_FOUND)
 endif(CMAKE_COMPILER_IS_GNUCXX)
 
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+if (CLANG)
     # Boost redeclares class members
     set(WARNING_FLAGS_CXX "-Wall -Wno-overloaded-virtual -Wno-redeclared-class-member")
     set(WARNING_FLAGS_C   "-Wall")
     set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
-    set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++11")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
+    # fix Boost compilation :(
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+
+    if (CMAKE_VERSION VERSION_LESS 3.1)
+       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+    endif()
+
+    if(ENABLE_SIMD)
+      if (X86 OR X86_64)
+        set(CMAKE_C_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse")
+        set(CMAKE_CXX_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse")
+      endif()
+    endif()
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
@@ -344,21 +396,35 @@ if(WIN32)
     endif()
 
     if(MSVC)
-        # turn off various warnings
-        # foreach(warning 4244 4251 4267 4275 4290 4786 4305 4996)
-        #     SET(WARNING_FLAGS "${WARNING_FLAGS} /wd${warning}")
-        # endforeach(warning)
+        set(MSVC_FLAGS "-DWIN32 -DNOMINMAX -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D__CRT_NONSTDC_NO_WARNINGS /MP")
+        if(ENABLE_SIMD)
+          if (X86)
+            SET(CMAKE_C_FLAGS_RELEASE "/O2 /arch:SSE /arch:SSE2")
+            SET(CMAKE_CXX_FLAGS_RELEASE "/O2 /arch:SSE /arch:SSE2")
+          else()
+            SET(CMAKE_C_FLAGS_RELEASE "/O2")
+            SET(CMAKE_CXX_FLAGS_RELEASE "/O2")
+          endif()
+        endif()
 
-        set(MSVC_FLAGS "-DWIN32 -DNOMINMAX -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D__CRT_NONSTDC_NO_WARNINGS /wd4996 /wd4250 -Dstrdup=_strdup")
-        if (${MSVC_VERSION} GREATER 1599)
+        if (NOT OSG_FSTREAM_EXPORT_FIXED)
+          message(STATUS "For better linking performance, use OSG with patched fstream header")
+          # needed to avoid link errors on multiply-defined standard C++
+          # symbols. Suspect this may be an OSG-DB export bug
             set( MSVC_LD_FLAGS "/FORCE:MULTIPLE" )
-        endif (${MSVC_VERSION} GREATER 1599)
+        endif ()
+
+        if (${MSVC_VERSION} GREATER 1899)
+            # needed for debug builds with VS2015
+            set( MSVC_FLAGS "${MSVC_FLAGS} /bigobj" )
+        endif()
     endif(MSVC)
 
     # assumed on Windows
     set(HAVE_GETLOCALTIME 1)
 
     set( WINSOCK_LIBRARY "ws2_32.lib" )
+    set( SHLWAPI_LIBRARY "Shlwapi.lib" )
     set( RT_LIBRARY "winmm" )
 endif(WIN32)
 
@@ -368,17 +434,8 @@ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MSVC_LD_FLAGS}")
 
 # use BEFORE to ensure local directories are used first,
 # ahead of system-installed libs
-include_directories(BEFORE ${PROJECT_SOURCE_DIR})
-include_directories(BEFORE ${PROJECT_SOURCE_DIR}/simgear/canvas/ShivaVG/include)
 include_directories(BEFORE ${PROJECT_BINARY_DIR}/simgear)
 
-include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS}
-    ${Boost_INCLUDE_DIRS}
-    ${ZLIB_INCLUDE_DIR}
-    ${OPENAL_INCLUDE_DIR}
-    ${CURL_INCLUDE_DIRS}
-)
-
 add_definitions(-DHAVE_CONFIG_H)
 
 # configure a header file to pass some of the CMake settings
@@ -403,6 +460,7 @@ set(TEST_LIBS_INTERNAL_CORE
     ${CMAKE_THREAD_LIBS_INIT}
     ${ZLIB_LIBRARY}
     ${WINSOCK_LIBRARY}
+    ${SHLWAPI_LIBRARY}
     ${RT_LIBRARY}
     ${DL_LIBRARY}
     ${COCOA_LIBRARY}
@@ -415,10 +473,15 @@ endif()
 
 install (FILES ${PROJECT_BINARY_DIR}/simgear/simgear_config.h  DESTINATION include/simgear/)
 
-include_directories(3rdparty/utf8/source)
-if (ENABLE_DNS)
-    message(STATUS "DNS resolver: ENABLED")
-    include_directories(3rdparty/udns)
+if(ENABLE_DNS)
+    if(SYSTEM_UDNS)
+        message(STATUS "Requested to use system udns library, forcing SIMGEAR_SHARED to true")
+        set(SIMGEAR_SHARED ON)
+        find_package(Udns REQUIRED)
+    else()
+        message(STATUS "DNS resolver: ENABLED")
+        include_directories(3rdparty/udns)
+    endif()
 else()
     message(STATUS "DNS resolver: DISABLED")
 endif()
@@ -449,7 +512,7 @@ configure_file(SimGearConfig.cmake.in
   @ONLY
 )
 
-set(ConfigPackageLocation lib/cmake/SimGear)
+set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/SimGear)
 install(EXPORT SimGearTargets
   DESTINATION ${ConfigPackageLocation}
 )

CMakeModules/BoostTestTargets.cmake

@@ -157,7 +157,7 @@ function(add_boost_test _name)
 		endforeach()
 
 		if(NOT _boostTestTargetsNagged${_name} STREQUAL "${includeType}")
-			if("includeType" STREQUAL "CONFIGURED")
+			if("${includeType}" STREQUAL "CONFIGURED")
 				message(STATUS
 					"Test '${_name}' uses the CMake-configurable form of the boost test framework - congrats! (Including File: ${includeFileLoc})")
 			elseif("${includeType}" STREQUAL "INCLUDED")

CMakeModules/DetectArch.cmake

@@ -0,0 +1,37 @@
+IF(CMAKE_SYSTEM_PROCESSOR MATCHES amd64.*|x86_64.* OR CMAKE_GENERATOR MATCHES "Visual Studio.*Win64")
+  IF(CMAKE_C_FLAGS MATCHES -m32 OR CMAKE_CXX_FLAGS MATCHES -m32)
+    SET(X86 1)
+  ELSE(CMAKE_C_FLAGS MATCHES -m32 OR CMAKE_CXX_FLAGS MATCHES -m32)
+    SET(X86_64 1)
+  ENDIF(CMAKE_C_FLAGS MATCHES -m32 OR CMAKE_CXX_FLAGS MATCHES -m32)
+ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES i686.*|i386.*|x86.* OR WIN32)
+  IF(CMAKE_C_FLAGS MATCHES -m64 OR CMAKE_CXX_FLAGS MATCHES -m64)
+    SET(X86_64 1)
+  ELSE(CMAKE_C_FLAGS MATCHES -m64 OR CMAKE_CXX_FLAGS MATCHES -m64)
+    SET(X86 1)
+  ENDIF(CMAKE_C_FLAGS MATCHES -m64 OR CMAKE_CXX_FLAGS MATCHES -m64)
+ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES arm.* AND CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    SET(ARM 1)
+ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES mips)
+    SET(MIPS 1)
+ENDIF()
+
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
+  # using Clang
+  SET(CLANG 1)
+ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "TinyCC")
+  # using TinyCC
+  SET(TINYCC 1)
+ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
+  # using GCC
+  SET(GCC 1)
+ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Intel")
+  # using Intel C++
+  SET(INTELCC 1)
+ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+  # using Visual Studio C++
+  SET(MSVC 1)
+ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MIPSpro")
+  # using SGI MIPSpro
+  SET(MIPSPRO 1)
+ENDIF()

CMakeModules/FindAAX.cmake

@@ -0,0 +1,48 @@
+# Locate AAX
+# This module defines
+# AAX_LIBRARIES
+# AAX_FOUND, if false, do not try to link to AAX 
+# AAX_INCLUDE_DIR, where to find the headers
+#
+# $AAXDIR is an environment variable that would
+# correspond to the ./configure --prefix=$AAXDIR
+# used in building AAX.
+#
+# Created by Erik Hofman.
+
+FIND_PATH(AAX_INCLUDE_DIR aax/aeonwave.hpp
+  HINTS
+  $ENV{AAXDIR}
+  $ENV{ProgramFiles}/aax
+  $ENV{ProgramFiles}/AeonWave
+  $ENV{ProgramFiles}/Adalin/AeonWave
+  PATH_SUFFIXES include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt
+)
+
+FIND_LIBRARY(AAX_LIBRARY 
+  NAMES AAX aax AAX32 libAAX32
+  HINTS
+  $ENV{AAXDIR}
+  $ENV{ProgramFiles}/AAX
+  $ENV{ProgramFiles}/AeonWave
+  $ENV{ProgramFiles}/Adalin/AeonWave
+  PATH_SUFFIXES bin lib lib/${CMAKE_LIBRARY_ARCHITECTURE} lib64 libs64 libs libs/Win32 libs/Win64
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr
+  /opt
+  /usr/local
+)
+
+SET(AAX_FOUND "NO")
+IF(AAX_LIBRARY AND AAX_INCLUDE_DIR)
+  SET(AAX_FOUND "YES")
+ENDIF(AAX_LIBRARY AND AAX_INCLUDE_DIR)
+

CMakeModules/FindUdns.cmake

@@ -0,0 +1,42 @@
+# - Try to find UDNS library
+# Once done this will define
+#
+#  UDNS_FOUND - system has UDNS
+#  UDNS_INCLUDE_DIRS - the UDNS include directory
+#  UDNS_LIBRARIES - Link these to use UDNS
+#  UDNS_DEFINITIONS - Compiler switches required for using UDNS
+#
+#  Copyright (c) 2016 Maciej Mrozowski <reavertm@gmail.com>
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+
+if (UDNS_LIBRARIES AND UDNS_INCLUDE_DIRS)
+  # in cache already
+  set(UDNS_FOUND TRUE)
+else ()
+  set(UDNS_DEFINITIONS "")
+
+  find_path(UDNS_INCLUDE_DIRS NAMES udns.h)
+  find_library(UDNS_LIBRARIES NAMES udns)
+
+  if (UDNS_INCLUDE_DIRS AND UDNS_LIBRARIES)
+    set(UDNS_FOUND TRUE)
+  endif ()
+
+  if (UDNS_FOUND)
+    if (NOT Udns_FIND_QUIETLY)
+      message(STATUS "Found UDNS: ${UDNS_LIBRARIES}")
+    endif ()
+  else ()
+    if (Udns_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find UDNS")
+    endif ()
+  endif ()
+
+  # show the UDNS_INCLUDE_DIRS and UDNS_LIBRARIES variables only in the advanced view
+  mark_as_advanced(UDNS_INCLUDE_DIRS UDNS_LIBRARIES)
+
+endif ()

SimGearConfig.cmake.in

@@ -13,4 +13,8 @@ set(SIMGEAR_SOUND @ENABLE_SOUND@)
 #  find_dependency(OpenAL)
 #endif()
 
+# SSE/SSE2 support
+
+set(ENABLE_SIMD @ENABLE_SIMD@)
+
 include("${CMAKE_CURRENT_LIST_DIR}/SimGearTargets.cmake")

simgear/CMakeLists.txt

@@ -54,24 +54,14 @@ if(SIMGEAR_SHARED)
     set_property(TARGET SimGearCore PROPERTY LINKER_LANGUAGE CXX)
     set_property(TARGET SimGearCore PROPERTY VERSION   ${SIMGEAR_VERSION})
     set_property(TARGET SimGearCore PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
-    install(TARGETS SimGearCore
-            EXPORT SimGearTargets
-            LIBRARY DESTINATION
-            ${CMAKE_INSTALL_LIBDIR})
+
 
     if(NOT SIMGEAR_HEADLESS)
         add_library(SimGearScene SHARED ${sceneSources})
         set_property(TARGET SimGearScene PROPERTY LINKER_LANGUAGE CXX)
         set_property(TARGET SimGearScene PROPERTY VERSION   ${SIMGEAR_VERSION})
         set_property(TARGET SimGearScene PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
-
-        # EXPORT SimGearSceneConfig
-        install(TARGETS SimGearScene
-                EXPORT SimGearTargets
-                LIBRARY
-                DESTINATION ${CMAKE_INSTALL_LIBDIR} )
     endif()
-
 else()
     message(STATUS "Library building mode: STATIC LIBRARIES")
 
@@ -94,9 +84,6 @@ else()
 	endforeach()
 
     add_library(SimGearCore STATIC ${coreSources} ${localExpatSources})
-    install(TARGETS SimGearCore
-            EXPORT SimGearTargets
-            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
     if(NOT SIMGEAR_HEADLESS)
 		get_property(FG_GROUPS_SCENE_SOURCES_C GLOBAL PROPERTY FG_GROUPS_SCENE_SOURCES_C)
@@ -118,22 +105,65 @@ else()
 		endforeach()
 
         add_library(SimGearScene STATIC ${sceneSources})
-        install(TARGETS SimGearScene
-                EXPORT SimGearTargets
-                ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
     endif(NOT SIMGEAR_HEADLESS)
 endif(SIMGEAR_SHARED)
 
+target_include_directories(SimGearCore BEFORE PUBLIC
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+    $<INSTALL_INTERFACE:include>)
+
+target_include_directories(SimGearCore PUBLIC
+  ${Boost_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIR})
+target_include_directories(SimGearCore PRIVATE
+  ${EXPAT_INCLUDE_DIRS} ${CURL_INCLUDE_DIRS})
+
+    install(TARGETS SimGearCore
+            EXPORT SimGearTargets
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+if (NOT SIMGEAR_HEADLESS)
+  install(TARGETS SimGearScene
+          EXPORT SimGearTargets
+          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+  target_include_directories(SimGearScene BEFORE PUBLIC
+      $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+    $<INSTALL_INTERFACE:include>)
+
+    target_include_directories(SimGearScene PUBLIC ${OPENSCENEGRAPH_INCLUDE_DIRS})
+
+    if (USE_AEONWAVE)
+      target_include_directories(SimGearScene PRIVATE ${AAX_INCLUDE_DIR} )
+    else()
+      target_include_directories(SimGearScene PRIVATE ${OPENAL_INCLUDE_DIR} )
+    endif()
+endif()
+
+
 target_link_libraries(SimGearCore
     ${ZLIB_LIBRARY}
     ${RT_LIBRARY}
     ${DL_LIBRARY}
-    ${EXPAT_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
     ${COCOA_LIBRARY}
-    ${CURL_LIBRARIES})
+    ${CURL_LIBRARIES}
+    ${WINSOCK_LIBRARY})
+
+if(SYSTEM_EXPAT)
+    target_link_libraries(SimGearCore
+        ${EXPAT_LIBRARIES})
+endif()
+
+if(ENABLE_DNS AND SYSTEM_UDNS)
+    target_link_libraries(SimGearCore
+        ${UDNS_LIBRARIES})
+endif()
 
 if(NOT SIMGEAR_HEADLESS)
+    target_include_directories(SimGearScene PRIVATE ${PROJECT_SOURCE_DIR}/simgear/canvas/ShivaVG/include)
+
     target_link_libraries(SimGearScene
         SimGearCore
         ${ZLIB_LIBRARY}
@@ -141,6 +171,9 @@ if(NOT SIMGEAR_HEADLESS)
         ${OPENAL_LIBRARY}
         ${OPENGL_LIBRARY}
         ${JPEG_LIBRARY})
+
+    # only actually needed by canvas/KeyboardEvent.cxx
+    target_include_directories(SimGearScene PRIVATE ${PROJECT_SOURCE_DIR}/3rdparty/utf8/source)
 endif()
 
 if(ENABLE_RTI)

simgear/bucket/newbucket.cxx

@@ -227,9 +227,7 @@ std::string SGBucket::gen_base_path() const {
 	    hem, top_lon, pole, top_lat, 
 	    hem, main_lon, pole, main_lat);
 
-    SGPath path( raw_path );
-
-    return path.str();
+    return raw_path;
 }
 
 

simgear/bucket/test_bucket.cxx

@@ -35,123 +35,124 @@ using std::endl;
 
 void testBucketSpans()
 {
-    COMPARE(sg_bucket_span(0.0), 0.125);
-    COMPARE(sg_bucket_span(-20), 0.125);
-    COMPARE(sg_bucket_span(-40), 0.25);
-    COMPARE(sg_bucket_span(89.9), 12.0);
-    COMPARE(sg_bucket_span(88.1), 4.0);
-    COMPARE(sg_bucket_span(-89.9), 12.0);
+    SG_CHECK_EQUAL(sg_bucket_span(0.0), 0.125);
+    SG_CHECK_EQUAL(sg_bucket_span(-20), 0.125);
+    SG_CHECK_EQUAL(sg_bucket_span(-40), 0.25);
+    SG_CHECK_EQUAL(sg_bucket_span(89.9), 12.0);
+    SG_CHECK_EQUAL(sg_bucket_span(88.1), 4.0);
+    SG_CHECK_EQUAL(sg_bucket_span(-89.9), 12.0);
 }
 
 void testBasic()
 {
     SGBucket b1(5.1, 55.05);
-    COMPARE(b1.get_chunk_lon(), 5);
-    COMPARE(b1.get_chunk_lat(), 55);
-    COMPARE(b1.get_x(), 0);
-    COMPARE(b1.get_y(), 0);
-    COMPARE(b1.gen_index(), 3040320);
-    COMPARE(b1.gen_base_path(), "e000n50/e005n55");
-    VERIFY(b1.isValid());
+    SG_CHECK_EQUAL(b1.get_chunk_lon(), 5);
+    SG_CHECK_EQUAL(b1.get_chunk_lat(), 55);
+    SG_CHECK_EQUAL(b1.get_x(), 0);
+    SG_CHECK_EQUAL(b1.get_y(), 0);
+    SG_CHECK_EQUAL(b1.gen_index(), 3040320);
+    SG_CHECK_EQUAL(b1.gen_base_path(), "e000n50/e005n55");
+    SG_VERIFY(b1.isValid());
     
     SGBucket b2(-10.1, -43.8);
-    COMPARE(b2.get_chunk_lon(), -11);
-    COMPARE(b2.get_chunk_lat(), -44);
-    COMPARE(b2.get_x(), 3);
-    COMPARE(b2.get_y(), 1); // latitude chunks numbered bottom to top, it seems
-    COMPARE(b2.gen_base_path(), "w020s50/w011s44");
-    VERIFY(b2.isValid());
+    SG_CHECK_EQUAL(b2.get_chunk_lon(), -11);
+    SG_CHECK_EQUAL(b2.get_chunk_lat(), -44);
+    SG_CHECK_EQUAL(b2.get_x(), 3);
+    // Latitude chunks numbered bottom to top, it seems
+    SG_CHECK_EQUAL(b2.get_y(), 1);
+    SG_CHECK_EQUAL(b2.gen_base_path(), "w020s50/w011s44");
+    SG_VERIFY(b2.isValid());
     
     SGBucket b3(123.48, 9.01);
-    COMPARE(b3.get_chunk_lon(), 123);
-    COMPARE(b3.get_chunk_lat(), 9);
-    COMPARE(b3.get_x(), 3);
-    COMPARE(b3.get_y(), 0);
-    COMPARE(b3.gen_base_path(), "e120n00/e123n09");
-    VERIFY(b3.isValid());
+    SG_CHECK_EQUAL(b3.get_chunk_lon(), 123);
+    SG_CHECK_EQUAL(b3.get_chunk_lat(), 9);
+    SG_CHECK_EQUAL(b3.get_x(), 3);
+    SG_CHECK_EQUAL(b3.get_y(), 0);
+    SG_CHECK_EQUAL(b3.gen_base_path(), "e120n00/e123n09");
+    SG_VERIFY(b3.isValid());
     
     SGBucket defBuck;
-    VERIFY(!defBuck.isValid());
+    SG_VERIFY(!defBuck.isValid());
     
     b3.make_bad();
-    VERIFY(!b3.isValid());
+    SG_VERIFY(!b3.isValid());
 
     SGBucket atAntiMeridian(180.0, 12.3);
-    VERIFY(atAntiMeridian.isValid());
-    COMPARE(atAntiMeridian.get_chunk_lon(), -180);
-    COMPARE(atAntiMeridian.get_x(), 0);
-    
+    SG_VERIFY(atAntiMeridian.isValid());
+    SG_CHECK_EQUAL(atAntiMeridian.get_chunk_lon(), -180);
+    SG_CHECK_EQUAL(atAntiMeridian.get_x(), 0);
+
     SGBucket atAntiMeridian2(-180.0, -78.1);
-    VERIFY(atAntiMeridian2.isValid());
-    COMPARE(atAntiMeridian2.get_chunk_lon(), -180);
-    COMPARE(atAntiMeridian2.get_x(), 0);
-    
+    SG_VERIFY(atAntiMeridian2.isValid());
+    SG_CHECK_EQUAL(atAntiMeridian2.get_chunk_lon(), -180);
+    SG_CHECK_EQUAL(atAntiMeridian2.get_x(), 0);
+
 // check comparisom operator overload
     SGBucket b4(5.11, 55.1);
-    VERIFY(b1 == b4); // should be equal
-    VERIFY(b1 == b1);
-    VERIFY(b1 != defBuck);
-    VERIFY(b1 != b2);
+    SG_VERIFY(b1 == b4); // should be equal
+    SG_VERIFY(b1 == b1);
+    SG_VERIFY(b1 != defBuck);
+    SG_VERIFY(b1 != b2);
     
 // check wrapping/clipping of inputs
     SGBucket wrapMeridian(-200.0, 45.0);
-    COMPARE(wrapMeridian.get_chunk_lon(), 160);
-    
+    SG_CHECK_EQUAL(wrapMeridian.get_chunk_lon(), 160);
+
     SGBucket clipPole(48.9, 91);
-    COMPARE(clipPole.get_chunk_lat(), 89);
+    SG_CHECK_EQUAL(clipPole.get_chunk_lat(), 89);
 }
 
 void testPolar()
 {
     SGBucket b1(0.0, 89.92);
     SGBucket b2(10.0, 89.96);
-    COMPARE(b1.get_chunk_lat(), 89);
-    COMPARE(b1.get_chunk_lon(), 0);
-    COMPARE(b1.get_x(), 0);
-    COMPARE(b1.get_y(), 7);
+    SG_CHECK_EQUAL(b1.get_chunk_lat(), 89);
+    SG_CHECK_EQUAL(b1.get_chunk_lon(), 0);
+    SG_CHECK_EQUAL(b1.get_x(), 0);
+    SG_CHECK_EQUAL(b1.get_y(), 7);
     
-    COMPARE_EP(b1.get_highest_lat(), 90.0);
-    COMPARE_EP(b1.get_width_m(), 10.0);
+    SG_CHECK_EQUAL_EP(b1.get_highest_lat(), 90.0);
+    SG_CHECK_EQUAL_EP(b1.get_width_m(), 10.0);
     
-    COMPARE(b2.get_chunk_lat(), 89);
-    COMPARE(b2.get_chunk_lon(), 0);
-    COMPARE(b2.get_x(), 0);
-    COMPARE(b2.get_y(), 7);
+    SG_CHECK_EQUAL(b2.get_chunk_lat(), 89);
+    SG_CHECK_EQUAL(b2.get_chunk_lon(), 0);
+    SG_CHECK_EQUAL(b2.get_x(), 0);
+    SG_CHECK_EQUAL(b2.get_y(), 7);
     
-    COMPARE(b1.gen_index(), b2.gen_index());
+    SG_CHECK_EQUAL(b1.gen_index(), b2.gen_index());
     
     SGGeod actualNorthPole1 = b1.get_corner(2);
     SGGeod actualNorthPole2 = b1.get_corner(3);
-    COMPARE_EP(actualNorthPole1.getLatitudeDeg(), 90.0);
-    COMPARE_EP(actualNorthPole1.getLongitudeDeg(), 12.0);
-    COMPARE_EP(actualNorthPole2.getLatitudeDeg(), 90.0);
-    COMPARE_EP(actualNorthPole2.getLongitudeDeg(), 0.0);
+    SG_CHECK_EQUAL_EP(actualNorthPole1.getLatitudeDeg(), 90.0);
+    SG_CHECK_EQUAL_EP(actualNorthPole1.getLongitudeDeg(), 12.0);
+    SG_CHECK_EQUAL_EP(actualNorthPole2.getLatitudeDeg(), 90.0);
+    SG_CHECK_EQUAL_EP(actualNorthPole2.getLongitudeDeg(), 0.0);
 
     SGBucket b3(-2, 89.88);
     SGBucket b4(-7, 89.88);
-    COMPARE(b3.gen_index(), b4.gen_index());
+    SG_CHECK_EQUAL(b3.gen_index(), b4.gen_index());
     
     // south pole
     SGBucket b5(-170, -89.88);
     SGBucket b6(-179, -89.88);
     
-    COMPARE(b5.get_chunk_lat(), -90);
-    COMPARE(b5.get_chunk_lon(), -180);
-    COMPARE(b5.get_x(), 0);
-    COMPARE(b5.get_y(), 0);
-    COMPARE(b5.gen_index(), b6.gen_index());
-    COMPARE_EP(b5.get_highest_lat(), -90.0);
-    COMPARE_EP(b5.get_width_m(), 10.0);
+    SG_CHECK_EQUAL(b5.get_chunk_lat(), -90);
+    SG_CHECK_EQUAL(b5.get_chunk_lon(), -180);
+    SG_CHECK_EQUAL(b5.get_x(), 0);
+    SG_CHECK_EQUAL(b5.get_y(), 0);
+    SG_CHECK_EQUAL(b5.gen_index(), b6.gen_index());
+    SG_CHECK_EQUAL_EP(b5.get_highest_lat(), -90.0);
+    SG_CHECK_EQUAL_EP(b5.get_width_m(), 10.0);
     
     SGGeod actualSouthPole1 = b5.get_corner(0);
     SGGeod actualSouthPole2 = b5.get_corner(1);
-    COMPARE_EP(actualSouthPole1.getLatitudeDeg(), -90.0);
-    COMPARE_EP(actualSouthPole1.getLongitudeDeg(), -180);
-    COMPARE_EP(actualSouthPole2.getLatitudeDeg(), -90.0);
-    COMPARE_EP(actualSouthPole2.getLongitudeDeg(), -168);
+    SG_CHECK_EQUAL_EP(actualSouthPole1.getLatitudeDeg(), -90.0);
+    SG_CHECK_EQUAL_EP(actualSouthPole1.getLongitudeDeg(), -180);
+    SG_CHECK_EQUAL_EP(actualSouthPole2.getLatitudeDeg(), -90.0);
+    SG_CHECK_EQUAL_EP(actualSouthPole2.getLongitudeDeg(), -168);
     
     SGBucket b7(200, 89.88);
-    COMPARE(b7.get_chunk_lon(), -168);
+    SG_CHECK_EQUAL(b7.get_chunk_lon(), -168);
 
 }
 
@@ -160,15 +161,15 @@ void testNearPolar()
 {
     SGBucket b1(1, 88.5);
     SGBucket b2(-1, 88.8);
-    COMPARE(b1.get_chunk_lon(), 0);
-    COMPARE(b1.get_chunk_lat(), 88);
-    VERIFY(b1.gen_index() != b2.gen_index());
+    SG_CHECK_EQUAL(b1.get_chunk_lon(), 0);
+    SG_CHECK_EQUAL(b1.get_chunk_lat(), 88);
+    SG_VERIFY(b1.gen_index() != b2.gen_index());
 
     SGBucket b3(176.1, 88.5);
-    COMPARE(b3.get_chunk_lon(), 176);
+    SG_CHECK_EQUAL(b3.get_chunk_lon(), 176);
     
     SGBucket b4(-178, 88.5);
-    COMPARE(b4.get_chunk_lon(), -180);
+    SG_CHECK_EQUAL(b4.get_chunk_lon(), -180);
 }
 
 void testOffset()
@@ -176,74 +177,74 @@ void testOffset()
     // bucket just below the 22 degree cutoff, so the next tile north
     // is twice the width
     SGBucket b1(-59.8, 21.9);
-    COMPARE(b1.get_chunk_lat(), 21);
-    COMPARE(b1.get_chunk_lon(), -60);
-    COMPARE(b1.get_x(), 1);
-    COMPARE(b1.get_y(), 7);
+    SG_CHECK_EQUAL(b1.get_chunk_lat(), 21);
+    SG_CHECK_EQUAL(b1.get_chunk_lon(), -60);
+    SG_CHECK_EQUAL(b1.get_x(), 1);
+    SG_CHECK_EQUAL(b1.get_y(), 7);
     
     // offset vertically
     SGBucket b2(b1.sibling(0, 1));
-    COMPARE(b2.get_chunk_lat(), 22);
-    COMPARE(b2.get_chunk_lon(), -60);
-    COMPARE(b2.get_x(), 0);
-    COMPARE(b2.get_y(), 0);
+    SG_CHECK_EQUAL(b2.get_chunk_lat(), 22);
+    SG_CHECK_EQUAL(b2.get_chunk_lon(), -60);
+    SG_CHECK_EQUAL(b2.get_x(), 0);
+    SG_CHECK_EQUAL(b2.get_y(), 0);
 
-    COMPARE(b2.gen_index(), sgBucketOffset(-59.8, 21.9, 0, 1));
+    SG_CHECK_EQUAL(b2.gen_index(), sgBucketOffset(-59.8, 21.9, 0, 1));
     
     // offset vertically and horizontally. We compute horizontal (x)
     // movement at the target latitude, so this should move 0.25 * -3 degrees,
     // NOT 0.125 * -3 degrees.
     SGBucket b3(b1.sibling(-3, 1));
-    COMPARE(b3.get_chunk_lat(), 22);
-    COMPARE(b3.get_chunk_lon(), -61);
-    COMPARE(b3.get_x(), 1);
-    COMPARE(b3.get_y(), 0);
+    SG_CHECK_EQUAL(b3.get_chunk_lat(), 22);
+    SG_CHECK_EQUAL(b3.get_chunk_lon(), -61);
+    SG_CHECK_EQUAL(b3.get_x(), 1);
+    SG_CHECK_EQUAL(b3.get_y(), 0);
     
-    COMPARE(b3.gen_index(), sgBucketOffset(-59.8, 21.9, -3, 1));
+    SG_CHECK_EQUAL(b3.gen_index(), sgBucketOffset(-59.8, 21.9, -3, 1));
 }
 
 void testPolarOffset()
 {
     SGBucket b1(-11.7, -89.6);
-    COMPARE(b1.get_chunk_lat(), -90);
-    COMPARE(b1.get_chunk_lon(), -12);
-    COMPARE(b1.get_x(), 0);
-    COMPARE(b1.get_y(), 3);
+    SG_CHECK_EQUAL(b1.get_chunk_lat(), -90);
+    SG_CHECK_EQUAL(b1.get_chunk_lon(), -12);
+    SG_CHECK_EQUAL(b1.get_x(), 0);
+    SG_CHECK_EQUAL(b1.get_y(), 3);
     
     // offset horizontally
     SGBucket b2(b1.sibling(-2, 0));
-    COMPARE(b2.get_chunk_lat(), -90);
-    COMPARE(b2.get_chunk_lon(), -36);
-    COMPARE(b2.get_x(), 0);
-    COMPARE(b2.get_y(), 3);
+    SG_CHECK_EQUAL(b2.get_chunk_lat(), -90);
+    SG_CHECK_EQUAL(b2.get_chunk_lon(), -36);
+    SG_CHECK_EQUAL(b2.get_x(), 0);
+    SG_CHECK_EQUAL(b2.get_y(), 3);
     
-    COMPARE(b2.gen_index(), sgBucketOffset(-11.7, -89.6, -2, 0));
+    SG_CHECK_EQUAL(b2.gen_index(), sgBucketOffset(-11.7, -89.6, -2, 0));
     
 // offset and wrap
     SGBucket b3(-170, 89.1);
     SGBucket b4(b3.sibling(-1, 0));
-    COMPARE(b4.get_chunk_lat(), 89);
-    COMPARE(b4.get_chunk_lon(), 168);
-    COMPARE(b4.get_x(), 0);
-    COMPARE(b4.get_y(), 0);
+    SG_CHECK_EQUAL(b4.get_chunk_lat(), 89);
+    SG_CHECK_EQUAL(b4.get_chunk_lon(), 168);
+    SG_CHECK_EQUAL(b4.get_x(), 0);
+    SG_CHECK_EQUAL(b4.get_y(), 0);
     
-    COMPARE(b4.gen_index(), sgBucketOffset(-170, 89.1, -1, 0));
+    SG_CHECK_EQUAL(b4.gen_index(), sgBucketOffset(-170, 89.1, -1, 0));
 
     
     SGBucket b5(177, 87.3);
     SGBucket b6(b5.sibling(1, 1));
-    COMPARE(b6.get_chunk_lat(), 87);
-    COMPARE(b6.get_chunk_lon(), -180);
-    COMPARE(b6.get_x(), 0);
-    COMPARE(b6.get_y(), 3);
+    SG_CHECK_EQUAL(b6.get_chunk_lat(), 87);
+    SG_CHECK_EQUAL(b6.get_chunk_lon(), -180);
+    SG_CHECK_EQUAL(b6.get_x(), 0);
+    SG_CHECK_EQUAL(b6.get_y(), 3);
     
-    COMPARE(b6.gen_index(), sgBucketOffset(177, 87.3, 1, 1));
+    SG_CHECK_EQUAL(b6.gen_index(), sgBucketOffset(177, 87.3, 1, 1));
 
     // offset vertically towards the pole
     SGBucket b7(b1.sibling(0, -5));
-    VERIFY(!b7.isValid());
+    SG_VERIFY(!b7.isValid());
     
-    VERIFY(!SGBucket(0, 90).sibling(0, 1).isValid());
+    SG_VERIFY(!SGBucket(0, 90).sibling(0, 1).isValid());
 }
 
 // test behaviour of bucket-offset near the anti-meridian (180-meridian)
@@ -251,17 +252,17 @@ void testOffsetWrap()
 {
     // near the equator
     SGBucket b1(-179.8, 16.8);
-    COMPARE(b1.get_chunk_lat(), 16);
-    COMPARE(b1.get_chunk_lon(), -180);
-    COMPARE(b1.get_x(), 1);
-    COMPARE(b1.get_y(), 6);
+    SG_CHECK_EQUAL(b1.get_chunk_lat(), 16);
+    SG_CHECK_EQUAL(b1.get_chunk_lon(), -180);
+    SG_CHECK_EQUAL(b1.get_x(), 1);
+    SG_CHECK_EQUAL(b1.get_y(), 6);
     
     SGBucket b2(b1.sibling(-2, 0));
-    COMPARE(b2.get_chunk_lat(), 16);
-    COMPARE(b2.get_chunk_lon(), 179);
-    COMPARE(b2.get_x(), 7);
-    COMPARE(b2.get_y(), 6);
-    COMPARE(b2.gen_index(), sgBucketOffset(-179.8, 16.8, -2, 0));
+    SG_CHECK_EQUAL(b2.get_chunk_lat(), 16);
+    SG_CHECK_EQUAL(b2.get_chunk_lon(), 179);
+    SG_CHECK_EQUAL(b2.get_x(), 7);
+    SG_CHECK_EQUAL(b2.get_y(), 6);
+    SG_CHECK_EQUAL(b2.gen_index(), sgBucketOffset(-179.8, 16.8, -2, 0));
     
     
 }

simgear/canvas/ShivaVG/src/shDefs.h

@@ -44,6 +44,11 @@
 #if defined(_MSC_VER)
 #  pragma warning(disable:4311)
 #  pragma warning(disable:4312)
+#  define ALIGN16 __declspec(align(16))
+#  define ALIGN16C
+#elif defined(__GNUC__)
+#  define ALIGN16
+#  define ALIGN16C __attribute__((aligned(16)))
 #endif
 
 /* Type definitions */

simgear/canvas/ShivaVG/src/shPipeline.c

@@ -80,8 +80,12 @@ void updateBlendingStateGL(VGContext *c, int alphaIsOne)
 
   case VG_BLEND_SRC_OVER: default:
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-    if (alphaIsOne) glDisable(GL_BLEND);
-    else glEnable(GL_BLEND); break;
+    if (alphaIsOne) {
+      glDisable(GL_BLEND);
+    } else {
+      glEnable(GL_BLEND);
+    }
+    break;
   };
 }
 

simgear/canvas/ShivaVG/src/shVectors.c

@@ -35,21 +35,33 @@ void SHVector2_dtor(SHVector2 *v) {
 }
 
 void SHVector3_ctor(SHVector3 *v) {
+#ifdef __SSE__
+  v->vec = _mm_setzero_ps();
+#else
   v->x=0.0f; v->y=0.0f; v->z=0.0f;
+#endif
 }
 
 void SHVector3_dtor(SHVector3 *v) {
 }
 
 void SHVector4_ctor(SHVector4 *v) {
+#ifdef __SSE__
+  v->vec = _mm_setzero_ps();
+#else
   v->x=0.0f; v->y=0.0f; v->z=0.0f; v->w=0.0f;
+#endif
 }
 
 void SHVector4_dtor(SHVector4 *v) {
 }
 
 void SHRectangle_ctor(SHRectangle *r) {
+#ifdef __SSE__
+  r->vec = _mm_setzero_ps();
+#else
   r->x=0.0f; r->y=0.0f; r->w=0.0f; r->h=0.0f;
+#endif
 }
 
 void SHRectangle_dtor(SHRectangle *r) {
@@ -135,3 +147,24 @@ int shLineLineXsection(SHVector2 *o1, SHVector2 *v1,
   xsection->y = o1->y + t1*v1->y;
   return 1;
 }
+
+#ifdef __SSE__
+# ifdef __SSE3__
+# include <pmmintrin.h>
+inline float hsum_ps_sse(__m128 v) {
+  __m128 shuf = _mm_movehdup_ps(v);
+  __m128 sums = _mm_add_ps(v, shuf);
+  shuf        = _mm_movehl_ps(shuf, sums);
+  sums        = _mm_add_ss(sums, shuf);
+  return        _mm_cvtss_f32(sums);
+}
+# else
+inline float hsum_ps_sse(__m128 v) {
+  __m128 shuf   = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 3, 0, 1));
+  __m128 sums   = _mm_add_ps(v, shuf);
+  shuf          = _mm_movehl_ps(shuf, sums);
+  sums          = _mm_add_ss(sums, shuf);
+  return          _mm_cvtss_f32(sums);
+}
+# endif
+#endif

simgear/canvas/ShivaVG/src/shVectors.h

@@ -21,6 +21,11 @@
 #ifndef __SHVECTORS_H
 #define __SHVECTORS_H
 
+#ifdef __SSE__
+# include <xmmintrin.h>
+float hsum_ps_sse(__m128 v);
+#endif
+
 #include "shDefs.h"
 
 /* Vector structures
@@ -33,9 +38,17 @@ typedef struct
 void SHVector2_ctor(SHVector2 *v);
 void SHVector2_dtor(SHVector2 *v);
 
+
 typedef struct
 {
+#ifdef __SSE__
+  union ALIGN16 {
+    __m128 vec;
+    struct { SHfloat x,y,z,w; };
+  } ALIGN16C;
+#else
   SHfloat x,y,z;
+#endif
 } SHVector3;
 
 void SHVector3_ctor(SHVector3 *v);
@@ -43,7 +56,14 @@ void SHVector3_dtor(SHVector3 *v);
 
 typedef struct
 {
+#ifdef __SSE__
+  union ALIGN16 {
+    __m128 vec;
+    struct { SHfloat x,y,z,w; };
+  } ALIGN16C;
+#else
   SHfloat x,y,z,w;
+#endif
 } SHVector4;
 
 void SHVector4_ctor(SHVector4 *v);
@@ -51,7 +71,14 @@ void SHVector4_dtor(SHVector4 *v);
 
 typedef struct
 {
+#ifdef __SSE__
+  union ALIGN16 {
+    __m128 vec;
+    struct { SHfloat x,y,w,h; };
+  } ALIGN16C;
+#else
   SHfloat x,y,w,h;
+#endif
 } SHRectangle;
 
 void SHRectangle_ctor(SHRectangle *r);
@@ -61,7 +88,14 @@ void shRectangleSet(SHRectangle *r, SHfloat x,
 
 typedef struct
 {
+#ifdef __SSE__
+  union ALIGN16 {
+    __m128 mtx[4];
+    SHfloat m[4][4];
+  } ALIGN16C;
+#else
   SHfloat m[3][3];
+#endif
 } SHMatrix3x3;
 
 void SHMatrix3x3_ctor(SHMatrix3x3 *m);
@@ -83,12 +117,22 @@ void SHMatrix3x3_dtor(SHMatrix3x3 *m);
  *--------------------------------------------------------- */
 
 #define SET2(v,xs,ys) { v.x=xs; v.y=ys; }
-#define SET3(v,xs,ys,zs) { v.x=xs; v.y=ys; v.z=zs; }
-#define SET4(v,xs,ys,zs,ws) { v.x=xs; v.y=ys; v.z=zs; v.w=ws; }
+#ifdef __SSE__
+# define SET3(v,xs,ys,zs,ws) { v.vec=_mm_set_ps(0,zs,ys,xs); }
+# define SET4(v,xs,ys,zs,ws) { v.vec=_mm_set_ps(ws,zs,ys,xs); }
+#else
+# define SET3(v,xs,ys,zs) { v.x=xs; v.y=ys; v.z=zs; }
+# define SET4(v,xs,ys,zs,ws) { v.x=xs; v.y=ys; v.z=zs; v.w=ws; }
+#endif
 
 #define SET2V(v1,v2) { v1.x=v2.x; v1.y=v2.y; }
-#define SET3V(v1,v2) { v1.x=v2.x; v1.y=v2.y; v1.z=v2.z; }
-#define SET4V(v1,v2) { v1.x=v2.x; v1.y=v2.y; v1.z=v2.z; v1.w=v2.w; }
+#ifdef __SSE__
+# define SET3V(v1,v2) { v1.vec=v2.vec; }
+# define SET4V(v1,v2) { v1.vec=v2.vec; }
+#else
+# define SET3V(v1,v2) { v1.x=v2.x; v1.y=v2.y; v1.z=v2.z; }
+# define SET4V(v1,v2) { v1.x=v2.x; v1.y=v2.y; v1.z=v2.z; v1.w=v2.w; }
+#endif
 
 #define EQ2(v,xx,yy)       ( v.x==xx && v.y==yy )
 #define EQ3(v,xx,yy,zz)    ( v.x==xx && v.y==yy && v.z==zz )
@@ -103,48 +147,89 @@ void SHMatrix3x3_dtor(SHMatrix3x3 *m);
 #define EQ4V(v1,v2) ( v1.x==v2.x && v1.y==v2.y && v1.z==v2.z && v1.w==v2.w )
 
 #define ADD2(v,xx,yy)       { v.x+=xx; v.y+=yy; }
-#define ADD3(v,xx,yy,zz)    { v.x+=xx; v.y+=yy; v.z+=zz; }
-#define ADD4(v,xx,yy,zz,ww) { v.x+=xx; v.y+=yy; v.z+=zz; v.w+=ww; }
+#ifdef __SSE__
+# define ADD3(v,xx,yy,zz,ww) { v.vec=_mm_add_ps(v.vec,_mm_set_ps(0,zz,yy,xx)); }
+# define ADD4(v,xx,yy,zz,ww) { v.vec=_mm_add_ps(v.vec,_mm_set_ps(ww,zz,yy,xx)); }
+#else
+# define ADD3(v,xx,yy,zz)    { v.x+=xx; v.y+=yy; v.z+=zz; }
+# define ADD4(v,xx,yy,zz,ww) { v.x+=xx; v.y+=yy; v.z+=zz; v.w+=ww; }
+#endif
 
 #define ADD2V(v1,v2) { v1.x+=v2.x; v1.y+=v2.y; }
-#define ADD3V(v1,v2) { v1.x+=v2.x; v1.y+=v2.y; v1.z+=v2.z; }
-#define ADD4V(v1,v2) { v1.x+=v2.x; v1.y+=v2.y; v1.z+=v2.z; v1.w+=v2.w; }
+#ifdef __SSE__
+# define ADD3V(v1,v2) { v1.vec=_mm_add_ps(v1.vec,v2.vec); }
+# define ADD4V(v1,v2) { v1.vec=_mm_add_ps(v1.vec,v2.vec); }
+#else
+# define ADD3V(v1,v2) { v1.x+=v2.x; v1.y+=v2.y; v1.z+=v2.z; }
+# define ADD4V(v1,v2) { v1.x+=v2.x; v1.y+=v2.y; v1.z+=v2.z; v1.w+=v2.w; }
+#endif
 
 #define SUB2(v,xx,yy)       { v.x-=xx; v.y-=yy; }
-#define SUB3(v,xx,yy,zz)    { v.x-=xx; v.y-=yy; v.z-=zz; }
-#define SUB4(v,xx,yy,zz,ww) { v.x-=xx; v.y-=yy; v.z-=zz; v.w-=v2.w; }
+#ifdef __SSE__
+# define SUB3(v,xx,yy,zz,ww) { v.vec=_mm_sub_ps(v.vec,_mm_set_ps(0,zz,yy,xx)); }
+# define SUB4(v,xx,yy,zz,ww) { v.vec=_mm_sub_ps(v.vec,_mm_set_ps(ww,zz,yy,xx)); }
+#else
+# define SUB3(v,xx,yy,zz)    { v.x-=xx; v.y-=yy; v.z-=zz; }
+# define SUB4(v,xx,yy,zz,ww) { v.x-=xx; v.y-=yy; v.z-=zz; v.w-=v2.w; }
+#endif
 
 #define SUB2V(v1,v2) { v1.x-=v2.x; v1.y-=v2.y; }
-#define SUB3V(v1,v2) { v1.x-=v2.x; v1.y-=v2.y; v1.z-=v2.z; }
-#define SUB4V(v1,v2) { v1.x-=v2.x; v1.y-=v2.y; v1.z-=v2.z; v1.w-=v2.w; }
+#ifdef __SSE__
+# define SUB3V(v1,v2) { v1.vec=_mm_sub_ps(v1.vec,v2.vec); }
+# define SUB4V(v1,v2) { v1.vec=_mm_sub_ps(v1.vec,v2.vec); }
+#else
+# define SUB3V(v1,v2) { v1.x-=v2.x; v1.y-=v2.y; v1.z-=v2.z; }
+# define SUB4V(v1,v2) { v1.x-=v2.x; v1.y-=v2.y; v1.z-=v2.z; v1.w-=v2.w; }
+#endif
 
 #define MUL2(v,f) { v.x*=f; v.y*=f; }
-#define MUL3(v,f) { v.x*=f; v.y*=f; v.z*=z; }
-#define MUL4(v,f) { v.x*=f; v.y*=f; v.z*=z; v.w*=w; }
+#ifdef __SSE__
+# define MUL3(v,f) { v.vec=_mm_mul_ps(v.vec,_mm_set1_ps(f)); }
+# define MUL4(v,f) { v.vec=_mm_mul_ps(v.vec,_mm_set1_ps(f)); }
+#else
+# define MUL3(v,f) { v.x*=f; v.y*=f; v.z*=z; }
+# define MUL4(v,f) { v.x*=f; v.y*=f; v.z*=z; v.w*=w; }
+#endif
 
 #define DIV2(v,f) { v.x/=f; v.y/=f; }
-#define DIV3(v,f) { v.x/=f; v.y/=f; v.z/=z; }
-#define DIV4(v,f) { v.x/=f; v.y/=f; v.z/=z; v.w/=w; }
+#ifdef __SSE__
+# define DIV3(v,f) { v.vec=_mm_div_ps(v.vec,_mm_set1_ps(f)); }
+# define DIV4(v,f) { v.vec=_mm_div_ps(v.vec,_mm_set1_ps(f)); }
+#else
+# define DIV3(v,f) { v.x/=f; v.y/=f; v.z/=z; }
+# define DIV4(v,f) { v.x/=f; v.y/=f; v.z/=z; v.w/=w; }
+#endif
 
 #define ABS2(v) { v.x=SH_ABS(v.x); v.y=SH_ABS(v.y); }
-#define ABS3(v) { v.x=SH_ABS(v.x); v.y=SH_ABS(v.y); v.z=SH_ABS(v.z); }
-#define ABS4(v) { v.x=SH_ABS(v.x); v.y=SH_ABS(v.y); v.z=SH_ABS(v.z); v.w=SH_ABS(v.w); }
+#ifdef __SSE__
+# define ABS_MASK _mm_set1_ps(-0.f)
+# define ABS3(v) { v.vec=_mm_andnot_ps(ABS_MASK, v.vec); }
+# define ABS4(v) { v.vec=_mm_andnot_ps(ABS_MASK, v.vec); }
+#else
+# define ABS3(v) { v.x=SH_ABS(v.x); v.y=SH_ABS(v.y); v.z=SH_ABS(v.z); }
+# define ABS4(v) { v.x=SH_ABS(v.x); v.y=SH_ABS(v.y); v.z=SH_ABS(v.z); v.w=SH_ABS(v.w); }
+#endif
 
-#define NORMSQ2(v) (v.x*v.x + v.y*v.y)
-#define NORMSQ3(v) (v.x*v.x + v.y*v.y + v.z*v.z)
-#define NORMSQ4(v) (v.x*v.x + v.y*v.y + v.z*v.z + v.w*v.w)
+#define NORMSQ2(v) DOT2(v,v)
+#define NORMSQ3(v) DOT3(v,v)
+#define NORMSQ4(v) DOT4(v,v)
 
 #define NORM2(v) SH_SQRT(NORMSQ2(v))
 #define NORM3(v) SH_SQRT(NORMSQ3(v))
 #define NORM4(v) SH_SQRT(NORMSQ4(v))
 
-#define NORMALIZE2(v) { SHfloat n=NORM2(v); v.x/=n; v.y/=n; }
-#define NORMALIZE3(v) { SHfloat n=NORM3(v); v.x/=n; v.y/=n; v.z/=n; }
-#define NORMALIZE4(v) { SHfloat n=NORM4(v); v.x/=n; v.y/=n; v.z/=n; v.w/=w; }
+#define NORMALIZE2(v) { SHfloat n=NORM2(v); DIV2(v,n); }
+#define NORMALIZE3(v) { SHfloat n=NORM3(v); DIV3(v,n); }
+#define NORMALIZE4(v) { SHfloat n=NORM4(v); DIV4(v,n); }
 
 #define DOT2(v1,v2) (v1.x*v2.x + v1.y*v2.y)
-#define DOT3(v1,v2) (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z)
-#define DOT4(v1,v2) (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z + v1.w*v2.w)
+#ifdef __SSE__
+# define DOT4(v1,v2) hsum_ps_sse(_mm_mul_ps(v1.vec,v2.vec))
+# define DOT4(v1,v2) hsum_ps_sse(_mm_mul_ps(v1.vec,v2.vec))
+#else
+# define DOT3(v1,v2) (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z)
+# define DOT4(v1,v2) (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z + v1.w*v2.w)
+#endif
 
 #define CROSS2(v1,v2) (v1.x*v2.y - v2.x*v1.y)
 
@@ -152,37 +237,84 @@ void SHMatrix3x3_dtor(SHMatrix3x3 *m);
 #define ANGLE2N(v1,v2) (SH_ACOS( DOT2(v1,v2) ))
 
 #define OFFSET2V(v, o, s) { v.x += o.x*s; v.y += o.y*s; }
-#define OFFSET3V(v, o, s) { v.x += o.x*s; v.y += o.y*s; v.z += o.z*s; }
-#define OFFSET4V(v, o, s) { v.x += o.x*s; v.y += o.y*s; v.z += o.z*s; v.w += o.w*s; }
+#ifdef __SSE__
+# define OFFSET4V(v, o, s) { v.vec=_mm_add_ps(v.vec,_mm_mul_ps(o.vec,_mm_set1_ps(s))); }
+# define OFFSET4V(v, o, s) { v.vec=_mm_add_ps(v.vec,_mm_mul_ps(o.vec,_mm_set1_ps(s))); }
+#else
+# define OFFSET3V(v, o, s) { v.x += o.x*s; v.y += o.y*s; v.z += o.z*s; }
+# define OFFSET4V(v, o, s) { v.x += o.x*s; v.y += o.y*s; v.z += o.z*s; v.w += o.w*s; }
+#endif
 
 /*-----------------------------------------------------
  * Macros for matrix operations
  *-----------------------------------------------------*/
 
-#define SETMAT(mat, m00, m01, m02, m10, m11, m12, m20, m21, m22) { \
-mat.m[0][0] = m00; mat.m[0][1] = m01; mat.m[0][2] = m02; \
+#ifdef __SSE__
+# define SETMAT(mat, m00, m01, m02, m10, m11, m12, m20, m21, m22) { \
+  mat.mtx[0] = _mm_set_ps(0,m02,m01,m00); \
+  mat.mtx[1] = _mm_set_ps(0,m12,m11,m10); \
+  mat.mtx[2] = _mm_set_ps(0,m22,m21,m20); \
+  mat.mtx[3] = _mm_setzero_ps(); }
+#else
+# define SETMAT(mat, m00, m01, m02, m10, m11, m12, m20, m21, m22) { \
+  mat.m[0][0] = m00; mat.m[0][1] = m01; mat.m[0][2] = m02; \
   mat.m[1][0] = m10; mat.m[1][1] = m11; mat.m[1][2] = m12; \
   mat.m[2][0] = m20; mat.m[2][1] = m21; mat.m[2][2] = m22; }
+#endif
 
-#define SETMATMAT(m1, m2) { \
+#ifdef __SSE__
+# define SETMATMAT(m1, m2) { \
+  m1.mtx[0] = m2.mtx[0]; \
+  m1.mtx[1] = m2.mtx[1]; \
+  m1.mtx[2] = m2.mtx[2]; }
+#else
+# define SETMATMAT(m1, m2) { \
 int i,j; \
   for(i=0;i<3;i++) \
   for(j=0;j<3;j++) \
     m1.m[i][j] = m2.m[i][j]; }
+#endif
 
-#define MULMATS(mat, s) { \
+#ifdef __SSE__
+# define MULMATS(mat, s) { \
+  mat.mtx[0] = _mm_mul_ps(mat.mtx[0],_mm_set1_ps(s)); \
+  mat.mtx[1] = _mm_mul_ps(mat.mtx[1],_mm_set1_ps(s)); \
+  mat.mtx[2] = _mm_mul_ps(mat.mtx[2],_mm_set1_ps(s)); }
+#else
+# define MULMATS(mat, s) { \
 int i,j; \
   for(i=0;i<3;i++) \
   for(j=0;j<3;j++) \
     mat.m[i][j] *= s; }
+#endif
 
-#define DIVMATS(mat, s) { \
+#ifdef __SSE__
+# define DIVMATS(mat, s) { \
+  mat.mtx[0] = _mm_mul_ps(mat.mtx[0],_mm_set1_ps(1/s)); \
+  mat.mtx[1] = _mm_mul_ps(mat.mtx[1],_mm_set1_ps(1/s)); \
+  mat.mtx[2] = _mm_mul_ps(mat.mtx[2],_mm_set1_ps(1/s)); }
+#else
+# define DIVMATS(mat, s) { \
 int i,j; \
   for(i=0;i<3;i++) \
   for(j=0;j<3;j++) \
     mat.m[i][j] /= s; }
+#endif
 
-#define MULMATMAT(m1, m2, mout) { \
+#ifdef __SSE__
+# define MULMATMAT(m2, m1, mout) { \
+  int i,j; \
+  for (i=0;i<4;i++) { \
+    __m128 a = m1.mtx[0]; \
+    __m128 b = _mm_set1_ps(m2.m[i][0]); \
+    mout.mtx[i] = a*b; \
+    for (j=1;j<4;j++) { \
+      a = m1.mtx[j]; \
+      b = _mm_set1_ps(m2.m[i][j]); \
+      mout.mtx[i] += a*b; } } }
+
+#else
+# define MULMATMAT(m1, m2, mout) { \
 int i,j; \
   for(i=0;i<3;i++) \
   for(j=0;j<3;j++) \
@@ -190,6 +322,7 @@ int i,j; \
       m1.m[i][0] * m2.m[0][j] + \
       m1.m[i][1] * m2.m[1][j] + \
       m1.m[i][2] * m2.m[2][j]; }
+#endif
 
 #define IDMAT(mat) SETMAT(mat, 1,0,0, 0,1,0, 0,0,1)
 

simgear/canvas/elements/CanvasElement.cxx

@@ -640,6 +640,27 @@ namespace canvas
       _scissor->_coord_reference = rf;
   }
 
+    //----------------------------------------------------------------------------
+    void Element::setRotation(unsigned int index, double r)
+    {
+        _node->getChild(NAME_TRANSFORM, index, true)->setDoubleValue("rot", r);
+    }
+
+    //----------------------------------------------------------------------------
+    void Element::setTranslation(unsigned int index, double x, double y)
+    {
+        SGPropertyNode* tf = _node->getChild(NAME_TRANSFORM, index, true);
+        tf->getChild("t", 0, true)->setDoubleValue(x);
+        tf->getChild("t", 1, true)->setDoubleValue(y);
+    }
+
+    //----------------------------------------------------------------------------
+    void Element::setTransformEnabled(unsigned int index, bool enabled)
+    {
+        SGPropertyNode* tf = _node->getChild(NAME_TRANSFORM, index, true);
+        tf->setBoolValue("enabled", enabled);
+    }
+
   //----------------------------------------------------------------------------
   osg::BoundingBox Element::getBoundingBox() const
   {
@@ -701,6 +722,9 @@ namespace canvas
         continue;
 
       SGPropertyNode* tf_node = _node->getChild("tf", i, true);
+      if (!tf_node->getBoolValue("enabled", true)) {
+        continue; // skip disabled transforms
+      }
 
       // Build up the matrix representation of the current transform node
       osg::Matrix tf;

simgear/canvas/elements/CanvasElement.hxx

@@ -172,6 +172,22 @@ namespace canvas
        */
       void setClipFrame(ReferenceFrame rf);
 
+      /**
+       *
+       */
+      void setRotation(unsigned int index, double r);
+
+      /**
+       *
+       */
+      void setTranslation(unsigned int index, double x, double y);
+
+      /**
+       *
+       *
+       */
+      void setTransformEnabled(unsigned int index, bool enabled);
+
       /**
        * Get bounding box (may not be as tight as bounding box returned by
        * #getTightBoundingBox)

simgear/canvas/elements/CanvasGroup.cxx

@@ -373,7 +373,7 @@ namespace canvas
     SG_LOG
     (
       SG_GENERAL,
-      SG_INFO,
+      SG_DEBUG,
       "canvas::Group: Moved element " << index << " to position " << index_new
     );
   }

simgear/canvas/elements/CanvasImage.cxx

@@ -487,11 +487,17 @@ namespace canvas
     if(    !fill.empty() // If no color is given default to white
         && !parseColor(fill, color) )
       return;
-
-    _colors->front() = color;
-    _colors->dirty();
+    setFill(color);
   }
 
+    //----------------------------------------------------------------------------
+    void Image::setFill(const osg::Vec4& color)
+    {
+        _colors->front() = color;
+        _colors->dirty();
+    }
+
+
   //----------------------------------------------------------------------------
   void Image::setOutset(const std::string& outset)
   {
@@ -506,6 +512,13 @@ namespace canvas
     _attributes_dirty |= SRC_RECT;
   }
 
+  //----------------------------------------------------------------------------
+  void Image::setSourceRect(const SGRect<float>& sourceRect)
+  {
+      _attributes_dirty |= SRC_RECT;
+      _src_rect = sourceRect;
+  }
+
   //----------------------------------------------------------------------------
   void Image::setSlice(const std::string& slice)
   {

simgear/canvas/elements/CanvasImage.hxx

@@ -61,6 +61,7 @@ namespace canvas
 
       void setImage(osg::ref_ptr<osg::Image> img);
       void setFill(const std::string& fill);
+      void setFill(const osg::Vec4& color);
 
       /**
        * @see http://www.w3.org/TR/css3-background/#border-image-outset
@@ -95,6 +96,10 @@ namespace canvas
 
       bool handleEvent(const EventPtr& event);
 
+      /**
+       *
+       */
+      void setSourceRect(const SGRect<float>& sourceRect);
     protected:
 
       enum ImageAttributes

simgear/canvas/elements/CanvasPath.cxx

@@ -18,12 +18,14 @@
 
 #include "CanvasPath.hxx"
 #include <simgear/scene/util/parse_color.hxx>
+#include <simgear/misc/strutils.hxx>
 
 #include <osg/Drawable>
 #include <osg/Version>
 
 #include <vg/openvg.h>
 #include <cassert>
+#include <cctype>
 
 namespace simgear
 {
@@ -57,6 +59,153 @@ namespace canvas
    */
   std::vector<float> splitAndConvert(const char del[], const std::string& str);
 
+    static float parseCSSNumber(const std::string& s)
+    {
+        if (strutils::ends_with(s, "px")) {
+            return std::stof(s.substr(0, s.length() - 2));
+        } else if (s.back() == '%') {
+            float f = std::stof(s.substr(0, s.length() - 1));
+            return f / 100.0f;
+        }
+        return std::stof(s);
+    }
+
+    //----------------------------------------------------------------------------
+    static bool parseSVGPathToVGPath(const std::string& svgPath, CmdList& commands, CoordList& coords)
+    {
+        const string_list& tokens = simgear::strutils::split_on_any_of(svgPath, "\t \n\r,");
+        char activeSVGCommand = 0;
+        bool isRelative = false;
+        int tokensNeeded = 0;
+
+        for (auto it = tokens.begin(); it != tokens.end(); ) {
+            // set up the new command data
+            if ((it->size() == 1) && std::isalpha(it->at(0))) {
+                const char svgCommand = std::toupper(it->at(0));
+                isRelative = std::islower(it->at(0));
+                switch (svgCommand) {
+                case 'Z':
+                        tokensNeeded = 0;
+                        break;
+                case 'M':
+                case 'L':
+                case 'T':
+                        tokensNeeded = 2;
+                        break;
+                case 'H':
+                case 'V':
+                        tokensNeeded = 1;
+                        break;
+                case 'C':
+                        tokensNeeded = 6;
+                        break;
+                case 'S':
+                case 'Q':
+                        tokensNeeded = 4;
+                        break;
+                case 'A':
+                        tokensNeeded = 7;
+                        break;
+                default:
+                    SG_LOG(SG_GENERAL, SG_WARN, "unrecognized SVG path command: "
+                           << *it << " at token " <<  std::distance(tokens.begin(), it));
+                    return false;
+                }
+
+                activeSVGCommand = svgCommand;
+                ++it; // advance to first coordinate token
+            }
+
+            const int numTokensRemaining = std::distance(it, tokens.end());
+            if (numTokensRemaining < tokensNeeded) {
+                SG_LOG(SG_GENERAL, SG_WARN, "insufficent SVG path tokens");
+                return false;
+            }
+
+            bool pushTokensDirectly = true;
+            if (activeSVGCommand == 'Z') {
+                commands.push_back(VG_CLOSE_PATH);
+                activeSVGCommand = 0;
+            } else if (activeSVGCommand == 'M') {
+                commands.push_back(VG_MOVE_TO | isRelative);
+                activeSVGCommand = 'L';
+            } else if (activeSVGCommand == 'L') {
+                commands.push_back(VG_LINE_TO | isRelative);
+            } else if (activeSVGCommand == 'H') {
+                commands.push_back(VG_HLINE_TO | isRelative);
+            } else if (activeSVGCommand == 'V') {
+                commands.push_back(VG_HLINE_TO | isRelative);
+            } else if (activeSVGCommand == 'C') {
+                commands.push_back(VG_CUBIC_TO | isRelative);
+            } else if (activeSVGCommand == 'S') {
+                commands.push_back(VG_SCUBIC_TO | isRelative);
+            } else if (activeSVGCommand == 'Q') {
+                commands.push_back(VG_SCUBIC_TO | isRelative);
+            } else if (activeSVGCommand == 'T') {
+                commands.push_back(VG_SCUBIC_TO | isRelative);
+            } else if (activeSVGCommand == 'A') {
+                pushTokensDirectly = false; // deal with tokens manually
+                coords.push_back(parseCSSNumber(*it++)); // rx
+                coords.push_back(parseCSSNumber(*it++)); // ry
+                coords.push_back(parseCSSNumber(*it++)); // x-axis rotation
+
+                const bool isLargeArc = std::stoi(*it++); // large-angle
+                const bool isCCW = std::stoi(*it++); // sweep-flag
+
+                int vgCmd = isLargeArc ? (isCCW ? VG_LCCWARC_TO : VG_LCWARC_TO) :
+                    (isCCW ? VG_SCCWARC_TO : VG_SCWARC_TO);
+
+                coords.push_back(parseCSSNumber(*it++));
+                coords.push_back(parseCSSNumber(*it++));
+                commands.push_back(vgCmd | isRelative);
+            } else {
+                SG_LOG(SG_GENERAL, SG_WARN, "malformed SVG path string: expected a command at token:"
+                       << std::distance(tokens.begin(), it) << " :" << *it);
+                return false;
+            }
+
+            if (pushTokensDirectly) {
+                for (int i=0; i<tokensNeeded;++i) {
+                    coords.push_back(parseCSSNumber(*it++));
+                }
+            }
+        } // of tokens iteration
+
+        return true;
+    }
+
+
+    //---------------------------------------------------------------------------
+
+    static SGVec2f parseRectCornerRadius(SGPropertyNode* node, const std::string& xDir, const std::string& yDir, bool& haveCorner)
+    {
+        haveCorner = false;
+        std::string propName = "border-" + yDir + "-" + xDir + "-radius";
+        if (!node->hasChild(propName)) {
+            propName = "border-" + yDir + "-radius";
+            if (!node->hasChild(propName)) {
+                propName = "border-radius";
+            }
+        }
+
+        PropertyList props = node->getChildren(propName);
+        if (props.size() == 1) {
+            double r = props.at(0)->getDoubleValue(propName);
+            haveCorner = true;
+            return SGVec2f(r, r);
+        }
+
+        if (props.size() >= 2 ) {
+            haveCorner = true;
+            return SGVec2f(props.at(0)->getDoubleValue(),
+                           props.at(1)->getDoubleValue());
+        }
+
+        return SGVec2f(-1.0f, -1.0f);
+    }
+
+    //----------------------------------------------------------------------------
+
   class Path::PathDrawable:
     public osg::Drawable
   {
@@ -533,7 +682,9 @@ namespace canvas
               const Style& parent_style,
               ElementWeakPtr parent ):
     Element(canvas, node, parent_style, parent),
-    _path( new PathDrawable(this) )
+    _path( new PathDrawable(this) ),
+    _hasSVG(false),
+    _hasRect(false)
   {
     staticInit();
 
@@ -561,6 +712,23 @@ namespace canvas
       _attributes_dirty &= ~(CMDS | COORDS);
     }
 
+    // SVG path overrides manual cmd/coord specification
+    if ( _hasSVG && (_attributes_dirty & SVG))
+    {
+        CmdList cmds;
+        CoordList coords;
+        parseSVGPathToVGPath(_node->getStringValue("svg"), cmds, coords);
+        _path->setSegments(cmds, coords);
+        _attributes_dirty &= ~SVG;
+    }
+
+    if ( _hasRect &&(_attributes_dirty & RECT))
+    {
+        parseRectToVGPath();
+        _attributes_dirty &= ~RECT;
+
+    }
+
     Element::update(dt);
   }
 
@@ -630,16 +798,75 @@ namespace canvas
     childChanged(child);
   }
 
+  //----------------------------------------------------------------------------
+  void Path::setSVGPath(const std::string& svgPath)
+  {
+    _node->setStringValue("svg", svgPath);
+    _hasSVG = true;
+    _attributes_dirty |= SVG;
+  }
+
+  //----------------------------------------------------------------------------
+  void Path::setRect(const SGRect<float> &r)
+  {
+    _rect = r;
+    _hasRect = true;
+    _attributes_dirty |= RECT;
+  }
+
+  //----------------------------------------------------------------------------
+  void Path::setRoundRect(const SGRect<float> &r, float radiusX, float radiusY)
+  {
+    if (radiusY < 0.0) {
+        radiusY = radiusX;
+    }
+
+    setRect(r);
+    _node->getChild("border-radius", 0, true)->setDoubleValue(radiusX);
+    _node->getChild("border-radius", 1, true)->setDoubleValue(radiusY);
+  }
+
   //----------------------------------------------------------------------------
   void Path::childChanged(SGPropertyNode* child)
   {
+      const std::string& name = child->getNameString();
+      const std::string &prName = child->getParent()->getNameString();
+
+      if (simgear::strutils::starts_with(name, "border-"))
+      {
+          _attributes_dirty |= RECT;
+          return;
+      }
+
+      if (prName == "rect") {
+          _hasRect = true;
+          if (name == "left") {
+              _rect.setLeft(child->getDoubleValue());
+          } else if (name == "top") {
+              _rect.setTop(child->getDoubleValue());
+          } else if (name == "right") {
+              _rect.setRight(child->getDoubleValue());
+          } else if (name == "bottom") {
+              _rect.setBottom(child->getDoubleValue());
+          } else if (name == "width") {
+              _rect.setWidth(child->getDoubleValue());
+          } else if (name == "height") {
+              _rect.setHeight(child->getDoubleValue());
+          }
+          _attributes_dirty |= RECT;
+          return;
+      }
+
     if( child->getParent() != _node )
       return;
 
-    if( child->getNameString() == "cmd" )
+    if( name == "cmd" )
       _attributes_dirty |= CMDS;
-    else if( child->getNameString() == "coord" )
+    else if( name == "coord" )
       _attributes_dirty |= COORDS;
+    else if ( name == "svg")
+      _hasSVG = true;
+      _attributes_dirty |= SVG;
   }
 
   //----------------------------------------------------------------------------
@@ -664,5 +891,67 @@ namespace canvas
     return values;
   }
 
+    //----------------------------------------------------------------------------
+
+    void operator+=(CoordList& base, const std::initializer_list<VGfloat>& other)
+    {
+        base.insert(base.end(), other.begin(), other.end());
+    }
+
+    void Path::parseRectToVGPath()
+    {
+        CmdList commands;
+        CoordList coords;
+        commands.reserve(4);
+        coords.reserve(8);
+
+        bool haveCorner = false;
+        SGVec2f topLeft = parseRectCornerRadius(_node, "left", "top", haveCorner);
+        if (haveCorner) {
+            commands.push_back(VG_MOVE_TO_ABS);
+            coords += {_rect.l(), _rect.t() + topLeft.y()};
+            commands.push_back(VG_SCCWARC_TO_REL);
+            coords += {topLeft.x(), topLeft.y(), 0.0, topLeft.x(), -topLeft.y()};
+        } else {
+            commands.push_back(VG_MOVE_TO_ABS);
+            coords += {_rect.l(), _rect.t()};
+        }
+
+        SGVec2f topRight = parseRectCornerRadius(_node, "right", "top", haveCorner);
+        if (haveCorner) {
+            commands.push_back(VG_HLINE_TO_ABS);
+            coords += {_rect.r() - topRight.x()};
+            commands.push_back(VG_SCCWARC_TO_REL);
+            coords += {topRight.x(), topRight.y(), 0.0, topRight.x(), topRight.y()};
+        } else {
+            commands.push_back(VG_HLINE_TO_ABS);
+            coords += {_rect.r()};
+        }
+
+        SGVec2f bottomRight = parseRectCornerRadius(_node, "right", "bottom", haveCorner);
+        if (haveCorner) {
+            commands.push_back(VG_VLINE_TO_ABS);
+            coords += {_rect.b() - bottomRight.y()};
+            commands.push_back(VG_SCCWARC_TO_REL);
+            coords += {bottomRight.x(), bottomRight.y(), 0.0, -bottomRight.x(), bottomRight.y()};
+        } else {
+            commands.push_back(VG_VLINE_TO_ABS);
+            coords += {_rect.b()};
+        }
+
+        SGVec2f bottomLeft = parseRectCornerRadius(_node, "left", "bottom", haveCorner);
+        if (haveCorner) {
+            commands.push_back(VG_HLINE_TO_ABS);
+            coords += {_rect.l() + bottomLeft.x()};
+            commands.push_back(VG_SCCWARC_TO_REL);
+            coords += {bottomLeft.x(), bottomLeft.y(), 0.0, -bottomLeft.x(), -bottomLeft.y()};
+        } else {
+            commands.push_back(VG_HLINE_TO_ABS);
+            coords += {_rect.l()};
+        }
+
+        commands.push_back(VG_CLOSE_PATH);
+        _path->setSegments(commands, coords);
+    }
 } // namespace canvas
 } // namespace simgear

simgear/canvas/elements/CanvasPath.hxx

@@ -21,6 +21,7 @@
 
 #include "CanvasElement.hxx"
 #include <boost/preprocessor/iteration/iterate.hpp>
+#include <simgear/math/SGRect.hxx>
 
 namespace simgear
 {
@@ -67,18 +68,30 @@ namespace canvas
       /** Close the path (implicit lineTo to first point of path) */
       Path& close();
 
+      void setSVGPath(const std::string& svgPath);
+
+      void setRect(const SGRect<float>& r);
+      void setRoundRect(const SGRect<float>& r, float radiusX, float radiusY = -1.0);
     protected:
 
       enum PathAttributes
       {
         CMDS       = LAST_ATTRIBUTE << 1,
-        COORDS     = CMDS << 1
+        COORDS     = CMDS << 1,
+        SVG        = COORDS << 1,
+        RECT       = SVG << 1
       };
 
       class PathDrawable;
       typedef osg::ref_ptr<PathDrawable> PathDrawableRef;
       PathDrawableRef _path;
 
+      bool _hasSVG : 1;
+      bool _hasRect : 1;
+      SGRect<float> _rect;
+
+      void parseRectToVGPath();
+      
       virtual void childRemoved(SGPropertyNode * child);
       virtual void childChanged(SGPropertyNode * child);
   };

simgear/compiler.h

@@ -40,96 +40,40 @@
 #define SG_DO_STRINGIZE(X) #X
 
 #ifdef __GNUC__
-#  if __GNUC__ < 3
-#    error Time to upgrade. GNU compilers < 3.0 not supported
-#  elif (__GNUC__ == 3) && (__GNUC_MINOR__ < 4)
-#    warning GCC compilers prior to 3.4 are suspect  
-#  endif
-
 #  define SG_GCC_VERSION (__GNUC__ * 10000 \
                      + __GNUC_MINOR__ * 100 \
                      + __GNUC_PATCHLEVEL__)
 #  define SG_COMPILER_STR "GNU C++ version " SG_STRINGIZE(__GNUC__) "." SG_STRINGIZE(__GNUC_MINOR__)
 #endif // __GNUC__
 
-/* KAI C++ */
-#if defined(__KCC)
-#  define SG_COMPILER_STR "Kai C++ version " SG_STRINGIZE(__KCC_VERSION)
-#endif // __KCC
-
 //
 // Microsoft compilers.
 //
 #ifdef _MSC_VER
-#  define bcopy(from, to, n) memcpy(to, from, n)
+#  define strcasecmp stricmp
 
-#  if _MSC_VER >= 1200  // msvc++ 6.0 or greater
-#    define isnan _isnan
-#    define snprintf _snprintf
-#    if _MSC_VER < 1500
-#      define vsnprintf _vsnprintf
+#  if _MSC_VER >= 1200 // msvc++ 6.0 up to MSVC2013
+#    if _MSC_VER < 1900
+#      define bcopy(from, to, n) memcpy(to, from, n)
+#      define snprintf _snprintf
+#      define strdup _strdup
+#      define copysign _copysign
 #    endif
-#    define copysign _copysign
-#    define strcasecmp stricmp
-
-#    undef min
-#    undef max
 
 #    pragma warning(disable: 4786) // identifier was truncated to '255' characters
 #    pragma warning(disable: 4244) // conversion from double to float
-#    pragma warning(disable: 4305) //
+#    pragma warning(disable: 4305) // truncation from larger type to smaller
+#    pragma warning(disable: 4267) // conversion from size_t to int / 32-bit type
+#    pragma warning(disable: 4996) // don't require _ prefix for standard library functions
+#    pragma warning(disable: 4800) // don't warn about int -> bool performance
 
 #  else
 #    error What version of MSVC++ is this?
 #  endif
-
-#    define SG_COMPILER_STR "Microsoft Visual C++ version " SG_STRINGIZE(_MSC_VER)
+#  define SG_COMPILER_STR "Microsoft Visual C++ version " SG_STRINGIZE(_MSC_VER)
 
 #endif // _MSC_VER
 
-//
-// Native SGI compilers
-//
-
-#if defined ( sgi ) && !defined( __GNUC__ )
-# if (_COMPILER_VERSION < 740)
-#  error Need MipsPro 7.4.0 or higher now
-# endif
-
-#define SG_HAVE_NATIVE_SGI_COMPILERS
-
-#pragma set woff 1001,1012,1014,1116,1155,1172,1174
-#pragma set woff 1401,1460,1551,1552,1681
-
-#ifdef __cplusplus
-# pragma set woff 1682,3303
-# pragma set woff 3624
-#endif
-
-#  define SG_COMPILER_STR "SGI MipsPro compiler version " SG_STRINGIZE(_COMPILER_VERSION)
-
-#endif // Native SGI compilers
-
-
-#if defined (__sun)
-#  define SG_UNIX
-#  include <strings.h>
-#  include <memory.h>
-#  if defined ( __cplusplus )
-     // typedef unsigned int size_t;
-     extern "C" {
-       extern void *memmove(void *, const void *, size_t);
-     }
-#  else
-     extern void *memmove(void *, const void *, size_t);
-#  endif // __cplusplus
-
-#  if  !defined( __GNUC__ )
-#   define SG_COMPILER_STR "Sun compiler version " SG_STRINGIZE(__SUNPRO_CC)
-#  endif
-
-#endif // sun
-
 //
 // Intel C++ Compiler
 //
@@ -144,29 +88,10 @@
 #ifdef __APPLE__
 #  define SG_MAC
 #  define SG_UNIX
-#  ifdef __GNUC__
-#    if ( __GNUC__ > 3 ) || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 3 )
-inline int (isnan)(double r) { return !(r <= 0 || r >= 0); }
-#    else
-    // any C++ header file undefines isinf and isnan
-    // so this should be included before <iostream>
-    // the functions are STILL in libm (libSystem on mac os x)
-extern "C" int (isnan)(double);
-extern "C" int (isinf)(double);
-#    endif
-#  else
-inline int (isnan)(double r) { return !(r <= 0 || r >= 0); }
-#  endif
 #endif
 
 #if defined (__FreeBSD__)
 #  define SG_UNIX
-#include <sys/param.h>
-#  if __FreeBSD_version < 500000
-     extern "C" {
-       inline int isnan(double r) { return !(r <= 0 || r >= 0); }
-     }
-#  endif
 #endif
 
 #if defined (__CYGWIN__)
@@ -201,4 +126,3 @@ inline int (isnan)(double r) { return !(r <= 0 || r >= 0); }
 //
 
 #endif // _SG_COMPILER_H
-

simgear/constants.h

@@ -211,8 +211,10 @@ const float SG_RADIANS_TO_DEGREES = 180.0f / SG_PI;
 /** for backwards compatibility */
 #define SG_SCENERY_FILE_FORMAT "0.4"
 
-/** Default range in m at which all objects are displayed.  Overridden by /sim/rendering/static-lod/rough **/
-#define SG_OBJECT_RANGE     9000.0
+/** Default object ranges.  Overridden by /sim/rendering/static-lod/[bare|rough|detailed] **/
+#define SG_OBJECT_RANGE_BARE     30000.0
+#define SG_OBJECT_RANGE_ROUGH     9000.0
+#define SG_OBJECT_RANGE_DETAILED  1500.0
 
 /** Radius of scenery tiles in m **/
 #define SG_TILE_RADIUS      14000.0

simgear/debug/BufferedLogCallback.hxx

@@ -24,7 +24,7 @@
 #define SG_DEBUG_BUFFEREDLOGCALLBACK_HXX
 
 #include <vector>
-#include <memory> // for std::auto_ptr
+#include <memory> // for std::unique_ptr
 
 #include <simgear/debug/logstream.hxx>
 
@@ -70,10 +70,10 @@ public:
     unsigned int threadsafeCopy(vector_cstring& aOutput);
 private:
     class BufferedLogCallbackPrivate;
-    std::auto_ptr<BufferedLogCallbackPrivate> d;
+    std::unique_ptr<BufferedLogCallbackPrivate> d;
 };
      
 
 } // of namespace simgear
 
-#endif // of SG_DEBUG_BUFFEREDLOGCALLBACK_HXX
+#endif // of SG_DEBUG_BUFFEREDLOGCALLBACK_HXX

simgear/debug/debug_types.h

@@ -42,14 +42,22 @@ typedef enum {
 
 /**
  * Define the possible logging priorities (and their order).
+ *
+ * Caution - unfortunately, this enum is exposed to Nasal via the logprint()
+ * function as an integer parameter. Therefore, new values should only be
+ * appended, or the priority Nasal reports to compiled code will change.
  */
 typedef enum {
     SG_BULK = 1,       // For frequent messages
     SG_DEBUG,          // Less frequent debug type messages
     SG_INFO,           // Informatory messages
     SG_WARN,           // Possible impending problem
-    SG_ALERT           // Very possible impending problem
+    SG_ALERT,          // Very possible impending problem
+    SG_POPUP,          // Severe enough to alert using a pop-up window
     // SG_EXIT,        // Problem (no core)
     // SG_ABORT        // Abandon ship (core)
+
+    SG_DEV_WARN,       // Warning for developers, translated to other priority
+    SG_DEV_ALERT       // Alert for developers, translated
 } sgDebugPriority;
 

simgear/debug/logstream.cxx

@@ -36,11 +36,14 @@
 #include <simgear/threads/SGQueue.hxx>
 #include <simgear/threads/SGGuard.hxx>
 
+#include <simgear/io/iostreams/sgstream.hxx>
 #include <simgear/misc/sg_path.hxx>
 
-#ifdef SG_WINDOWS
+#if defined (SG_WINDOWS)
 // for AllocConsole, OutputDebugString
-    #include "windows.h"
+    #include <windows.h>
+    #include <fcntl.h>
+    #include <io.h>
 #endif
 
 const char* debugClassToString(sgDebugClass c)
@@ -106,13 +109,13 @@ void LogCallback::setLogLevels( sgDebugClass c, sgDebugPriority p )
 class FileLogCallback : public simgear::LogCallback
 {
 public:
-    FileLogCallback(const std::string& aPath, sgDebugClass c, sgDebugPriority p) :
-	    simgear::LogCallback(c, p),
-        m_file(aPath.c_str(), std::ios_base::out | std::ios_base::trunc)
+    FileLogCallback(const SGPath& aPath, sgDebugClass c, sgDebugPriority p) :
+	    simgear::LogCallback(c, p)
     {
+        m_file.open(aPath, std::ios_base::out | std::ios_base::trunc);
     }
-    
-    virtual void operator()(sgDebugClass c, sgDebugPriority p, 
+
+    virtual void operator()(sgDebugClass c, sgDebugPriority p,
         const char* file, int line, const std::string& message)
     {
         if (!shouldLog(c, p)) return;
@@ -120,28 +123,29 @@ public:
             << ":" << file << ":" << line << ":" << message << std::endl;
     }
 private:
-    std::ofstream m_file;   
+    sg_ofstream m_file;
 };
-   
+
 class StderrLogCallback : public simgear::LogCallback
 {
 public:
     StderrLogCallback(sgDebugClass c, sgDebugPriority p) :
 		simgear::LogCallback(c, p)
     {
-#ifdef SG_WINDOWS
-        AllocConsole(); // but only if we want a console
-        freopen("conin$", "r", stdin);
-        freopen("conout$", "w", stdout);
-        freopen("conout$", "w", stderr);
-#endif
     }
-    
-    virtual void operator()(sgDebugClass c, sgDebugPriority p, 
+
+#if defined (SG_WINDOWS)
+    ~StderrLogCallback()
+    {
+        FreeConsole();
+    }
+#endif
+
+    virtual void operator()(sgDebugClass c, sgDebugPriority p,
         const char* file, int line, const std::string& aMessage)
     {
         if (!shouldLog(c, p)) return;
-        
+
         fprintf(stderr, "%s\n", aMessage.c_str());
         //fprintf(stderr, "%s:%d:%s:%d:%s\n", debugClassToString(c), p,
         //    file, line, aMessage.c_str());
@@ -159,12 +163,12 @@ public:
 		simgear::LogCallback(c, p)
     {
     }
-    
-    virtual void operator()(sgDebugClass c, sgDebugPriority p, 
+
+    virtual void operator()(sgDebugClass c, sgDebugPriority p,
         const char* file, int line, const std::string& aMessage)
     {
         if (!shouldLog(c, p)) return;
-        
+
         std::ostringstream os;
 		os << debugClassToString(c) << ":" << aMessage << std::endl;
 		OutputDebugStringA(os.str().c_str());
@@ -177,9 +181,9 @@ class LogStreamPrivate : public SGThread
 {
 private:
     /**
-     * storage of a single log entry. Note this is not used for a persistent
-     * store, but rather for short term buffering between the submitting
-     * and output threads.
+     * storage of a single log entry. This is used to pass log entries from
+     * the various threads to the logging thread, and also to store the startup
+     * entries
      */
     class LogEntry
     {
@@ -188,24 +192,29 @@ private:
             const char* f, int l, const std::string& msg) :
             debugClass(c), debugPriority(p), file(f), line(l),
                 message(msg)
-        {   
+        {
         }
-        
-        sgDebugClass debugClass;
-        sgDebugPriority debugPriority;
+
+        const sgDebugClass debugClass;
+        const sgDebugPriority debugPriority;
         const char* file;
-        int line;
-        std::string message;
+        const int line;
+        const std::string message;
     };
-    
+
+    /**
+     * RAII object to pause the logging thread if it's running, and restart it.
+     * used to safely make configuration changes.
+     */
     class PauseThread
     {
     public:
-        PauseThread(LogStreamPrivate* parent) : m_parent(parent)
+        PauseThread(LogStreamPrivate* parent)
+            : m_parent(parent)
+            , m_wasRunning(m_parent->stop())
         {
-            m_wasRunning = m_parent->stop();
         }
-        
+
         ~PauseThread()
         {
             if (m_wasRunning) {
@@ -214,42 +223,144 @@ private:
         }
     private:
         LogStreamPrivate* m_parent;
-        bool m_wasRunning;
+        const bool m_wasRunning;
     };
+
 public:
     LogStreamPrivate() :
-        m_logClass(SG_ALL), 
-        m_logPriority(SG_ALERT),
-        m_isRunning(false),
-		m_consoleRequested(false)
-    { 
+        m_logClass(SG_ALL),
+        m_logPriority(SG_ALERT)
+    {
+#if defined (SG_WINDOWS)
+        /*
+         * 2016-09-20(RJH) - Reworked console handling
+         * 1) When started from the console use the console (when no --console)
+         * 2) When started from the GUI (with --console) open a new console window
+         * 3) When started from the GUI (without --console) don't open a new console
+         *    window; stdout/stderr will not appear (except in logfiles as they do now)
+         * 4) When started from the Console (with --console) open a new console window
+         * 5) Ensure that IO redirection still works when started from the console
+         * 
+         * Notes:
+         * 1) fgfs needs to be a GUI subsystem app - which it already is
+         * 2) What can't be done is to make the cmd prompt run fgfs synchronously; 
+         * this is only something that can be done via "start /wait fgfs".
+         */
 
-#if !defined(SG_WINDOWS)
-        m_callbacks.push_back(new StderrLogCallback(m_logClass, m_logPriority));
-		m_consoleCallbacks.push_back(m_callbacks.back());
-		m_consoleRequested = true;
+        int stderr_handle_type = GetFileType(GetStdHandle(STD_ERROR_HANDLE));
+        int stdout_handle_type = GetFileType(GetStdHandle(STD_OUTPUT_HANDLE));
+        int stdout_isNull = 0;
+        int stderr_isNull = 0;
+
+        m_stderr_isRedirectedAlready = stderr_handle_type == FILE_TYPE_DISK || stderr_handle_type == FILE_TYPE_PIPE || stderr_handle_type == FILE_TYPE_CHAR;
+        m_stdout_isRedirectedAlready = stdout_handle_type == FILE_TYPE_DISK || stdout_handle_type == FILE_TYPE_PIPE || stdout_handle_type == FILE_TYPE_CHAR;
+
+        /*
+         * We don't want to attach to the console if either stream has been redirected - so in this case ensure that both streams
+         * are redirected as otherwise something will be lost (as Alloc or Attach Console will cause the handles that were bound
+         * to disappear)
+         */
+        if (m_stdout_isRedirectedAlready){
+			if (!m_stderr_isRedirectedAlready) {
+				MessageBox(0, "Redirection only works when you use 2>&1 before using > or |\r\n(e.g. fgfs 2>&1 | more)", "Simgear Error", MB_OK | MB_ICONERROR);
+				exit(3);
+			}
+        } else {
+            /*
+            * Attempt to attach to the console process of the parent process; when launched from cmd.exe this should be the console, 
+            * when launched via the RUN menu explorer, or another GUI app that wasn't started from the console this will fail.
+            * When it fails we will redirect to the NUL device. This is to ensure that we have valid streams.
+            * Later on in the initialisation sequence the --console option will be processed and this will cause the requestConsole() to
+            * always open a new console, except for streams that are redirected. The same rules apply there, if both streams are redirected
+            * the console will be opened, and it will contain a message to indicate that no output will be present because the streams are redirected
+            */
+            if (AttachConsole(ATTACH_PARENT_PROCESS) == 0) {
+                /*
+                * attach failed - so ensure that the streams are bound to the null device - but only when not already redirected
+                */
+                if (!m_stdout_isRedirectedAlready)
+                {
+                    stdout_isNull = true;
+                    freopen("NUL", "w", stdout);
+                }
+
+                if (!m_stderr_isRedirectedAlready)
+                {
+                    stderr_isNull = true;
+                    freopen("NUL", "w", stderr);
+                }
+            }
+            /*
+            * providing that AttachConsole succeeded - we can then either reopen the stream onto the console, or use
+            * _fdopen to attached to the currently redirected (and open stream)
+            */
+            if (!stdout_isNull){
+                if (!m_stdout_isRedirectedAlready)
+                    freopen("conout$", "w", stdout);
+                else 
+                    /*
+                    * for already redirected streams we need to attach the stream to the OS handle that is open.
+                    * - this comes from part of the answer http://stackoverflow.com/a/13841522
+                    *   _open_osfhandle returns an FD for the Win32 Handle, which is then opened using fdopen and
+                    *   hopefully safely assigned to the stream (although it does look wrong to me it works)
+                    * Removing this bit will stop pipes and command line redirection (> 2> and 2>&1 from working)
+                    */
+                    *stdout = *_fdopen(_open_osfhandle((intptr_t) GetStdHandle(STD_OUTPUT_HANDLE), _O_WRONLY), "a");
+            }
+
+            if (!stderr_isNull){
+                if (!m_stderr_isRedirectedAlready)
+                    freopen("conout$", "w", stderr);
+                else
+                    *stderr = *_fdopen(_open_osfhandle((intptr_t) GetStdHandle(STD_ERROR_HANDLE), _O_WRONLY), "a");
+            }
+        }
+        //http://stackoverflow.com/a/25927081
+        //Clear the error state for each of the C++ standard stream objects. 
+        std::wcout.clear();
+        std::cout.clear();
+        std::wcerr.clear();
+        std::cerr.clear();
 #endif
 
+        m_callbacks.push_back(new StderrLogCallback(m_logClass, m_logPriority));
+        m_consoleCallbacks.push_back(m_callbacks.back());
 #if defined (SG_WINDOWS) && !defined(NDEBUG)
 		m_callbacks.push_back(new WinDebugLogCallback(m_logClass, m_logPriority));
 		m_consoleCallbacks.push_back(m_callbacks.back());
 #endif
     }
-                    
+
+    ~LogStreamPrivate()
+    {
+        for (simgear::LogCallback* cb : m_callbacks) {
+            delete cb;
+        }
+    }
+
     SGMutex m_lock;
     SGBlockingQueue<LogEntry> m_entries;
-    
+
+    // log entries posted during startup
+    std::vector<LogEntry> m_startupEntries;
+    bool m_startupLogging = false;
+
     typedef std::vector<simgear::LogCallback*> CallbackVec;
-    CallbackVec m_callbacks;    
+    CallbackVec m_callbacks;
     /// subset of callbacks which correspond to stdout / console,
 	/// and hence should dynamically reflect console logging settings
 	CallbackVec m_consoleCallbacks;
 
     sgDebugClass m_logClass;
     sgDebugPriority m_logPriority;
-    bool m_isRunning;
-	bool m_consoleRequested;
-    
+    bool m_isRunning = false;
+#if defined (SG_WINDOWS)
+    // track whether the console was redirected on launch (in the constructor, which is called early on)
+    bool m_stderr_isRedirectedAlready = false;
+    bool m_stdout_isRedirectedAlready = false;
+#endif
+    bool m_developerMode = false;
+
     void startLog()
     {
         SGGuard<SGMutex> g(m_lock);
@@ -257,7 +368,17 @@ public:
         m_isRunning = true;
         start();
     }
-    
+
+    void setStartupLoggingEnabled(bool on)
+    {
+        if (m_startupLogging == on) {
+            return;
+        }
+
+        m_startupLogging = on;
+        m_startupEntries.clear();
+    }
+
     virtual void run()
     {
         while (1) {
@@ -267,37 +388,50 @@ public:
             if ((entry.debugClass == SG_NONE) && !strcmp(entry.file, "done")) {
                 return;
             }
-            
+
+            if (m_startupLogging) {
+                // save to the startup list for not-yet-added callbacks to
+                // pull down on startup
+                m_startupEntries.push_back(entry);
+            }
+
             // submit to each installed callback in turn
-            BOOST_FOREACH(simgear::LogCallback* cb, m_callbacks) {
+            for (simgear::LogCallback* cb : m_callbacks) {
                 (*cb)(entry.debugClass, entry.debugPriority,
                     entry.file, entry.line, entry.message);
-            }           
+            }
         } // of main thread loop
     }
-    
+
     bool stop()
     {
         SGGuard<SGMutex> g(m_lock);
         if (!m_isRunning) {
             return false;
         }
-        
+
         // log a special marker value, which will cause the thread to wakeup,
         // and then exit
         log(SG_NONE, SG_ALERT, "done", -1, "");
         join();
-        
+
         m_isRunning = false;
         return true;
     }
-    
+
     void addCallback(simgear::LogCallback* cb)
     {
         PauseThread pause(this);
         m_callbacks.push_back(cb);
+
+        // we clear startup entries not using this, so always safe to run
+        // this code, container will simply be empty
+        for (auto entry : m_startupEntries) {
+            (*cb)(entry.debugClass, entry.debugPriority,
+               entry.file, entry.line, entry.message);
+        }
     }
-    
+
     void removeCallback(simgear::LogCallback* cb)
     {
         PauseThread pause(this);
@@ -306,7 +440,7 @@ public:
             m_callbacks.erase(it);
         }
     }
-    
+
     void setLogLevels( sgDebugClass c, sgDebugPriority p )
     {
         PauseThread pause(this);
@@ -316,37 +450,41 @@ public:
 	        cb->setLogLevels(c, p);
 		}
     }
-    
+
     bool would_log( sgDebugClass c, sgDebugPriority p ) const
     {
+        p = translatePriority(p);
         if (p >= SG_INFO) return true;
         return ((c & m_logClass) != 0 && p >= m_logPriority);
     }
-    
+
     void log( sgDebugClass c, sgDebugPriority p,
             const char* fileName, int line, const std::string& msg)
     {
+        p = translatePriority(p);
         LogEntry entry(c, p, fileName, line, msg);
         m_entries.push(entry);
     }
 
-	void requestConsole()
-	{
-		PauseThread pause(this);
-		if (m_consoleRequested) {
-			return;
-		}
+    sgDebugPriority translatePriority(sgDebugPriority in) const
+    {
+        if (in == SG_DEV_WARN) {
+            return m_developerMode ? SG_WARN : SG_DEBUG;
+        }
 
-		m_consoleRequested = true;
-		m_callbacks.push_back(new StderrLogCallback(m_logClass, m_logPriority));
-		m_consoleCallbacks.push_back(m_callbacks.back());
-	}
+        if (in == SG_DEV_ALERT) {
+            return m_developerMode ? SG_POPUP : SG_WARN;
+        }
+
+        return in;
+    }
 };
 
 /////////////////////////////////////////////////////////////////////////////
 
 static logstream* global_logstream = NULL;
 static LogStreamPrivate* global_privateLogstream = NULL;
+static SGMutex global_logStreamLock;
 
 logstream::logstream()
 {
@@ -354,21 +492,34 @@ logstream::logstream()
     global_privateLogstream->startLog();
 }
 
+logstream::~logstream()
+{
+    popup_msgs.clear();
+    global_privateLogstream->stop();
+    delete global_privateLogstream;
+}
+
 void
 logstream::setLogLevels( sgDebugClass c, sgDebugPriority p )
 {
     global_privateLogstream->setLogLevels(c, p);
 }
 
+void logstream::setDeveloperMode(bool devMode)
+{
+    global_privateLogstream->m_developerMode = devMode;
+}
+
+
 void
 logstream::addCallback(simgear::LogCallback* cb)
-{   
+{
     global_privateLogstream->addCallback(cb);
 }
 
 void
 logstream::removeCallback(simgear::LogCallback* cb)
-{   
+{
     global_privateLogstream->removeCallback(cb);
 }
 
@@ -379,6 +530,30 @@ logstream::log( sgDebugClass c, sgDebugPriority p,
     global_privateLogstream->log(c, p, fileName, line, msg);
 }
 
+void
+logstream::popup( const std::string& msg)
+{
+    popup_msgs.push_back(msg);
+}
+
+std::string
+logstream::get_popup()
+{
+    std::string rv = "";
+    if (!popup_msgs.empty())
+    {
+        rv = popup_msgs.front();
+        popup_msgs.erase(popup_msgs.begin());
+    }
+    return rv;
+}
+
+bool
+logstream::has_popup()
+{
+    return (popup_msgs.size() > 0) ? true : false;
+}
+
 bool
 logstream::would_log( sgDebugClass c, sgDebugPriority p ) const
 {
@@ -390,7 +565,7 @@ logstream::get_log_classes() const
 {
     return global_privateLogstream->m_logClass;
 }
-    
+
 sgDebugPriority
 logstream::get_log_priority() const
 {
@@ -402,25 +577,25 @@ logstream::set_log_priority( sgDebugPriority p)
 {
     global_privateLogstream->setLogLevels(global_privateLogstream->m_logClass, p);
 }
-    
+
 void
 logstream::set_log_classes( sgDebugClass c)
 {
     global_privateLogstream->setLogLevels(c, global_privateLogstream->m_logPriority);
 }
 
+
 logstream&
 sglog()
 {
     // Force initialization of cerr.
     static std::ios_base::Init initializer;
-    
+
     // http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf
     // in the absence of portable memory barrier ops in Simgear,
     // let's keep this correct & safe
-    static SGMutex m;
-    SGGuard<SGMutex> g(m);
-    
+    SGGuard<SGMutex> g(global_logStreamLock);
+
     if( !global_logstream )
         global_logstream = new logstream();
     return *global_logstream;
@@ -429,16 +604,64 @@ sglog()
 void
 logstream::logToFile( const SGPath& aPath, sgDebugClass c, sgDebugPriority p )
 {
-    global_privateLogstream->addCallback(new FileLogCallback(aPath.str(), c, p));
+    global_privateLogstream->addCallback(new FileLogCallback(aPath, c, p));
+}
+
+void logstream::setStartupLoggingEnabled(bool enabled)
+{
+    global_privateLogstream->setStartupLoggingEnabled(enabled);
 }
 
 namespace simgear
 {
 
 void requestConsole()
+{ 
+#if defined (SG_WINDOWS)
+   /*
+    * 2016-09-20(RJH) - Reworked console handling
+    * This is part of the reworked console handling for Win32. This is for building as a Win32 GUI Subsystem where no
+    * console is allocated on launch. If building as a console app then the startup will ensure that a console is created - but
+    * we don't need to handle that.
+    * The new handling is quite simple:
+    *              1. The constructor will ensure that these streams exists. It will attach to the
+    *                 parent command prompt if started from the command prompt, otherwise the
+    *                 stdout/stderr will be bound to the NUL device.
+    *              2. with --console a window will always appear regardless of where the process was
+    *                 started from. Any non redirected streams will be redirected 
+    *              3. You cannot use --console and either redirected stream.
+    *
+    * This is called after the Private Log Stream constructor so we need to undo any console that it has attached to.
+    */
+
+    if (!global_privateLogstream->m_stderr_isRedirectedAlready && !global_privateLogstream->m_stdout_isRedirectedAlready) {
+        FreeConsole();
+        if (AllocConsole()) {
+            if (!global_privateLogstream->m_stdout_isRedirectedAlready)
+                freopen("conout$", "w", stdout);
+
+            if (!global_privateLogstream->m_stderr_isRedirectedAlready)
+                freopen("conout$", "w", stderr);
+
+            //http://stackoverflow.com/a/25927081
+            //Clear the error state for each of the C++ standard stream objects. 
+            std::wcout.clear();
+            std::cout.clear();
+            std::wcerr.clear();
+            std::cerr.clear();
+        }
+    } else {
+        MessageBox(0, "--console ignored because stdout or stderr redirected with > or 2>", "Simgear Error", MB_OK | MB_ICONERROR);
+    }
+#endif
+}
+
+
+void shutdownLogging()
 {
-	sglog(); // force creation
-	global_privateLogstream->requestConsole();
+    SGGuard<SGMutex> g(global_logStreamLock);
+    delete global_logstream;
+    global_logstream = 0;
 }
 
 } // of namespace simgear

simgear/debug/logstream.hxx

@@ -29,6 +29,7 @@
 #include <simgear/debug/debug_types.h>
 
 #include <sstream>
+#include <vector>
  
 // forward decls
 class SGPath;
@@ -59,7 +60,9 @@ private:
  * moment - on other plaforms it's a no-op
  */
 void requestConsole();
-     
+
+void shutdownLogging();
+
 } // of namespace simgear
 
 /**
@@ -68,6 +71,8 @@ void requestConsole();
 class logstream
 {
 public:
+    ~logstream();
+    
     static void initGlobalLogstream();
     /**
      * Set the global log class and priority level.
@@ -88,12 +93,36 @@ public:
     
     sgDebugPriority get_log_priority() const;
 
+    /**
+     * set developer mode on/off. In developer mode, SG_DEV_WARN messags
+     * are treated as warnings. In normal (non-developer) mode they are
+     * treated as SG_DEBUG.
+     */
+    void setDeveloperMode(bool devMode);
+
     /**
      * the core logging method
      */
     void log( sgDebugClass c, sgDebugPriority p,
             const char* fileName, int line, const std::string& msg);
 
+    /**
+     * support for the SG_POPUP logging class
+     * set the content of the popup message
+     */
+    void popup( const std::string& msg);
+
+    /**
+     * retrieve the contents of the popup message and clear it's internal
+     * content. The return value may be an empty string.
+     */
+    std::string get_popup();
+
+    /**
+     * return true if a new popup message is available. false otherwise.
+     */
+    bool has_popup();
+
    /**
     * \relates logstream
     * Return the one and only logstream instance.
@@ -112,9 +141,17 @@ public:
      
     void removeCallback(simgear::LogCallback* cb);
 
+    /**
+     * optionally record all entries and submit them to new log callbacks that
+     * are added. This allows simplified logging configuration, but still including
+     * early startup information in all logs.
+     */
+    void setStartupLoggingEnabled(bool enabled);
 private:
     // constructor
     logstream();
+
+    std::vector<std::string> popup_msgs;
 };
 
 logstream& sglog();
@@ -127,16 +164,16 @@ logstream& sglog();
  * @param P priority
  * @param M message
  */
-#ifdef FG_NDEBUG
-# define SG_LOG(C,P,M)
-#else
-# define SG_LOG(C,P,M) do {                     \
-	if(sglog().would_log(C,P)) {                      \
-        std::ostringstream os;                             \
-        os << M;                                       \
+# define SG_LOGX(C,P,M) \
+    do { if(sglog().would_log(C,P)) {                         \
+        std::ostringstream os; os << M;                  \
         sglog().log(C, P, __FILE__, __LINE__, os.str()); \
-    } \
-} while(0)
+        if (P == SG_POPUP) sglog().popup(os.str());      \
+    } } while(0)
+#ifdef FG_NDEBUG
+# define SG_LOG(C,P,M)	do { if(P == SG_POPUP) SG_LOGX(C,P,M) } while(0)
+#else
+# define SG_LOG(C,P,M)	SG_LOGX(C,P,M)
 #endif
 
 #define SG_ORIGIN __FILE__ ":" SG_STRINGIZE(__LINE__)

simgear/environment/metar.cxx

@@ -648,10 +648,11 @@ bool SGMetar::scanWeather()
 	weather = pre + weather + post;
 	weather.erase(weather.length() - 1);
 	_weather.push_back(weather);
-    if( ! w.phenomena.empty() )
+    if( ! w.phenomena.empty() ) {
         _weather2.push_back( w );
-	_grpcount++;
-	return true;
+    }
+    _grpcount++;
+    return true;
 }
 
 

simgear/environment/test_metar.cxx

@@ -4,6 +4,7 @@
 #endif
 
 #include <simgear/compiler.h>
+#include <simgear/misc/test_macros.hxx>
 
 #include <iostream>
 #include <cstdlib>
@@ -23,75 +24,56 @@ using std::cerr;
 using std::endl;
 using std::string;
 
-#define COMPARE(a, b) \
-    if ((a) != (b))  { \
-        cerr << "failed:" << #a << " != " << #b << endl; \
-        cerr << "\tgot:" << a << endl; \
-        exit(1); \
-    }
-
-#define FUZZY_COMPARE(a, b, epsilon) \
-    if (fabs(a - b) > epsilon) { \
-        cerr << "failed:" << #a << " != " << #b << endl; \
-        cerr << "\tgot:" << a << endl; \
-        cerr << "\tepsilon:" << epsilon << endl; \
-    }
-
-#define VERIFY(a) \
-    if (!(a))  { \
-        cerr << "failed:" << #a << endl; \
-        exit(1); \
-    }
 
 const double TEST_EPSILON = 1e-9;
 
 void test_basic()
 {
     SGMetar m1("2011/10/20 11:25 EHAM 201125Z 27012KT 240V300 9999 VCSH FEW025CB SCT048 10/05 Q1025 TEMPO VRB03KT");
-    COMPARE(m1.getYear(), 2011);
-    COMPARE(m1.getMonth(), 10);
-    COMPARE(m1.getDay(), 20);
-    COMPARE(m1.getHour(), 11);
-    COMPARE(m1.getMinute(), 25);
-    COMPARE(m1.getReportType(), -1); // should default to NIL?
-    
-    COMPARE(m1.getWindDir(), 270);
-    FUZZY_COMPARE(m1.getWindSpeed_kt(), 12, TEST_EPSILON);
-    
-    COMPARE(m1.getWeather().size(), 1);
-    COMPARE(m1.getClouds().size(), 2);
+    SG_CHECK_EQUAL(m1.getYear(), 2011);
+    SG_CHECK_EQUAL(m1.getMonth(), 10);
+    SG_CHECK_EQUAL(m1.getDay(), 20);
+    SG_CHECK_EQUAL(m1.getHour(), 11);
+    SG_CHECK_EQUAL(m1.getMinute(), 25);
+    SG_CHECK_EQUAL(m1.getReportType(), -1); // should default to NIL?
 
-    FUZZY_COMPARE(m1.getTemperature_C(), 10, TEST_EPSILON);
-    FUZZY_COMPARE(m1.getDewpoint_C(), 5, TEST_EPSILON);
-    FUZZY_COMPARE(m1.getPressure_hPa(), 1025, TEST_EPSILON);
+    SG_CHECK_EQUAL(m1.getWindDir(), 270);
+    SG_CHECK_EQUAL_EP2(m1.getWindSpeed_kt(), 12, TEST_EPSILON);
+
+    SG_CHECK_EQUAL(m1.getWeather().size(), 1);
+    SG_CHECK_EQUAL(m1.getClouds().size(), 2);
+
+    SG_CHECK_EQUAL_EP2(m1.getTemperature_C(), 10, TEST_EPSILON);
+    SG_CHECK_EQUAL_EP2(m1.getDewpoint_C(), 5, TEST_EPSILON);
+    SG_CHECK_EQUAL_EP2(m1.getPressure_hPa(), 1025, TEST_EPSILON);
 }
 
 void test_sensor_failure_weather()
 {
     SGMetar m1("2011/10/20 11:25 EHAM 201125Z 27012KT 240V300 9999 // FEW025CB SCT048 10/05 Q1025");
-    COMPARE(m1.getWindDir(), 270);
-    FUZZY_COMPARE(m1.getWindSpeed_kt(), 12, TEST_EPSILON);
+    SG_CHECK_EQUAL(m1.getWindDir(), 270);
+    SG_CHECK_EQUAL_EP2(m1.getWindSpeed_kt(), 12, TEST_EPSILON);
 
-    COMPARE(m1.getWeather().size(), 0);
-    COMPARE(m1.getClouds().size(), 2);
+    SG_CHECK_EQUAL(m1.getWeather().size(), 0);
+    SG_CHECK_EQUAL(m1.getClouds().size(), 2);
 
-    FUZZY_COMPARE(m1.getTemperature_C(), 10, TEST_EPSILON);
-    FUZZY_COMPARE(m1.getDewpoint_C(), 5, TEST_EPSILON);
-    FUZZY_COMPARE(m1.getPressure_hPa(), 1025, TEST_EPSILON);
+    SG_CHECK_EQUAL_EP2(m1.getTemperature_C(), 10, TEST_EPSILON);
+    SG_CHECK_EQUAL_EP2(m1.getDewpoint_C(), 5, TEST_EPSILON);
+    SG_CHECK_EQUAL_EP2(m1.getPressure_hPa(), 1025, TEST_EPSILON);
 }
 
 void test_sensor_failure_cloud()
 {
     SGMetar m1("2011/10/20 11:25 EHAM 201125Z 27012KT 240V300 9999 FEW025CB/// SCT048/// 10/05 Q1025");
-    COMPARE(m1.getWindDir(), 270);
-    FUZZY_COMPARE(m1.getWindSpeed_kt(), 12, TEST_EPSILON);
+    SG_CHECK_EQUAL(m1.getWindDir(), 270);
+    SG_CHECK_EQUAL_EP2(m1.getWindSpeed_kt(), 12, TEST_EPSILON);
 
-    COMPARE(m1.getWeather().size(), 0);
-    COMPARE(m1.getClouds().size(), 2);
+    SG_CHECK_EQUAL(m1.getWeather().size(), 0);
+    SG_CHECK_EQUAL(m1.getClouds().size(), 2);
 
-    FUZZY_COMPARE(m1.getTemperature_C(), 10, TEST_EPSILON);
-    FUZZY_COMPARE(m1.getDewpoint_C(), 5, TEST_EPSILON);
-    FUZZY_COMPARE(m1.getPressure_hPa(), 1025, TEST_EPSILON);
+    SG_CHECK_EQUAL_EP2(m1.getTemperature_C(), 10, TEST_EPSILON);
+    SG_CHECK_EQUAL_EP2(m1.getDewpoint_C(), 5, TEST_EPSILON);
+    SG_CHECK_EQUAL_EP2(m1.getPressure_hPa(), 1025, TEST_EPSILON);
 }
 
 int main(int argc, char* argv[])

simgear/ephemeris/celestialBody.cxx

@@ -52,7 +52,8 @@
 void CelestialBody::updatePosition(double mjd, Star *ourSun)
 {
   double eccAnom, v, ecl, actTime, 
-    xv, yv, xh, yh, zh, xg, yg, zg, xe, ye, ze;
+    xv, yv, xh, yh, zh, xg, yg, zg, xe, ye, ze,
+    cosN, sinN, cosvw, sinvw, sinvw_cosi, cosecl, sinecl;
 
   updateOrbElements(mjd);
   actTime = sgCalcActTime(mjd);
@@ -66,10 +67,19 @@ void CelestialBody::updatePosition(double mjd, Star *ourSun)
   v = atan2(yv, xv);           // the planet's true anomaly
   r = sqrt (xv*xv + yv*yv);    // the planet's distance
   
+  // repetitive calculations, minimised for speed
+  cosN = cos(N);
+  sinN = sin(N);
+  cosvw = cos(v+w);
+  sinvw = sin(v+w);
+  sinvw_cosi = sinvw * cos(i);
+  cosecl = cos(ecl);
+  sinecl = sin(ecl);
+
   // calculate the planet's position in 3D space
-  xh = r * (cos(N) * cos(v+w) - sin(N) * sin(v+w) * cos(i));
-  yh = r * (sin(N) * cos(v+w) + cos(N) * sin(v+w) * cos(i));
-  zh = r * (sin(v+w) * sin(i));
+  xh = r * (cosN * cosvw - sinN * sinvw_cosi);
+  yh = r * (sinN * cosvw + cosN * sinvw_cosi);
+  zh = r * (sinvw * sin(i));
 
   // calculate the ecliptic longitude and latitude
   xg = xh + ourSun->getxs();
@@ -80,8 +90,8 @@ void CelestialBody::updatePosition(double mjd, Star *ourSun)
   latEcl = atan2(zh, sqrt(xh*xh+yh*yh));
 
   xe = xg;
-  ye = yg * cos(ecl) - zg * sin(ecl);
-  ze = yg * sin(ecl) + zg * cos(ecl);
+  ye = yg * cosecl - zg * sinecl;
+  ze = yg * sinecl + zg * cosecl;
   rightAscension = atan2(ye, xe);
   declination = atan2(ze, sqrt(xe*xe + ye*ye));
   /* SG_LOG(SG_GENERAL, SG_INFO, "Planet found at : " 

simgear/ephemeris/moonpos.cxx

@@ -26,6 +26,7 @@
 #include <string.h>
 
 #include <simgear/debug/logstream.hxx>
+#include <simgear/math/SGMath.hxx>
 
 #include <math.h>
 
@@ -78,69 +79,90 @@ void MoonPos::updatePosition(double mjd, double lst, double lat, Star *ourSun)
 {
   double 
     eccAnom, ecl, actTime,
-    xv, yv, v, r, xh, yh, zh, xg, yg, zg, xe, ye, ze,
+    xv, yv, v, r, xh, yh, zh, zg, xe,
     Ls, Lm, D, F, mpar, gclat, rho, HA, g,
-    geoRa, geoDec;
+    geoRa, geoDec,
+    cosN, sinN, cosvw, sinvw, sinvw_cosi, cosecl, sinecl, rcoslatEcl,
+    FlesstwoD, MlesstwoD, twoD, twoM, twolat, alpha;
   
+  double max_loglux = -0.504030345621;
+  double min_loglux = -4.39964634562;
+  double conv = 1.0319696543787917;    // The log foot-candle to log lux conversion factor.
   updateOrbElements(mjd);
   actTime = sgCalcActTime(mjd);
 
   // calculate the angle between ecliptic and equatorial coordinate system
   // in Radians
-  ecl = ((SGD_DEGREES_TO_RADIANS * 23.4393) - (SGD_DEGREES_TO_RADIANS * 3.563E-7) * actTime);  
+  ecl = SGD_DEGREES_TO_RADIANS * (23.4393 - 3.563E-7 * actTime);
   eccAnom = sgCalcEccAnom(M, e);  // Calculate the eccentric anomaly
   xv = a * (cos(eccAnom) - e);
   yv = a * (sqrt(1.0 - e*e) * sin(eccAnom));
   v = atan2(yv, xv);               // the moon's true anomaly
   r = sqrt (xv*xv + yv*yv);       // and its distance
   
+  // repetitive calculations, minimised for speed
+  cosN = cos(N);
+  sinN = sin(N);
+  cosvw = cos(v+w);
+  sinvw = sin(v+w);
+  sinvw_cosi = sinvw * cos(i);
+  cosecl = cos(ecl);
+  sinecl = sin(ecl);
+
   // estimate the geocentric rectangular coordinates here
-  xh = r * (cos(N) * cos (v+w) - sin (N) * sin(v+w) * cos(i));
-  yh = r * (sin(N) * cos (v+w) + cos (N) * sin(v+w) * cos(i));
-  zh = r * (sin(v+w) * sin(i));
+  xh = r * (cosN * cosvw - sinN * sinvw_cosi);
+  yh = r * (sinN * cosvw + cosN * sinvw_cosi);
+  zh = r * (sinvw * sin(i));
 
   // calculate the ecliptic latitude and longitude here
   lonEcl = atan2 (yh, xh);
   latEcl = atan2(zh, sqrt(xh*xh + yh*yh));
 
-  /* Calculate a number of perturbatioin, i.e. disturbances caused by the 
-   * gravitational infuence of the sun and the other major planets.
+  /* Calculate a number of perturbation, i.e. disturbances caused by the 
+   * gravitational influence of the sun and the other major planets.
    * The largest of these even have a name */
   Ls = ourSun->getM() + ourSun->getw();
   Lm = M + w + N;
   D = Lm - Ls;
   F = Lm - N;
+
+  twoD = 2 * D;
+  twoM = 2 * M;
+  FlesstwoD = F - twoD;
+  MlesstwoD = M - twoD;
   
-  lonEcl += SGD_DEGREES_TO_RADIANS * (-1.274 * sin (M - 2*D)
-			  +0.658 * sin (2*D)
+  lonEcl += SGD_DEGREES_TO_RADIANS * (-1.274 * sin(MlesstwoD)
+			  +0.658 * sin(twoD)
 			  -0.186 * sin(ourSun->getM())
-			  -0.059 * sin(2*M - 2*D)
-			  -0.057 * sin(M - 2*D + ourSun->getM())
-			  +0.053 * sin(M + 2*D)
-			  +0.046 * sin(2*D - ourSun->getM())
+			  -0.059 * sin(twoM - twoD)
+			  -0.057 * sin(MlesstwoD + ourSun->getM())
+			  +0.053 * sin(M + twoD)
+			  +0.046 * sin(twoD - ourSun->getM())
 			  +0.041 * sin(M - ourSun->getM())
 			  -0.035 * sin(D)
 			  -0.031 * sin(M + ourSun->getM())
-			  -0.015 * sin(2*F - 2*D)
+			  -0.015 * sin(2*F - twoD)
 			  +0.011 * sin(M - 4*D)
 			  );
-  latEcl += SGD_DEGREES_TO_RADIANS * (-0.173 * sin(F-2*D)
-			  -0.055 * sin(M - F - 2*D)
-			  -0.046 * sin(M + F - 2*D)
-			  +0.033 * sin(F + 2*D)
-			  +0.017 * sin(2*M + F)
+  latEcl += SGD_DEGREES_TO_RADIANS * (-0.173 * sin(FlesstwoD)
+			  -0.055 * sin(M - FlesstwoD)
+			  -0.046 * sin(M + FlesstwoD)
+			  +0.033 * sin(F + twoD)
+			  +0.017 * sin(twoM + F)
 			  );
-  r += (-0.58 * cos(M - 2*D)
-	-0.46 * cos(2*D)
+  r += (-0.58 * cos(MlesstwoD)
+	-0.46 * cos(twoD)
 	);
+  distance = r;
   // SG_LOG(SG_GENERAL, SG_INFO, "Running moon update");
-  xg = r * cos(lonEcl) * cos(latEcl);
-  yg = r * sin(lonEcl) * cos(latEcl);
+  rcoslatEcl = r * cos(latEcl);
+  xg =     cos(lonEcl) * rcoslatEcl;
+  yg =     sin(lonEcl) * rcoslatEcl;
   zg = r *               sin(latEcl);
   
   xe = xg;
-  ye = yg * cos(ecl) -zg * sin(ecl);
-  ze = yg * sin(ecl) +zg * cos(ecl);
+  ye = yg * cosecl -zg * sinecl;
+  ze = yg * sinecl +zg * cosecl;
 
   geoRa  = atan2(ye, xe);
   geoDec = atan2(ze, sqrt(xe*xe + ye*ye));
@@ -154,17 +176,17 @@ void MoonPos::updatePosition(double mjd, double lst, double lat, Star *ourSun)
   // topocentric ra and dec. i.e. the position as seen from the
   // surface of the earth, instead of the center of the earth
 
-  // First calculate the moon's parrallax, that is, the apparent size of the 
+  // First calculate the moon's parallax, that is, the apparent size of the 
   // (equatorial) radius of the earth, as seen from the moon 
   mpar = asin ( 1 / r);
   // SG_LOG( SG_GENERAL, SG_INFO, "r = " << r << " mpar = " << mpar );
   // SG_LOG( SG_GENERAL, SG_INFO, "lat = " << f->get_Latitude() );
 
-  gclat = lat - 0.003358 * 
-      sin (2 * SGD_DEGREES_TO_RADIANS * lat );
+  twolat = 2 * SGD_DEGREES_TO_RADIANS * lat;
+  gclat = lat - 0.003358 * sin(twolat);
   // SG_LOG( SG_GENERAL, SG_INFO, "gclat = " << gclat );
 
-  rho = 0.99883 + 0.00167 * cos(2 * SGD_DEGREES_TO_RADIANS * lat);
+  rho = 0.99883 + 0.00167 * cos(twolat);
   // SG_LOG( SG_GENERAL, SG_INFO, "rho = " << rho );
   
   if (geoRa < 0)
@@ -193,4 +215,22 @@ void MoonPos::updatePosition(double mjd, double lst, double lat, Star *ourSun)
   /* SG_LOG( SG_GENERAL, SG_INFO, 
 	  "Ra = (" << (SGD_RADIANS_TO_DEGREES *rightAscension) 
 	  << "), Dec= (" << (SGD_RADIANS_TO_DEGREES *declination) << ")" ); */
+
+  // Moon age and phase calculation
+  age = lonEcl - ourSun->getlonEcl();
+  phase = (1 - cos(age)) / 2;
+
+  // The log of the illuminance of the moon outside the atmosphere.
+  // This is the base 10 log of equation 20 from Krisciunas K. and Schaefer B.E.
+  // (1991). A model of the brightness of moonlight, Publ. Astron. Soc. Pacif.
+  // 103(667), 1033-1039 (DOI: http://dx.doi.org/10.1086/132921).
+  alpha = SGD_RADIANS_TO_DEGREES * SGMiscd::normalizeAngle(age + SGMiscd::pi());
+  log_I = -0.4 * (3.84 + 0.026*fabs(alpha) + 4e-9*pow(alpha, 4.0));
+
+  // Convert from foot-candles to lux.
+  log_I += conv;
+
+  // The moon's illuminance factor, bracketed between 0 and 1.
+  I_factor = (log_I - max_loglux) / (max_loglux - min_loglux) + 1.0;
+  I_factor = SGMiscd::clip(I_factor, 0, 1);
 }

simgear/ephemeris/moonpos.hxx

@@ -36,6 +36,13 @@ class MoonPos : public CelestialBody
 
 private:
 
+    double xg, yg;     // the moon's rectangular geocentric coordinates
+    double ye, ze;     // the moon's rectangular equatorial coordinates
+    double distance;   // the moon's distance to the earth
+    double age;        // the moon's age from 0 to 2pi
+    double phase;      // the moon's phase
+    double log_I;      // the moon's illuminance outside the atmosphere (logged)
+    double I_factor;   // the illuminance factor for the moon, between 0 and 1.
     // void TexInit();  // This should move to the constructor eventually.
 
     // GLUquadricObj *moonObject;
@@ -54,7 +61,72 @@ public:
     ~MoonPos();
     void updatePosition(double mjd, double lst, double lat, Star *ourSun);
     // void newImage();
+    double getM() const;
+    double getw() const;
+    double getxg() const;
+    double getyg() const;
+    double getye() const;
+    double getze() const;
+    double getDistance() const;
+    double getAge() const;
+    double getPhase() const;
+    double getLogIlluminance() const;
+    double getIlluminanceFactor() const;
 };
 
+inline double MoonPos::getM() const
+{
+  return M;
+}
+
+inline double MoonPos::getw() const
+{
+  return w;
+}
+
+inline double MoonPos::getxg() const
+{
+  return xg;
+}
+
+inline double MoonPos::getyg() const
+{
+  return yg;
+}
+
+inline double MoonPos::getye() const
+{
+   return ye;
+}
+
+inline double MoonPos::getze() const
+{
+   return ze;
+}
+
+inline double MoonPos::getDistance() const
+{
+  return distance;
+}
+
+inline double MoonPos::getAge() const
+{
+  return age;
+}
+
+inline double MoonPos::getPhase() const
+{
+  return phase;
+}
+
+inline double MoonPos::getLogIlluminance() const
+{
+  return log_I;
+}
+
+inline double MoonPos::getIlluminanceFactor() const
+{
+  return I_factor;
+}
 
 #endif // _MOONPOS_HXX_

simgear/ephemeris/star.hxx

@@ -33,6 +33,7 @@ class Star : public CelestialBody
 
 private:
 
+    double lonEcl;     // the sun's true longitude
     double xs, ys;     // the sun's rectangular geocentric coordinates
     double ye, ze;     // the sun's rectangularequatorial rectangular geocentric coordinates
     double distance;   // the sun's distance to the earth
@@ -50,6 +51,7 @@ public:
     double getye() const;
     double getze() const;
     double getDistance() const;
+    double getlonEcl() const;
 };
 
 
@@ -88,6 +90,10 @@ inline double Star::getDistance() const
   return distance;
 }
 
+inline double Star::getlonEcl() const
+{
+  return lonEcl;
+}
 
 #endif // _STAR_HXX_
 

simgear/ephemeris/stardata.cxx

@@ -26,7 +26,7 @@
 
 #include <simgear/debug/logstream.hxx>
 #include <simgear/misc/sg_path.hxx>
-#include <simgear/misc/sgstream.hxx>
+#include <simgear/io/iostreams/sgstream.hxx>
 
 #include "stardata.hxx"
 
@@ -55,12 +55,11 @@ bool SGStarData::load( const SGPath& path ) {
     // build the full path name to the stars data base file
     SGPath tmp = path;
     tmp.append( "stars" );
-    SG_LOG( SG_ASTRO, SG_INFO, "  Loading stars from " << tmp.str() );
+    SG_LOG( SG_ASTRO, SG_INFO, "  Loading stars from " << tmp );
 
-    sg_gzifstream in( tmp.str() );
+    sg_gzifstream in( tmp );
     if ( ! in.is_open() ) {
-	SG_LOG( SG_ASTRO, SG_ALERT, "Cannot open star file: "
-		<< tmp.str() );
+	SG_LOG( SG_ASTRO, SG_ALERT, "Cannot open star file: " << tmp );
         return false;
     }
 

simgear/hla/HLAFederate.cxx

@@ -26,6 +26,7 @@
 #include <algorithm>
 
 #include "simgear/debug/logstream.hxx"
+#include "simgear/misc/sg_path.hxx"
 
 #include "RTIFederate.hxx"
 #include "RTIFederateFactoryRegistry.hxx"
@@ -798,7 +799,7 @@ HLAFederate::readRTI1516ObjectModelTemplate(const std::string& objectModel)
     // This one covers the generic attributes, parameters and data types.
     HLAOMTXmlVisitor omtXmlVisitor;
     try {
-        readXML(objectModel, omtXmlVisitor);
+        readXML(SGPath(objectModel), omtXmlVisitor);
     } catch (const sg_throwable& e) {
         SG_LOG(SG_IO, SG_ALERT, "Could not open HLA XML object model file: "
                << e.getMessage());

simgear/hla/RTI13Ambassador.hxx

@@ -117,7 +117,7 @@ public:
     // bool unconditionalAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
     // {
     //     try {
-    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         std::unique_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
     //             attributeHandleSet->add(*i);
     //         _rtiAmbassador.unconditionalAttributeOwnershipDivestiture(objectHandle, *attributeHandleSet);
@@ -136,7 +136,7 @@ public:
     // bool negotiatedAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles, const RTIData& tag)
     // {
     //     try {
-    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         std::unique_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
     //             attributeHandleSet->add(*i);
     //         _rtiAmbassador.negotiatedAttributeOwnershipDivestiture(objectHandle, *attributeHandleSet, tag.data());
@@ -156,7 +156,7 @@ public:
     // bool attributeOwnershipAcquisition(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles, const RTIData& tag)
     // {
     //     try {
-    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         std::unique_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
     //             attributeHandleSet->add(*i);
     //         _rtiAmbassador.attributeOwnershipAcquisition(objectHandle, *attributeHandleSet, tag.data());
@@ -177,7 +177,7 @@ public:
     // bool attributeOwnershipAcquisitionIfAvailable(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
     // {
     //     try {
-    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         std::unique_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
     //             attributeHandleSet->add(*i);
     //         _rtiAmbassador.attributeOwnershipAcquisitionIfAvailable(objectHandle, *attributeHandleSet);
@@ -199,7 +199,7 @@ public:
     // RTIHandleSet attributeOwnershipReleaseResponse(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
     // {
     //     try {
-    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         std::unique_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
     //             attributeHandleSet->add(*i);
     //         attributeHandleSet.reset(_rtiAmbassador.attributeOwnershipReleaseResponse(objectHandle, *attributeHandleSet));
@@ -223,7 +223,7 @@ public:
     // bool cancelNegotiatedAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
     // {
     //     try {
-    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         std::unique_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
     //             attributeHandleSet->add(*i);
     //         _rtiAmbassador.cancelNegotiatedAttributeOwnershipDivestiture(objectHandle, *attributeHandleSet);
@@ -243,7 +243,7 @@ public:
     // bool cancelAttributeOwnershipAcquisition(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
     // {
     //     try {
-    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         std::unique_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
     //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
     //             attributeHandleSet->add(*i);
     //         _rtiAmbassador.cancelAttributeOwnershipAcquisition(objectHandle, *attributeHandleSet);

simgear/hla/RTI13ObjectClass.cxx

@@ -101,7 +101,7 @@ RTI13ObjectClass::publish(const HLAIndexList& indexList)
 
     try {
         unsigned numAttributes = getNumAttributes();
-        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
+        std::unique_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
         for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
             if (_attributeHandleVector.size() <= *i) {
                 SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectClass::publish(): Invalid attribute index!");
@@ -195,7 +195,7 @@ RTI13ObjectClass::subscribe(const HLAIndexList& indexList, bool active)
 
     try {
         unsigned numAttributes = getNumAttributes();
-        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
+        std::unique_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
         for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
             if (_attributeHandleVector.size() <= *i) {
                 SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectClass::subscribe(): Invalid attribute index!");

simgear/hla/RTI13ObjectInstance.cxx

@@ -243,7 +243,7 @@ RTI13ObjectInstance::requestObjectAttributeValueUpdate(const HLAIndexList& index
 
     try {
         unsigned numAttributes = getNumAttributes();
-        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
+        std::unique_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
         for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
             if (getAttributeOwned(*i)) {
                 SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectInstance::requestObjectAttributeValueUpdate(): "

simgear/hla/RTI13ObjectInstance.hxx

@@ -101,7 +101,7 @@ private:
     SGSharedPtr<RTI13Ambassador> _ambassador;
 
     // cached storage for updates
-    std::auto_ptr<RTI::AttributeHandleValuePairSet> _attributeValuePairSet;
+    std::unique_ptr<RTI::AttributeHandleValuePairSet> _attributeValuePairSet;
 };
 
 }

simgear/io/AbstractRepository.cxx

@@ -1,34 +0,0 @@
-// AbstractRepository.cxx -- abstract API for TerraSync remote
-//
-// Copyright (C) 2016  James Turner <zakalawe@mac.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-#include "AbstractRepository.hxx"
-
-namespace simgear
-{
-
-AbstractRepository::~AbstractRepository()
-{
-
-}
-
-size_t AbstractRepository::bytesStillToDownload() const
-{
-    return 0;
-}
-
-} // of namespace simgear

simgear/io/AbstractRepository.hxx

@@ -1,72 +0,0 @@
-// AbstractRepository.hxx - API for terrasyc to access remote server
-//
-// Copyright (C) 2016  James Turner <zakalawe@mac.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-
-#ifndef SG_IO_ABSTRACT_REPOSITORY_HXX
-#define SG_IO_ABSTRACT_REPOSITORY_HXX
-
-#include <string>
-
-#include <simgear/misc/sg_path.hxx>
-
-namespace simgear  {
-
-  namespace HTTP {
-    class Client;
-  }
-
-class AbstractRepository
-{
-public:
-
-    virtual ~AbstractRepository();
-
-    virtual SGPath fsBase() const = 0;
-
-    virtual void setBaseUrl(const std::string& url) =0;
-    virtual std::string baseUrl() const = 0;;
-
-    virtual HTTP::Client* http() const = 0;
-
-    virtual void update() = 0;
-
-    virtual bool isDoingSync() const = 0;
-
-    virtual size_t bytesStillToDownload() const;
-
-    enum ResultCode {
-        REPO_NO_ERROR = 0,
-        REPO_ERROR_NOT_FOUND,
-        REPO_ERROR_SOCKET,
-        SVN_ERROR_XML,
-        SVN_ERROR_TXDELTA,
-        REPO_ERROR_IO,
-        REPO_ERROR_CHECKSUM,
-        REPO_ERROR_FILE_NOT_FOUND,
-        REPO_ERROR_HTTP,
-        REPO_PARTIAL_UPDATE
-    };
-
-    virtual ResultCode failure() const = 0;
-  protected:
-
-};
-
-} // of namespace simgear
-
-#endif // of SG_IO_ABSTRACT_REPOSITORY_HXX

simgear/io/CMakeLists.txt

@@ -1,4 +1,4 @@
-
+add_subdirectory(iostreams)
 
 include (SimGearComponent)
 
@@ -18,12 +18,8 @@ set(HEADERS
     HTTPFileRequest.hxx
     HTTPMemoryRequest.hxx
     HTTPRequest.hxx
-    AbstractRepository.hxx
-    DAVMultiStatus.hxx
-    SVNRepository.hxx
-    SVNDirectory.hxx
-    SVNReportParser.hxx
     HTTPRepository.hxx
+    untar.hxx
     )
 
 set(SOURCES
@@ -42,12 +38,8 @@ set(SOURCES
     HTTPFileRequest.cxx
     HTTPMemoryRequest.cxx
     HTTPRequest.cxx
-    AbstractRepository.cxx
-    DAVMultiStatus.cxx
-    SVNRepository.cxx
-    SVNDirectory.cxx
-    SVNReportParser.cxx
     HTTPRepository.cxx
+    untar.cxx
     )
 
 if(ENABLE_DNS)
@@ -59,9 +51,6 @@ simgear_component(io io "${SOURCES}" "${HEADERS}")
 
 if(ENABLE_TESTS)
 
-add_executable(http_svn http_svn.cxx)
-target_link_libraries(http_svn ${TEST_LIBS})
-
 add_executable(test_sock socktest.cxx)
 target_link_libraries(test_sock ${TEST_LIBS})
 
@@ -94,4 +83,12 @@ add_executable(test_repository test_repository.cxx)
 target_link_libraries(test_repository ${TEST_LIBS})
 add_test(http_repository ${EXECUTABLE_OUTPUT_PATH}/test_repository)
 
+add_executable(test_untar test_untar.cxx)
+
+set_target_properties(test_untar PROPERTIES
+  COMPILE_DEFINITIONS "SRC_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}\"" )
+
+target_link_libraries(test_untar ${TEST_LIBS})
+add_test(untar ${EXECUTABLE_OUTPUT_PATH}/test_untar)
+
 endif(ENABLE_TESTS)

simgear/io/DAVMultiStatus.cxx

@@ -1,402 +0,0 @@
-// DAVMultiStatus.cxx -- parser for WebDAV MultiStatus XML data
-//
-// Copyright (C) 2012  James Turner <zakalawe@mac.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-#ifdef HAVE_CONFIG_H
-#  include <simgear_config.h>
-#endif
-     
-#include "DAVMultiStatus.hxx"
-
-#include <iostream>
-#include <cstring>
-#include <cassert>
-#include <algorithm>
-#include <sstream>
-
-#include <boost/foreach.hpp>
-
-#include "simgear/debug/logstream.hxx"
-#include "simgear/misc/strutils.hxx"
-#include "simgear/structure/exception.hxx"
-
-#ifdef SYSTEM_EXPAT
-#  include <expat.h>
-#else
-#  include "sg_expat.h"     
-#endif
-
-using std::string;
-
-using namespace simgear;
-
-#define DAV_NS "DAV::"
-#define SUBVERSION_DAV_NS "http://subversion.tigris.org/xmlns/dav/"
-
-const char* DAV_MULTISTATUS_TAG = DAV_NS "multistatus";
-const char* DAV_RESPONSE_TAG = DAV_NS "response";
-const char* DAV_PROPSTAT_TAG = DAV_NS "propstat";
-const char* DAV_PROP_TAG = DAV_NS "prop";
-
-const char* DAV_HREF_TAG = DAV_NS "href";
-const char* DAV_RESOURCE_TYPE_TAG = DAV_NS "resourcetype";
-const char* DAV_CONTENT_TYPE_TAG = DAV_NS "getcontenttype";
-const char* DAV_CONTENT_LENGTH_TAG = DAV_NS "getcontentlength";
-const char* DAV_VERSIONNAME_TAG = DAV_NS "version-name";
-const char* DAV_COLLECTION_TAG = DAV_NS "collection";
-const char* DAV_VCC_TAG = DAV_NS "version-controlled-configuration";
-
-const char* SUBVERSION_MD5_CHECKSUM_TAG = SUBVERSION_DAV_NS ":md5-checksum";
-
-DAVResource::DAVResource(const string& href) :
-  _type(Unknown),
-  _url(href),
-  _container(NULL)
-{
-    assert(!href.empty());
-    if (strutils::ends_with(href, "/")) {
-        _url = href.substr(0, _url.size() - 1);
-    }
-}
-
-void DAVResource::setVersionName(const std::string& aVersion)
-{
-  _versionName = aVersion;
-}
-
-void DAVResource::setVersionControlledConfiguration(const std::string& vcc)
-{
-    _vcc = vcc;
-}
-
-void DAVResource::setMD5(const std::string& md5Hex)
-{
-    _md5 = md5Hex;
-}
-
-std::string DAVResource::name() const
-{
-    string::size_type index = _url.rfind('/');
-    if (index != string::npos) {
-        return _url.substr(index + 1);
-    }
-    
-    throw sg_exception("bad DAV resource HREF:" + _url);
-}
-
-////////////////////////////////////////////////////////////////////////////
-
-DAVCollection::DAVCollection(const string& href) :
-  DAVResource(href)
-{
-  _type = DAVResource::Collection;
-}
-
-DAVCollection::~DAVCollection()
-{
-  BOOST_FOREACH(DAVResource* c, _contents) {
-    delete c;
-  }
-}
-
-void DAVCollection::addChild(DAVResource *res)
-{
-  assert(res);
-  if (res->container() == this) {
-    return;
-  }
-  
-  assert(res->container() == NULL);
-  assert(std::find(_contents.begin(), _contents.end(), res) == _contents.end());
-  assert(strutils::starts_with(res->url(), _url));
-  assert(childWithUrl(res->url()) == NULL);
-  
-  res->_container = this;
-  _contents.push_back(res);
-}
-
-void DAVCollection::removeChild(DAVResource* res)
-{
-  assert(res);
-  assert(res->container() == this);
-  
-  res->_container = NULL;
-  DAVResourceList::iterator it = std::find(_contents.begin(), _contents.end(), res);
-  assert(it != _contents.end());
-  _contents.erase(it);
-}
-
-DAVCollection*
-DAVCollection::createChildCollection(const std::string& name)
-{
-    DAVCollection* child = new DAVCollection(urlForChildWithName(name));
-    addChild(child);
-    return child;
-}
-
-DAVResourceList DAVCollection::contents() const
-{
-  return _contents;
-}
-
-DAVResource* DAVCollection::childWithUrl(const string& url) const
-{
-  if (url.empty())
-    return NULL;
-  
-  BOOST_FOREACH(DAVResource* c, _contents) {
-    if (c->url() == url) {
-      return c;
-    }
-  }
-  
-  return NULL;
-}
-
-DAVResource* DAVCollection::childWithName(const string& name) const
-{
-  return childWithUrl(urlForChildWithName(name));
-}
-
-std::string DAVCollection::urlForChildWithName(const std::string& name) const
-{
-  return url() + "/" + name;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-class DAVMultiStatus::DAVMultiStatusPrivate
-{
-public:
-  DAVMultiStatusPrivate() :
-      parserInited(false),
-      valid(false)
-  {
-    rootResource = NULL;
-  }
-  
-  void startElement (const char * name)
-  {
-    if (tagStack.empty()) {
-      if (strcmp(name, DAV_MULTISTATUS_TAG)) {
-        SG_LOG(SG_TERRASYNC, SG_WARN, "root element is not " <<
-               DAV_MULTISTATUS_TAG << ", got:" << name);
-      } else {
-        
-      }
-    } else {
-      // not at the root element
-      if (tagStack.back() == DAV_MULTISTATUS_TAG) {
-        if (strcmp(name, DAV_RESPONSE_TAG)) {
-          SG_LOG(SG_TERRASYNC, SG_WARN, "multistatus child is not response: saw:"
-                 << name);
-        }
-      }
-      
-      if (tagStack.back() == DAV_RESOURCE_TYPE_TAG) {
-        if (!strcmp(name, DAV_COLLECTION_TAG)) {
-          currentElementType = DAVResource::Collection;
-        } else {
-          currentElementType = DAVResource::Unknown;
-        }
-      }
-    }
-    
-    tagStack.push_back(name);
-    if (!strcmp(name, DAV_RESPONSE_TAG)) {
-      currentElementType = DAVResource::Unknown;
-      currentElementUrl.clear();
-      currentElementMD5.clear();
-      currentVersionName.clear();
-      currentVCC.clear();
-    }
-  }
-  
-  void endElement (const char * name)
-  {
-    assert(tagStack.back() == name);
-    tagStack.pop_back();
-    
-    if (!strcmp(name, DAV_RESPONSE_TAG)) {
-      // finish complete response
-      currentElementUrl = strutils::strip(currentElementUrl);
-      
-      DAVResource* res = NULL;
-      if (currentElementType == DAVResource::Collection) {
-        DAVCollection* col = new DAVCollection(currentElementUrl);
-        res = col;
-      } else {
-        res = new DAVResource(currentElementUrl);
-      }
-      
-      res->setVersionName(strutils::strip(currentVersionName));
-      res->setVersionControlledConfiguration(currentVCC);
-      if (rootResource &&
-          strutils::starts_with(currentElementUrl, rootResource->url()))
-      {
-        static_cast<DAVCollection*>(rootResource)->addChild(res);
-      }
-      
-      if (!rootResource) {
-        rootResource = res;
-      }
-    }
-  }
-  
-  void data (const char * s, int length)
-  {
-    if (tagStack.back() == DAV_HREF_TAG) {
-      if (tagN(1) == DAV_RESPONSE_TAG) {
-        currentElementUrl += string(s, length);
-      } else if (tagN(1) == DAV_VCC_TAG) {
-        currentVCC += string(s, length);
-      }
-    } else if (tagStack.back() == SUBVERSION_MD5_CHECKSUM_TAG) {
-      currentElementMD5 = string(s, length);
-    } else if (tagStack.back() == DAV_VERSIONNAME_TAG) {
-      currentVersionName = string(s, length);
-    } else if (tagStack.back() == DAV_CONTENT_LENGTH_TAG) {
-      std::istringstream is(string(s, length));
-      is >> currentElementLength;
-    }
-  }
-  
-  void pi (const char * target, const char * data) {}
-  
-  string tagN(const unsigned int n) const
-  {
-    size_t sz = tagStack.size();
-    if (n >= sz) {
-      return string();
-    }
-    
-    return tagStack[sz - (1 + n)];
-  }
-  
-  bool parserInited;
-  bool valid;
-  XML_Parser xmlParser;
-  DAVResource* rootResource;
-  
-  // in-flight data
-  string_list tagStack;
-  DAVResource::Type currentElementType;
-  string currentElementUrl,
-    currentVersionName,
-    currentVCC;
-  int currentElementLength;
-  string currentElementMD5;
-};
-
-
-////////////////////////////////////////////////////////////////////////
-// Static callback functions for Expat.
-////////////////////////////////////////////////////////////////////////
-
-#define VISITOR static_cast<DAVMultiStatus::DAVMultiStatusPrivate *>(userData)
-
-static void
-start_element (void * userData, const char * name, const char ** atts)
-{
-  VISITOR->startElement(name);
-}
-
-static void
-end_element (void * userData, const char * name)
-{
-  VISITOR->endElement(name);
-}
-
-static void
-character_data (void * userData, const char * s, int len)
-{
-  VISITOR->data(s, len);
-}
-
-static void
-processing_instruction (void * userData,
-                        const char * target,
-                        const char * data)
-{
-  VISITOR->pi(target, data);
-}
-
-#undef VISITOR
-
-///////////////////////////////////////////////////////////////////////////////
-
-DAVMultiStatus::DAVMultiStatus() :
-_d(new DAVMultiStatusPrivate)
-{
-  
-}
-
-DAVMultiStatus::~DAVMultiStatus()
-{
-  
-}
-
-void DAVMultiStatus::parseXML(const char* data, int size)
-{
-  if (!_d->parserInited) {
-    _d->xmlParser = XML_ParserCreateNS(0, ':');
-    XML_SetUserData(_d->xmlParser, _d.get());
-    XML_SetElementHandler(_d->xmlParser, start_element, end_element);
-    XML_SetCharacterDataHandler(_d->xmlParser, character_data);
-    XML_SetProcessingInstructionHandler(_d->xmlParser, processing_instruction);
-    _d->parserInited = true;
-  }
-  
-  if (!XML_Parse(_d->xmlParser, data, size, false)) {
-    SG_LOG(SG_TERRASYNC, SG_WARN, "DAV parse error:" << XML_ErrorString(XML_GetErrorCode(_d->xmlParser))
-           << " at line:" << XML_GetCurrentLineNumber(_d->xmlParser)
-           << " column " << XML_GetCurrentColumnNumber(_d->xmlParser));
-    
-    XML_ParserFree(_d->xmlParser);
-    _d->parserInited = false;
-    _d->valid = false;
-  }
-}
-
-void DAVMultiStatus::finishParse()
-{
-  if (_d->parserInited) {
-    if (!XML_Parse(_d->xmlParser, NULL, 0, true)) {
-        SG_LOG(SG_TERRASYNC, SG_WARN, "DAV parse error:" << XML_ErrorString(XML_GetErrorCode(_d->xmlParser))
-               << " at line:" << XML_GetCurrentLineNumber(_d->xmlParser)
-               << " column " << XML_GetCurrentColumnNumber(_d->xmlParser));
-        _d->valid = false;
-    } else {
-        _d->valid = true;
-    }
-    XML_ParserFree(_d->xmlParser);
-  }
-  
-  _d->parserInited = false;
-}
-
-DAVResource* DAVMultiStatus::resource()
-{
-  return _d->rootResource;
-}
-
-bool DAVMultiStatus::isValid() const
-{
-    return _d->valid;
-}
-
-

simgear/io/DAVMultiStatus.hxx

@@ -1,143 +0,0 @@
-// DAVMultiStatus.hxx -- parser for WebDAV MultiStatus XML data
-//
-// Copyright (C) 2012  James Turner <zakalawe@mac.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-
-#ifndef SG_IO_DAVMULTISTATUS_HXX
-#define SG_IO_DAVMULTISTATUS_HXX
-
-#include <string>
-#include <vector>
-#include <memory> // for auto_ptr
-
-namespace simgear
-{
-
-class DAVCollection;
-
-class DAVResource
-{
-public:
-    DAVResource(const std::string& url);
-    virtual ~DAVResource() { }
-  
-    typedef enum {
-        Unknown = 0,
-        Collection = 1
-    } Type;
-        
-    const Type type() const
-        { return _type; }
-    
-    const std::string& url() const
-        { return _url; }
-
-    std::string name() const;
-
-    /**
-     * SVN servers use this field to expose the head revision
-     * of the resource, which is useful
-     */
-    const std::string& versionName() const
-      { return _versionName; }
-
-    void setVersionName(const std::string& aVersion);
-
-    DAVCollection* container() const
-        { return _container; }
-    
-    virtual bool isCollection() const
-        { return false; }
-
-    void setVersionControlledConfiguration(const std::string& vcc);
-    const std::string& versionControlledConfiguration() const
-        { return _vcc; }
-    
-    void setMD5(const std::string& md5Hex);
-    const std::string& md5() const
-        { return _md5; }
-protected:
-    friend class DAVCollection;
-  
-    Type _type;
-    std::string _url;
-    std::string _versionName;
-    std::string _vcc;
-    std::string _md5;
-    DAVCollection* _container;
-};
-
-typedef std::vector<DAVResource*> DAVResourceList;
-
-class DAVCollection : public DAVResource
-{
-public:
-  DAVCollection(const std::string& url);
-  virtual ~DAVCollection();
-  
-  DAVResourceList contents() const;
-  
-  void addChild(DAVResource* res);
-  void removeChild(DAVResource* res);
-  
-  DAVCollection* createChildCollection(const std::string& name);
-  
-  /**
-   * find the collection member with the specified URL, or return NULL
-   * if no such member of this collection exists.
-   */
-  DAVResource* childWithUrl(const std::string& url) const;
-     
-  /**
-   * find the collection member with the specified name, or return NULL
-   */
-  DAVResource* childWithName(const std::string& name) const;
-   
-  /**
-   * wrapper around URL manipulation
-   */
-  std::string urlForChildWithName(const std::string& name) const;
-  
-  virtual bool isCollection() const
-  { return true; }
-private:
-  DAVResourceList _contents;
-};
-
-class DAVMultiStatus
-{
-public:
-    DAVMultiStatus();
-    ~DAVMultiStatus();
-    
-    // incremental XML parsing
-    void parseXML(const char* data, int size);
-    
-    void finishParse();
-    
-    bool isValid() const;
-    
-    DAVResource* resource();
-  
-  class DAVMultiStatusPrivate;
-private:
-    std::auto_ptr<DAVMultiStatusPrivate> _d;
-};
-
-} // of namespace simgear
-
-#endif // of SG_IO_DAVMULTISTATUS_HXX

simgear/io/DNSClient.cxx

@@ -22,7 +22,7 @@
 //
 
 #include "DNSClient.hxx"
-#include "udns.h"
+#include <udns.h>
 #include <time.h>
 #include <simgear/debug/logstream.hxx>
 
@@ -33,18 +33,33 @@ namespace DNS {
 class Client::ClientPrivate {
 public:
     ClientPrivate() {
-        if (dns_init(NULL, 0) < 0)
-            SG_LOG(SG_IO, SG_ALERT, "Can't init udns library" );
 
-        if( dns_open(NULL) < 0 )
+        if( instanceCounter++ == 0 )
+          if (dns_init(NULL, 0) < 0)
+              SG_LOG(SG_IO, SG_ALERT, "Can't init udns library" );
+
+        ctx = dns_new(NULL);
+
+        if (dns_init(ctx, 0) < 0)
+            SG_LOG(SG_IO, SG_ALERT, "Can't create udns context" );
+
+        if( dns_open(ctx) < 0 )
             SG_LOG(SG_IO, SG_ALERT, "Can't open udns context" );
     }
 
     ~ClientPrivate() {
-        dns_close(NULL);
+        dns_close(ctx);
+        dns_free(ctx);
+        if( --instanceCounter == 0 )
+            dns_close(NULL);
     }
+
+    struct dns_ctx * ctx;
+    static size_t instanceCounter;
 };
 
+size_t Client::ClientPrivate::instanceCounter = 0;
+
 Request::Request( const std::string & dn ) :
         _dn(dn),
         _type(DNS_T_ANY),
@@ -69,6 +84,96 @@ NAPTRRequest::NAPTRRequest( const std::string & dn ) :
     _type = DNS_T_NAPTR;
 }
 
+SRVRequest::SRVRequest( const std::string & dn ) :
+        Request(dn)
+{
+    _type = DNS_T_SRV;
+}
+
+SRVRequest::SRVRequest( const std::string & dn, const string & service, const string & protocol ) :
+        Request(dn),
+        _service(service),
+        _protocol(protocol)
+{
+    _type = DNS_T_SRV;
+}
+
+static bool sortSRV( const SRVRequest::SRV_ptr a, const SRVRequest::SRV_ptr b )
+{
+    if( a->priority > b->priority ) return false;
+    if( a->priority < b->priority ) return true;
+    return a->weight > b->weight;
+}
+
+static void dnscbSRV(struct dns_ctx *ctx, struct dns_rr_srv *result, void *data)
+{
+    SRVRequest * r = static_cast<SRVRequest*>(data);
+    if (result) {
+        r->cname = result->dnssrv_cname;
+        r->qname = result->dnssrv_qname;
+        r->ttl = result->dnssrv_ttl;
+        for (int i = 0; i < result->dnssrv_nrr; i++) {
+            SRVRequest::SRV_ptr srv(new SRVRequest::SRV);
+            r->entries.push_back(srv);
+            srv->priority = result->dnssrv_srv[i].priority;
+            srv->weight = result->dnssrv_srv[i].weight;
+            srv->port = result->dnssrv_srv[i].port;
+            srv->target = result->dnssrv_srv[i].name;
+        }
+        std::sort( r->entries.begin(), r->entries.end(), sortSRV );
+        free(result);
+    }
+    r->setComplete();
+}
+
+void SRVRequest::submit( Client * client )
+{
+    // if service is defined, pass service and protocol
+    if (!dns_submit_srv(client->d->ctx, getDn().c_str(), _service.empty() ? NULL : _service.c_str(), _service.empty() ? NULL : _protocol.c_str(), 0, dnscbSRV, this )) {
+        SG_LOG(SG_IO, SG_ALERT, "Can't submit dns request for " << getDn());
+        return;
+    }
+    _start = time(NULL);
+}
+
+TXTRequest::TXTRequest( const std::string & dn ) :
+        Request(dn)
+{
+    _type = DNS_T_TXT;
+}
+
+static void dnscbTXT(struct dns_ctx *ctx, struct dns_rr_txt *result, void *data)
+{
+    TXTRequest * r = static_cast<TXTRequest*>(data);
+    if (result) {
+        r->cname = result->dnstxt_cname;
+        r->qname = result->dnstxt_qname;
+        r->ttl = result->dnstxt_ttl;
+        for (int i = 0; i < result->dnstxt_nrr; i++) {
+          //TODO: interprete the .len field of dnstxt_txt?
+          string txt = string((char*)result->dnstxt_txt[i].txt);
+          r->entries.push_back( txt );
+          string_list tokens = simgear::strutils::split( txt, "=", 1 );
+          if( tokens.size() == 2 ) {
+            r->attributes[tokens[0]] = tokens[1];
+          }
+        }
+        free(result);
+    }
+    r->setComplete();
+}
+
+void TXTRequest::submit( Client * client )
+{
+    // protocol and service an already encoded in DN so pass in NULL for both
+    if (!dns_submit_txt(client->d->ctx, getDn().c_str(), DNS_C_IN, 0, dnscbTXT, this )) {
+        SG_LOG(SG_IO, SG_ALERT, "Can't submit dns request for " << getDn());
+        return;
+    }
+    _start = time(NULL);
+}
+
+
 static bool sortNAPTR( const NAPTRRequest::NAPTR_ptr a, const NAPTRRequest::NAPTR_ptr b )
 {
     if( a->order > b->order ) return false;
@@ -106,9 +211,9 @@ static void dnscbNAPTR(struct dns_ctx *ctx, struct dns_rr_naptr *result, void *d
     r->setComplete();
 }
 
-void NAPTRRequest::submit()
+void NAPTRRequest::submit( Client * client )
 {
-    if (!dns_submit_naptr(NULL, getDn().c_str(), 0, dnscbNAPTR, this )) {
+    if (!dns_submit_naptr(client->d->ctx, getDn().c_str(), 0, dnscbNAPTR, this )) {
         SG_LOG(SG_IO, SG_ALERT, "Can't submit dns request for " << getDn());
         return;
     }
@@ -127,16 +232,16 @@ Client::Client() :
 
 void Client::makeRequest(const Request_ptr& r)
 {
-    r->submit();
+    r->submit(this);
 }
 
-
 void Client::update(int waitTimeout)
 {
     time_t now = time(NULL);
-    if( dns_timeouts( NULL, waitTimeout, now ) < 0 )
+    if( dns_timeouts( d->ctx, -1, now ) < 0 )
         return;
-    dns_ioevent(NULL, now);
+
+    dns_ioevent(d->ctx, now);
 }
 
 } // of namespace DNS

simgear/io/DNSClient.hxx

@@ -24,11 +24,14 @@
 #ifndef SG_DNS_CLIENT_HXX
 #define SG_DNS_CLIENT_HXX
 
-#include <memory> // for std::auto_ptr
+#include <memory> // for std::unique_ptr
 #include <string>
 #include <vector>
+#include <ctime> // for time_t
+
 #include <simgear/structure/SGReferenced.hxx>
 #include <simgear/structure/SGSharedPtr.hxx>
+#include <simgear/structure/event_mgr.hxx>
 
 namespace simgear
 {
@@ -36,6 +39,7 @@ namespace simgear
 namespace DNS
 {
 
+class Client;
 class Request : public SGReferenced
 {
 public:
@@ -47,7 +51,7 @@ public:
     bool isTimeout() const;
     void setComplete( bool b = true ) { _complete = b; }
 
-    virtual void submit() = 0;
+    virtual void submit( Client * client) = 0;
 
     std::string cname;
     std::string qname;
@@ -59,12 +63,13 @@ protected:
     time_t _timeout_secs;
     time_t _start;
 };
+typedef SGSharedPtr<Request> Request_ptr;
 
 class NAPTRRequest : public Request
 {
 public:
     NAPTRRequest( const std::string & dn );
-    virtual void submit();
+    virtual void submit( Client * client );
 
     struct NAPTR : SGReferenced {
         int order;
@@ -82,7 +87,38 @@ public:
     std::string qservice;
 };
 
-typedef SGSharedPtr<Request> Request_ptr;
+class SRVRequest : public Request
+{
+public:
+    SRVRequest( const std::string & dn );
+    SRVRequest( const std::string & dn, const string & service, const string & protocol );
+    virtual void submit( Client * client );
+
+    struct SRV : SGReferenced {
+      int priority;
+      int weight;
+      int port;
+      std::string target;
+    };
+    typedef SGSharedPtr<SRV> SRV_ptr;
+    typedef std::vector<SRV_ptr> SRV_list;
+    SRV_list entries;
+private:
+    std::string _service;
+    std::string _protocol;
+};
+
+class TXTRequest : public Request
+{
+public:
+    TXTRequest( const std::string & dn );
+    virtual void submit( Client * client );
+
+    typedef std::vector<string> TXT_list;
+    typedef std::map<std::string,std::string> TXT_Attribute_map;
+    TXT_list entries;
+    TXT_Attribute_map attributes;
+};
 
 class Client
 {
@@ -96,10 +132,8 @@ public:
 
 //    void cancelRequest(const Request_ptr& r, std::string reason = std::string());
 
-private:
-
     class ClientPrivate;
-    std::auto_ptr<ClientPrivate> d;
+    std::unique_ptr<ClientPrivate> d;
 };
 
 } // of namespace DNS

simgear/io/HTTPClient.cxx

@@ -80,13 +80,13 @@ public:
         // see https://curl.haxx.se/libcurl/c/CURLMOPT_PIPELINING.html
         // we request HTTP 1.1 pipelining
         curl_multi_setopt(curlMulti, CURLMOPT_PIPELINING, 1 /* aka CURLPIPE_HTTP1 */);
+#if (LIBCURL_VERSION_MINOR >= 30)
         curl_multi_setopt(curlMulti, CURLMOPT_MAX_TOTAL_CONNECTIONS, (long) maxConnections);
         curl_multi_setopt(curlMulti, CURLMOPT_MAX_PIPELINE_LENGTH,
                           (long) maxPipelineDepth);
         curl_multi_setopt(curlMulti, CURLMOPT_MAX_HOST_CONNECTIONS,
                           (long) maxHostConnections);
-
-
+#endif
     }
 
     typedef std::map<Request_ptr, CURL*> RequestCurlMap;
@@ -138,24 +138,38 @@ Client::~Client()
 void Client::setMaxConnections(unsigned int maxCon)
 {
     d->maxConnections = maxCon;
+#if (LIBCURL_VERSION_MINOR >= 30)
     curl_multi_setopt(d->curlMulti, CURLMOPT_MAX_TOTAL_CONNECTIONS, (long) maxCon);
+#endif
 }
 
 void Client::setMaxHostConnections(unsigned int maxHostCon)
 {
     d->maxHostConnections = maxHostCon;
+#if (LIBCURL_VERSION_MINOR >= 30)
     curl_multi_setopt(d->curlMulti, CURLMOPT_MAX_HOST_CONNECTIONS, (long) maxHostCon);
+#endif
 }
 
 void Client::setMaxPipelineDepth(unsigned int depth)
 {
     d->maxPipelineDepth = depth;
+#if (LIBCURL_VERSION_MINOR >= 30)
     curl_multi_setopt(d->curlMulti, CURLMOPT_MAX_PIPELINE_LENGTH, (long) depth);
+#endif
 }
 
 void Client::update(int waitTimeout)
 {
-    int remainingActive, messagesInQueue;
+    if (d->requests.empty()) {
+        // curl_multi_wait returns immediately if there's no requests active,
+        // but that can cause high CPU usage for us.
+        SGTimeStamp::sleepForMSec(waitTimeout);
+        return;
+    }
+
+    int remainingActive, messagesInQueue, numFds;
+    curl_multi_wait(d->curlMulti, NULL, 0, waitTimeout, &numFds);
     curl_multi_perform(d->curlMulti, &remainingActive);
 
     CURLMsg* msg;
@@ -196,7 +210,6 @@ void Client::update(int waitTimeout)
           SG_LOG(SG_IO, SG_ALERT, "unknown CurlMSG:" << msg->msg);
       }
     } // of curl message processing loop
-    SGTimeStamp::sleepForMSec(waitTimeout);
 }
 
 void Client::makeRequest(const Request_ptr& r)
@@ -211,8 +224,7 @@ void Client::makeRequest(const Request_ptr& r)
 
     r->_client = this;
 
-    ClientPrivate::RequestCurlMap::iterator rit = d->requests.find(r);
-    assert(rit == d->requests.end());
+    assert(d->requests.find(r) == d->requests.end());
 
     CURL* curlRequest = curl_easy_init();
     curl_easy_setopt(curlRequest, CURLOPT_URL, r->url().c_str());
@@ -231,6 +243,8 @@ void Client::makeRequest(const Request_ptr& r)
     curl_easy_setopt(curlRequest, CURLOPT_USERAGENT, d->userAgent.c_str());
     curl_easy_setopt(curlRequest, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
 
+    curl_easy_setopt(curlRequest, CURLOPT_FOLLOWLOCATION, 1);
+
     if (!d->proxy.empty()) {
       curl_easy_setopt(curlRequest, CURLOPT_PROXY, d->proxy.c_str());
       curl_easy_setopt(curlRequest, CURLOPT_PROXYPORT, d->proxyPort);
@@ -300,7 +314,9 @@ void Client::cancelRequest(const Request_ptr &r, std::string reason)
     }
 
     CURLMcode err = curl_multi_remove_handle(d->curlMulti, it->second);
-    assert(err == CURLM_OK);
+    if (err != CURLM_OK) {
+      SG_LOG(SG_IO, SG_WARN, "curl_multi_remove_handle failed:" << err);
+    }
 
     // clear the request pointer form the curl-easy object
     curl_easy_setopt(it->second, CURLOPT_PRIVATE, 0);

simgear/io/HTTPClient.hxx

@@ -24,7 +24,7 @@
 #ifndef SG_HTTP_CLIENT_HXX
 #define SG_HTTP_CLIENT_HXX
 
-#include <memory> // for std::auto_ptr
+#include <memory> // for std::unique_ptr
 #include <stdint.h> // for uint_64t
 
 #include <simgear/io/HTTPFileRequest.hxx>
@@ -125,7 +125,7 @@ private:
     friend class Request;
 
     class ClientPrivate;
-    std::auto_ptr<ClientPrivate> d;
+    std::unique_ptr<ClientPrivate> d;
 };
 
 } // of namespace HTTP

simgear/io/HTTPFileRequest.cxx

@@ -41,14 +41,13 @@ namespace HTTP
     if( responseCode() != 200 )
       return setFailure(responseCode(), responseReason());
 
-    if( !_filename.empty() )
+    if( !_filename.isNull() )
     {
       // TODO validate path? (would require to expose fgValidatePath somehow to
       //      simgear)
-      SGPath path(_filename);
-      path.create_dir(0755);
+      _filename.create_dir(0755);
 
-      _file.open(_filename.c_str(), std::ios::binary | std::ios::trunc);
+      _file.open(_filename, std::ios::binary | std::ios::trunc | std::ios::out);
     }
 
     if( !_file )

simgear/io/HTTPFileRequest.hxx

@@ -19,8 +19,11 @@
 #ifndef SG_HTTP_FILEREQUEST_HXX_
 #define SG_HTTP_FILEREQUEST_HXX_
 
+#include <simgear/misc/sg_path.hxx>
+
 #include "HTTPRequest.hxx"
-#include <fstream>
+
+#include <simgear/io/iostreams/sgstream.hxx>
 
 namespace simgear
 {
@@ -43,8 +46,8 @@ namespace HTTP
       FileRequest(const std::string& url, const std::string& path);
 
     protected:
-      std::string   _filename;
-      std::ofstream _file;
+      SGPath _filename;
+      sg_ofstream _file;
 
       virtual void responseHeadersComplete();
       virtual void gotBodyData(const char* s, int n);

simgear/io/HTTPRepository.cxx

@@ -37,7 +37,7 @@
 #include <simgear/misc/sg_dir.hxx>
 #include <simgear/io/HTTPClient.hxx>
 #include <simgear/io/sg_file.hxx>
-#include <simgear/misc/sgstream.hxx>
+#include <simgear/io/iostreams/sgstream.hxx>
 #include <simgear/structure/exception.hxx>
 #include <simgear/timing/timestamp.hxx>
 
@@ -70,7 +70,7 @@ namespace simgear
         }
     protected:
         HTTPDirectory* _directory;
-        size_t _contentSize;
+        size_t _contentSize = 0;
     };
 
     typedef SGSharedPtr<HTTPRepoGetRequest> RepoRequestPtr;
@@ -94,7 +94,7 @@ public:
     struct Failure
     {
         SGPath path;
-        AbstractRepository::ResultCode error;
+        HTTPRepository::ResultCode error;
     };
 
     typedef std::vector<Failure> FailureList;
@@ -104,7 +104,7 @@ public:
         hashCacheDirty(false),
         p(parent),
         isUpdating(false),
-        status(AbstractRepository::REPO_NO_ERROR),
+        status(HTTPRepository::REPO_NO_ERROR),
         totalDownloaded(0)
     { ; }
 
@@ -115,7 +115,7 @@ public:
     std::string baseUrl;
     SGPath basePath;
     bool isUpdating;
-    AbstractRepository::ResultCode status;
+    HTTPRepository::ResultCode status;
     HTTPDirectory* rootDir;
     size_t totalDownloaded;
 
@@ -130,9 +130,9 @@ public:
     std::string computeHashForPath(const SGPath& p);
     void writeHashCache();
 
-    void failedToGetRootIndex(AbstractRepository::ResultCode st);
+    void failedToGetRootIndex(HTTPRepository::ResultCode st);
     void failedToUpdateChild(const SGPath& relativePath,
-                             AbstractRepository::ResultCode fileStatus);
+                             HTTPRepository::ResultCode fileStatus);
 
     typedef std::vector<RepoRequestPtr> RequestVector;
     RequestVector queuedRequests,
@@ -147,6 +147,7 @@ public:
     typedef std::vector<HTTPDirectory*> DirectoryVector;
     DirectoryVector directories;
 
+    SGPath installedCopyPath;
 };
 
 class HTTPDirectory
@@ -219,16 +220,16 @@ public:
 
     std::string url() const
     {
-        if (_relativePath.str().empty()) {
+        if (_relativePath.empty()) {
             return _repository->baseUrl;
         }
 
-        return _repository->baseUrl + "/" + _relativePath.str();
+        return _repository->baseUrl + "/" + _relativePath;
     }
 
     void dirIndexUpdated(const std::string& hash)
     {
-        SGPath fpath(_relativePath);
+        SGPath fpath(absolutePath());
         fpath.append(".dirindex");
         _repository->updatedFileContents(fpath, hash);
 
@@ -237,9 +238,9 @@ public:
         std::sort(children.begin(), children.end());
     }
 
-    void failedToUpdate(AbstractRepository::ResultCode status)
+    void failedToUpdate(HTTPRepository::ResultCode status)
     {
-        if (_relativePath.isNull()) {
+        if (_relativePath.empty()) {
             // root dir failed
             _repository->failedToGetRootIndex(status);
         } else {
@@ -247,10 +248,60 @@ public:
         }
     }
 
+    void copyInstalledChildren()
+    {
+        if (_repository->installedCopyPath.isNull()) {
+            return;
+        }
+
+        string_list indexNames = indexChildren();
+        const_string_list_iterator nameIt = indexNames.begin();
+        for (; nameIt != indexNames.end(); ++nameIt) {
+            SGPath p(absolutePath());
+            p.append(*nameIt);
+            if (p.exists()) {
+                continue; // only copy if the file is missing entirely
+            }
+
+            ChildInfoList::iterator c = findIndexChild(*nameIt);
+            if (c->type == ChildInfo::DirectoryType) {
+                continue; // only care about files
+            }
+
+            SGPath cp = _repository->installedCopyPath;
+            cp.append(relativePath());
+            cp.append(*nameIt);
+            if (!cp.exists()) {
+                continue;
+            }
+
+            SG_LOG(SG_TERRASYNC, SG_BULK, "new child, copying existing file" << cp << p);
+
+            SGBinaryFile src(cp);
+            SGBinaryFile dst(p);
+            src.open(SG_IO_IN);
+            dst.open(SG_IO_OUT);
+
+            char* buf = (char*) malloc(cp.sizeInBytes());
+            if (!buf) {
+                continue;
+            }
+
+            src.read(buf, cp.sizeInBytes());
+            dst.write(buf, cp.sizeInBytes());
+            src.close();
+            dst.close();
+
+            free(buf);
+        }
+    }
+
     void updateChildrenBasedOnHash()
     {
         //SG_LOG(SG_TERRASYNC, SG_DEBUG, "updated children for:" << relativePath());
 
+        copyInstalledChildren();
+
         string_list indexNames = indexChildren(),
             toBeUpdated, orphans;
         simgear::Dir d(absolutePath());
@@ -281,9 +332,7 @@ public:
                 // perform a recursive check.
                 SG_LOG(SG_TERRASYNC, SG_DEBUG, "file exists hash is good:" << it->file() );
                 if (c->type == ChildInfo::DirectoryType) {
-                    SGPath p(relativePath());
-                    p.append(it->file());
-                    HTTPDirectory* childDir = _repository->getOrCreateDirectory(p.str());
+                    HTTPDirectory* childDir = childDirectory(it->file());
                     childDir->updateChildrenBasedOnHash();
                 }
             }
@@ -301,6 +350,12 @@ public:
         scheduleUpdates(toBeUpdated);
     }
 
+    HTTPDirectory* childDirectory(const std::string& name)
+    {
+        std::string childPath = relativePath().empty() ? name : relativePath() + "/" + name;
+        return _repository->getOrCreateDirectory(childPath);
+    }
+
     void removeOrphans(const string_list& orphans)
     {
         string_list::const_iterator it;
@@ -334,9 +389,7 @@ public:
             if (cit->type == ChildInfo::FileType) {
                 _repository->updateFile(this, *it, cit->sizeInBytes);
             } else {
-                SGPath p(relativePath());
-                p.append(*it);
-                HTTPDirectory* childDir = _repository->getOrCreateDirectory(p.str());
+                HTTPDirectory* childDir = childDirectory(*it);
                 _repository->updateDir(childDir, cit->hash, cit->sizeInBytes);
             }
         }
@@ -345,11 +398,11 @@ public:
     SGPath absolutePath() const
     {
         SGPath r(_repository->basePath);
-        r.append(_relativePath.str());
+        r.append(_relativePath);
         return r;
     }
 
-    SGPath relativePath() const
+    std::string relativePath() const
     {
         return _relativePath;
     }
@@ -361,21 +414,22 @@ public:
         if (it == children.end()) {
             SG_LOG(SG_TERRASYNC, SG_WARN, "updated file but not found in dir:" << _relativePath << " " << file);
         } else {
-            SGPath fpath(_relativePath);
+            SGPath fpath(absolutePath());
             fpath.append(file);
 
             if (it->hash != hash) {
-                _repository->failedToUpdateChild(_relativePath, AbstractRepository::REPO_ERROR_CHECKSUM);
+                // we don't erase the file on a hash mismatch, becuase if we're syncing during the
+                // middle of a server-side update, the downloaded file may actually become valid.
+                _repository->failedToUpdateChild(_relativePath, HTTPRepository::REPO_ERROR_CHECKSUM);
             } else {
                 _repository->updatedFileContents(fpath, hash);
                 _repository->totalDownloaded += sz;
-                //SG_LOG(SG_TERRASYNC, SG_INFO, "did update:" << fpath);
             } // of hash matches
         } // of found in child list
     }
 
     void didFailToUpdateFile(const std::string& file,
-                             AbstractRepository::ResultCode status)
+                             HTTPRepository::ResultCode status)
     {
         SGPath fpath(_relativePath);
         fpath.append(file);
@@ -405,7 +459,7 @@ private:
             return false;
         }
 
-        std::ifstream indexStream( p.c_str(), std::ios::in );
+        sg_ifstream indexStream(p, std::ios::in );
 
         if ( !indexStream.is_open() ) {
             throw sg_io_exception("cannot open dirIndex file", p);
@@ -440,6 +494,11 @@ private:
                 continue; // ignore path, next line
             }
 
+            if( typeData == "time" && tokens.size() > 1 ) {
+                SG_LOG(SG_TERRASYNC, SG_INFO, ".dirindex at '" << p.str() << "' timestamp: " << tokens[1] );
+                continue;
+            }
+
             if( tokens.size() < 3 ) {
                 SG_LOG(SG_TERRASYNC, SG_WARN, "malformed .dirindex file: not enough tokens in line '" << line << "' (ignoring line)" );
                 continue;
@@ -449,6 +508,14 @@ private:
                 SG_LOG(SG_TERRASYNC, SG_WARN, "malformed .dirindex file: invalid type in line '" << line << "', expected 'd' or 'f', (ignoring line)" );
                 continue;
             }
+
+            // security: prevent writing outside the repository via ../../.. filenames
+            // (valid filenames never contain / - subdirectories have their own .dirindex)
+            if ((tokens[1] == "..") || (tokens[1].find_first_of("/\\") != std::string::npos)) {
+                SG_LOG(SG_TERRASYNC, SG_WARN, "malformed .dirindex file: invalid filename in line '" << line << "', (ignoring line)" );
+                continue;
+            }
+
             children.push_back(ChildInfo(typeData == "f" ? ChildInfo::FileType : ChildInfo::DirectoryType, tokens[1], tokens[2]));
 
             if (tokens.size() > 3) {
@@ -465,14 +532,12 @@ private:
         p.append(name);
         bool ok;
 
-        SGPath fpath(_relativePath);
-        fpath.append(name);
-
+        std::string fpath = _relativePath + "/" + name;
         if (p.isDir()) {
-            ok = _repository->deleteDirectory(fpath.str());
+            ok = _repository->deleteDirectory(fpath);
         } else {
             // remove the hash cache entry
-            _repository->updatedFileContents(fpath, std::string());
+            _repository->updatedFileContents(p, std::string());
             ok = p.remove();
         }
 
@@ -492,8 +557,8 @@ private:
         return _repository->hashForPath(p);
     }
 
-  HTTPRepoPrivate* _repository;
-  SGPath _relativePath; // in URL and file-system space
+    HTTPRepoPrivate* _repository;
+    std::string _relativePath; // in URL and file-system space
 
 
 };
@@ -562,7 +627,12 @@ size_t HTTPRepository::bytesToDownload() const
     }
 
     for (r = _d->activeRequests.begin(); r != _d->activeRequests.end(); ++r) {
-        result += (*r)->contentSize() - (*r)->responseBytesReceived();
+        if ((*r)->contentSize() > 0) {
+            // Content size for root dirindex of a repository is zero,
+            // and returing a negative value breaks everyting, so just ignore
+            // it
+            result += (*r)->contentSize() - (*r)->responseBytesReceived();
+        }
     }
 
     return result;
@@ -580,7 +650,12 @@ size_t HTTPRepository::bytesDownloaded() const
     return result;
 }
 
-AbstractRepository::ResultCode
+void HTTPRepository::setInstalledCopyPath(const SGPath& copyPath)
+{
+    _d->installedCopyPath = copyPath;
+}
+
+HTTPRepository::ResultCode
 HTTPRepository::failure() const
 {
     if ((_d->status == REPO_NO_ERROR) && !_d->failures.empty()) {
@@ -605,14 +680,13 @@ HTTPRepository::failure() const
         {
             pathInRepo = _directory->absolutePath();
             pathInRepo.append(fileName);
-            //SG_LOG(SG_TERRASYNC, SG_INFO, "will GET file " << url());
         }
 
     protected:
         virtual void gotBodyData(const char* s, int n)
         {
             if (!file.get()) {
-                file.reset(new SGBinaryFile(pathInRepo.str()));
+                file.reset(new SGBinaryFile(pathInRepo));
                 if (!file->open(SG_IO_OUT)) {
                   SG_LOG(SG_TERRASYNC, SG_WARN, "unable to create file " << pathInRepo);
                   _directory->repository()->http->cancelRequest(this, "Unable to create output file");
@@ -634,10 +708,10 @@ HTTPRepository::failure() const
                 SG_LOG(SG_TERRASYNC, SG_DEBUG, "got file " << fileName << " in " << _directory->absolutePath());
             } else if (responseCode() == 404) {
                 SG_LOG(SG_TERRASYNC, SG_WARN, "terrasync file not found on server: " << fileName << " for " << _directory->absolutePath());
-                _directory->didFailToUpdateFile(fileName, AbstractRepository::REPO_ERROR_FILE_NOT_FOUND);
+                _directory->didFailToUpdateFile(fileName, HTTPRepository::REPO_ERROR_FILE_NOT_FOUND);
             } else {
                 SG_LOG(SG_TERRASYNC, SG_WARN, "terrasync file download error on server: " << fileName << " for " << _directory->absolutePath() << ": " << responseCode() );
-                _directory->didFailToUpdateFile(fileName, AbstractRepository::REPO_ERROR_HTTP);
+                _directory->didFailToUpdateFile(fileName, HTTPRepository::REPO_ERROR_HTTP);
             }
 
             _directory->repository()->finishedRequest(this);
@@ -649,9 +723,9 @@ HTTPRepository::failure() const
             if (pathInRepo.exists()) {
                 pathInRepo.remove();
             }
-            
+
             if (_directory) {
-                _directory->didFailToUpdateFile(fileName, AbstractRepository::REPO_ERROR_SOCKET);
+                _directory->didFailToUpdateFile(fileName, HTTPRepository::REPO_ERROR_SOCKET);
                 _directory->repository()->finishedRequest(this);
             }
         }
@@ -664,7 +738,7 @@ HTTPRepository::failure() const
         std::string fileName; // if empty, we're getting the directory itself
         SGPath pathInRepo;
         simgear::sha1nfo hashContext;
-        std::auto_ptr<SGBinaryFile> file;
+        std::unique_ptr<SGBinaryFile> file;
     };
 
     class DirGetRequest : public HTTPRepoGetRequest
@@ -676,7 +750,6 @@ HTTPRepository::failure() const
             _targetHash(targetHash)
         {
             sha1_init(&hashContext);
-           //SG_LOG(SG_TERRASYNC, SG_INFO, "will GET dir " << url());
         }
 
         void setIsRootDir()
@@ -701,7 +774,7 @@ HTTPRepository::failure() const
             if (responseCode() == 200) {
                 std::string hash = strutils::encodeHex(sha1_result(&hashContext), HASH_LENGTH);
                 if (!_targetHash.empty() && (hash != _targetHash)) {
-                    _directory->failedToUpdate(AbstractRepository::REPO_ERROR_CHECKSUM);
+                    _directory->failedToUpdate(HTTPRepository::REPO_ERROR_CHECKSUM);
                     _directory->repository()->finishedRequest(this);
                     return;
                 }
@@ -717,9 +790,9 @@ HTTPRepository::failure() const
 
                     // dir index data has changed, so write to disk and update
                     // the hash accordingly
-                    std::ofstream of(pathInRepo().c_str(), std::ios::trunc | std::ios::out);
+                    sg_ofstream of(pathInRepo(), std::ios::trunc | std::ios::out);
                     if (!of.is_open()) {
-                        throw sg_io_exception("Failed to open directory index file for writing", pathInRepo().c_str());
+                        throw sg_io_exception("Failed to open directory index file for writing", pathInRepo());
                     }
 
                     of.write(body.data(), body.size());
@@ -737,14 +810,14 @@ HTTPRepository::failure() const
                     SGTimeStamp st;
                     st.stamp();
                     _directory->updateChildrenBasedOnHash();
-                    SG_LOG(SG_TERRASYNC, SG_INFO, "after update of:" << _directory->absolutePath() << " child update took:" << st.elapsedMSec());
+                    SG_LOG(SG_TERRASYNC, SG_DEBUG, "after update of:" << _directory->absolutePath() << " child update took:" << st.elapsedMSec());
                 } catch (sg_exception& ) {
-                    _directory->failedToUpdate(AbstractRepository::REPO_ERROR_IO);
+                    _directory->failedToUpdate(HTTPRepository::REPO_ERROR_IO);
                 }
             } else if (responseCode() == 404) {
-                _directory->failedToUpdate(AbstractRepository::REPO_ERROR_FILE_NOT_FOUND);
+                _directory->failedToUpdate(HTTPRepository::REPO_ERROR_FILE_NOT_FOUND);
             } else {
-                _directory->failedToUpdate(AbstractRepository::REPO_ERROR_HTTP);
+                _directory->failedToUpdate(HTTPRepository::REPO_ERROR_HTTP);
             }
 
             _directory->repository()->finishedRequest(this);
@@ -753,7 +826,7 @@ HTTPRepository::failure() const
         virtual void onFail()
         {
             if (_directory) {
-                _directory->failedToUpdate(AbstractRepository::REPO_ERROR_SOCKET);
+                _directory->failedToUpdate(HTTPRepository::REPO_ERROR_SOCKET);
                 _directory->repository()->finishedRequest(this);
             }
         }
@@ -778,15 +851,18 @@ HTTPRepository::failure() const
 
     HTTPRepoPrivate::~HTTPRepoPrivate()
     {
+        // take a copy since cancelRequest will fail and hence remove
+        // remove activeRequests, invalidating any iterator to it.
+        RequestVector copyOfActive(activeRequests);
+        RequestVector::iterator rq;
+        for (rq = copyOfActive.begin(); rq != copyOfActive.end(); ++rq) {
+            http->cancelRequest(*rq, "Repository object deleted");
+        }
+
         DirectoryVector::iterator it;
         for (it=directories.begin(); it != directories.end(); ++it) {
             delete *it;
         }
-
-        RequestVector::iterator r;
-        for (r=activeRequests.begin(); r != activeRequests.end(); ++r) {
-            (*r)->cancel();
-        }
     }
 
     HTTP::Request_ptr HTTPRepoPrivate::updateFile(HTTPDirectory* dir, const std::string& name, size_t sz)
@@ -809,7 +885,7 @@ HTTPRepository::failure() const
     class HashEntryWithPath
     {
     public:
-        HashEntryWithPath(const std::string& p) : path(p) {}
+        HashEntryWithPath(const SGPath& p) : path(p.utf8Str()) {}
         bool operator()(const HTTPRepoPrivate::HashCacheEntry& entry) const
         { return entry.filePath == path; }
     private:
@@ -818,7 +894,7 @@ HTTPRepository::failure() const
 
     std::string HTTPRepoPrivate::hashForPath(const SGPath& p)
     {
-        HashCache::iterator it = std::find_if(hashes.begin(), hashes.end(), HashEntryWithPath(p.str()));
+        HashCache::iterator it = std::find_if(hashes.begin(), hashes.end(), HashEntryWithPath(p));
         if (it != hashes.end()) {
             // ensure data on disk hasn't changed.
             // we could also use the file type here if we were paranoid
@@ -843,7 +919,7 @@ HTTPRepository::failure() const
         sha1_init(&info);
         char* buf = static_cast<char*>(malloc(1024 * 1024));
         size_t readLen;
-        SGBinaryFile f(p.str());
+        SGBinaryFile f(p);
         if (!f.open(SG_IO_IN)) {
             throw sg_io_exception("Couldn't open file for compute hash", p);
         }
@@ -860,7 +936,7 @@ HTTPRepository::failure() const
     void HTTPRepoPrivate::updatedFileContents(const SGPath& p, const std::string& newHash)
     {
         // remove the existing entry
-        HashCache::iterator it = std::find_if(hashes.begin(), hashes.end(), HashEntryWithPath(p.str()));
+        HashCache::iterator it = std::find_if(hashes.begin(), hashes.end(), HashEntryWithPath(p));
         if (it != hashes.end()) {
             hashes.erase(it);
             hashCacheDirty = true;
@@ -876,7 +952,7 @@ HTTPRepository::failure() const
         p2.set_cached(true);
 
         HashCacheEntry entry;
-        entry.filePath = p.str();
+        entry.filePath = p.utf8Str();
         entry.hashHex = newHash;
         entry.modTime = p2.modTime();
         entry.lengthBytes = p2.sizeInBytes();
@@ -893,8 +969,7 @@ HTTPRepository::failure() const
 
         SGPath cachePath = basePath;
         cachePath.append(".hashes");
-
-        std::ofstream stream(cachePath.c_str(),std::ios::out | std::ios::trunc);
+        sg_ofstream stream(cachePath, std::ios::out | std::ios::trunc);
         HashCache::const_iterator it;
         for (it = hashes.begin(); it != hashes.end(); ++it) {
             stream << it->filePath << ":" << it->modTime << ":"
@@ -913,7 +988,7 @@ HTTPRepository::failure() const
             return;
         }
 
-        std::ifstream stream(cachePath.c_str(), std::ios::in);
+        sg_ifstream stream(cachePath, std::ios::in);
 
         while (!stream.eof()) {
             std::string line;
@@ -924,7 +999,7 @@ HTTPRepository::failure() const
 
             string_list tokens = simgear::strutils::split( line, ":" );
             if( tokens.size() < 4 ) {
-                SG_LOG(SG_TERRASYNC, SG_WARN, "invalid entry in '" << cachePath.str() << "': '" << line << "' (ignoring line)");
+                SG_LOG(SG_TERRASYNC, SG_WARN, "invalid entry in '" << cachePath << "': '" << line << "' (ignoring line)");
                 continue;
             }
             const std::string nameData = simgear::strutils::strip(tokens[0]);
@@ -933,7 +1008,7 @@ HTTPRepository::failure() const
             const std::string hashData = simgear::strutils::strip(tokens[3]);
 
             if (nameData.empty() || timeData.empty() || sizeData.empty() || hashData.empty() ) {
-                SG_LOG(SG_TERRASYNC, SG_WARN, "invalid entry in '" << cachePath.str() << "': '" << line << "' (ignoring line)");
+                SG_LOG(SG_TERRASYNC, SG_WARN, "invalid entry in '" << cachePath << "': '" << line << "' (ignoring line)");
                 continue;
             }
 
@@ -951,7 +1026,7 @@ HTTPRepository::failure() const
     public:
         DirectoryWithPath(const std::string& p) : path(p) {}
         bool operator()(const HTTPDirectory* entry) const
-        { return entry->relativePath().str() == path; }
+        { return entry->relativePath() == path; }
     private:
         std::string path;
     };
@@ -978,10 +1053,11 @@ HTTPRepository::failure() const
             directories.erase(it);
             Dir dir(d->absolutePath());
             bool result = dir.remove(true);
-            delete d;
 
             // update the hash cache too
-            updatedFileContents(path, std::string());
+            updatedFileContents(d->absolutePath(), std::string());
+
+            delete d;
 
             return result;
         }
@@ -1002,10 +1078,11 @@ HTTPRepository::failure() const
     void HTTPRepoPrivate::finishedRequest(const RepoRequestPtr& req)
     {
         RequestVector::iterator it = std::find(activeRequests.begin(), activeRequests.end(), req);
-        if (it == activeRequests.end()) {
-            throw sg_exception("lost request somehow", req->url());
+        // in some cases, for example a checksum failure, we clear the active
+        // and queued request vectors, so the ::find above can fail
+        if (it != activeRequests.end()) {
+            activeRequests.erase(it);
         }
-        activeRequests.erase(it);
 
         if (!queuedRequests.empty()) {
             RepoRequestPtr rr = queuedRequests.front();
@@ -1021,15 +1098,36 @@ HTTPRepository::failure() const
         }
     }
 
-    void HTTPRepoPrivate::failedToGetRootIndex(AbstractRepository::ResultCode st)
+    void HTTPRepoPrivate::failedToGetRootIndex(HTTPRepository::ResultCode st)
     {
-        SG_LOG(SG_TERRASYNC, SG_WARN, "Failed to get root of repo:" << baseUrl);
+        SG_LOG(SG_TERRASYNC, SG_WARN, "Failed to get root of repo:" << baseUrl << " " << st);
         status = st;
     }
 
     void HTTPRepoPrivate::failedToUpdateChild(const SGPath& relativePath,
-                                              AbstractRepository::ResultCode fileStatus)
+                                              HTTPRepository::ResultCode fileStatus)
     {
+        if (fileStatus == HTTPRepository::REPO_ERROR_CHECKSUM) {
+            // stop updating, and mark repository as failed, becuase this
+            // usually indicates we need to start a fresh update from the
+            // root.
+            // (we could issue a retry here, but we leave that to higher layers)
+            status = fileStatus;
+
+            queuedRequests.clear();
+
+            RequestVector copyOfActive(activeRequests);
+            RequestVector::iterator rq;
+            for (rq = copyOfActive.begin(); rq != copyOfActive.end(); ++rq) {
+                //SG_LOG(SG_TERRASYNC, SG_DEBUG, "cancelling request for:" << (*rq)->url());
+                http->cancelRequest(*rq, "Repository updated failed");
+            }
+
+
+            SG_LOG(SG_TERRASYNC, SG_WARN, "failed to update repository:" << baseUrl
+                   << ", possibly modified during sync");
+        }
+
         Failure f;
         f.path = relativePath;
         f.error = fileStatus;
@@ -1038,6 +1136,4 @@ HTTPRepository::failure() const
         SG_LOG(SG_TERRASYNC, SG_WARN, "failed to update entry:" << relativePath << " code:" << fileStatus);
     }
 
-
-
 } // of namespace simgear

simgear/io/HTTPRepository.hxx

@@ -20,16 +20,30 @@
 #ifndef SG_IO_HTTP_REPOSITORY_HXX
 #define SG_IO_HTTP_REPOSITORY_HXX
 
-#include <simgear/io/AbstractRepository.hxx>
 #include <memory>
 
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/io/HTTPClient.hxx>
+
 namespace simgear  {
 
 class HTTPRepoPrivate;
 
-class HTTPRepository : public AbstractRepository
+class HTTPRepository
 {
 public:
+    enum ResultCode {
+        REPO_NO_ERROR = 0,
+        REPO_ERROR_NOT_FOUND,
+        REPO_ERROR_SOCKET,
+        SVN_ERROR_XML,
+        SVN_ERROR_TXDELTA,
+        REPO_ERROR_IO,
+        REPO_ERROR_CHECKSUM,
+        REPO_ERROR_FILE_NOT_FOUND,
+        REPO_ERROR_HTTP,
+        REPO_PARTIAL_UPDATE
+    };
 
     HTTPRepository(const SGPath& root, HTTP::Client* cl);
     virtual ~HTTPRepository();
@@ -50,10 +64,16 @@ public:
     virtual size_t bytesToDownload() const;
 
     virtual size_t bytesDownloaded() const;
+
+    /**
+     * optionally provide the location of an installer copy of this
+     * repository. When a file is missing it will be copied from this tree.
+     */
+    void setInstalledCopyPath(const SGPath& copyPath);
 private:
     bool isBare() const;
 
-    std::auto_ptr<HTTPRepoPrivate> _d;
+    std::unique_ptr<HTTPRepoPrivate> _d;
 };
 
 } // of namespace simgear

simgear/io/HTTPRequest.cxx

@@ -132,15 +132,15 @@ Request::HTTPVersion decodeHTTPVersion(const std::string& v)
 //------------------------------------------------------------------------------
 void Request::responseStart(const std::string& r)
 {
-    const int maxSplit = 2; // HTTP/1.1 nnn reason-string
+    const int maxSplit = 2; // HTTP/1.1 nnn reason-string?
     string_list parts = strutils::split(r, NULL, maxSplit);
-    if (parts.size() != 3) {
+    if (parts.size() < 2) {
         throw sg_io_exception("bad HTTP response:" + r);
     }
 
     _responseVersion = decodeHTTPVersion(parts[0]);
     _responseStatus = strutils::to_int(parts[1]);
-    _responseReason = parts[2];
+    _responseReason = parts.size() > 2 ? parts[2] : "";
 
     setReadyState(STATUS_RECEIVED);
 }

simgear/io/SVNDirectory.cxx

@@ -1,400 +0,0 @@
-
-#include "SVNDirectory.hxx"
-
-#include <cassert>
-#include <fstream>
-#include <iostream>
-#include <boost/foreach.hpp>
-
-#include <simgear/debug/logstream.hxx>
-#include <simgear/misc/strutils.hxx>
-#include <simgear/misc/sg_dir.hxx>
-#include <simgear/io/HTTPClient.hxx>
-#include <simgear/io/DAVMultiStatus.hxx>
-#include <simgear/io/SVNRepository.hxx>
-#include <simgear/io/sg_file.hxx>
-#include <simgear/io/SVNReportParser.hxx>
-#include <simgear/package/md5.h>
-#include <simgear/structure/exception.hxx>
-
-using std::string;
-using std::cout;
-using std::endl;
-using namespace simgear;
-
-typedef std::vector<HTTP::Request_ptr> RequestVector;
-typedef std::map<std::string, DAVResource*> DAVResourceMap;
-
-
-const char* DAV_CACHE_NAME = ".terrasync_cache";
-const char* CACHE_VERSION_4_TOKEN = "terrasync-cache-4";
-
-// important: with the Google servers, setting this higher than '1' causes
-// server internal errors (500, the connection is closed). In other words we
-// can only specify update report items one level deep at most and no more.
-// (the root and its direct children, not NOT grand-children)
-const unsigned int MAX_UPDATE_REPORT_DEPTH = 1;
-
-enum LineState
-{
-  LINESTATE_HREF = 0,
-  LINESTATE_VERSIONNAME
-};
-
-SVNDirectory::SVNDirectory(SVNRepository *r, const SGPath& path) :
-  localPath(path),
-  dav(NULL),
-  repo(r),
-  _doingUpdateReport(false),
-  _parent(NULL)
-{
-  if (path.exists()) {
-    parseCache();
-  } 
-  
-  // don't create dir here, repo might not exist at all
-}
-  
-SVNDirectory::SVNDirectory(SVNDirectory* pr, DAVCollection* col) :
-  dav(col),
-  repo(pr->repository()),
-  _doingUpdateReport(false),
-  _parent(pr)
-{
-  assert(col->container());
-  assert(!col->url().empty());
-  assert(_parent);
-
-  localPath = pr->fsDir().file(col->name());
-  if (!localPath.exists()) {
-    Dir d(localPath);
-    d.create(0755);
-    writeCache();
-  } else {
-    parseCache();
-  }
-}
-
-SVNDirectory::~SVNDirectory()
-{
-    // recursive delete our child directories
-    BOOST_FOREACH(SVNDirectory* d, _children) {
-        delete d;
-    }
-}
-
-void SVNDirectory::parseCache()
-{
-  SGPath p(localPath);
-  p.append(DAV_CACHE_NAME);
-  if (!p.exists()) {
-    return;
-  }
-    
-  char href[1024];
-  char versionName[128];
-  LineState lineState = LINESTATE_HREF;
-  std::ifstream file(p.c_str());
-    if (!file.is_open()) {
-        SG_LOG(SG_TERRASYNC, SG_WARN, "unable to open cache file for reading:" << p);
-        return;
-    }
-  bool doneSelf = false;
-    
-  file.getline(href, 1024);
-  if (strcmp(CACHE_VERSION_4_TOKEN, href)) {
-    SG_LOG(SG_TERRASYNC, SG_WARN, "invalid cache file [missing header token]:" << p << " '" << href << "'");
-    return;
-  }
-    
-    std::string vccUrl;
-    file.getline(href, 1024);
-    vccUrl = href;
-    
-  while (!file.eof()) {
-    if (lineState == LINESTATE_HREF) {
-      file.getline(href, 1024);
-      lineState = LINESTATE_VERSIONNAME;
-    } else {
-      assert(lineState == LINESTATE_VERSIONNAME);
-      file.getline(versionName, 1024);
-      lineState = LINESTATE_HREF;
-      char* hrefPtr = href;
-    
-      if (!doneSelf) {
-        if (!dav) {
-          dav = new DAVCollection(hrefPtr);
-          dav->setVersionName(versionName);
-        } else {
-          assert(string(hrefPtr) == dav->url());
-        }
-        
-        if (!vccUrl.empty()) {
-            dav->setVersionControlledConfiguration(vccUrl);
-        }
-        
-        _cachedRevision = versionName;
-        doneSelf = true;
-      } else {
-        DAVResource* child = parseChildDirectory(hrefPtr)->collection();
-          string s = strutils::strip(versionName);
-          if (!s.empty()) {
-              child->setVersionName(versionName);
-          }
-      } // of done self test
-    } // of line-state switching 
-  } // of file get-line loop
-}
-  
-void SVNDirectory::writeCache()
-{
-  SGPath p(localPath);
-  if (!p.exists()) {
-      Dir d(localPath);
-      d.create(0755);
-  }
-  
-  p.append(string(DAV_CACHE_NAME) + ".new");
-    
-  std::ofstream file(p.c_str(), std::ios::trunc);
-// first, cache file version header
-  file << CACHE_VERSION_4_TOKEN << '\n';
- 
-// second, the repository VCC url
-  file << dav->versionControlledConfiguration() << '\n';
-      
-// third, our own URL, and version
-  file << dav->url() << '\n' << _cachedRevision << '\n';
-  
-  BOOST_FOREACH(DAVResource* child, dav->contents()) {
-    if (child->isCollection()) {
-        file << child->name() << '\n' << child->versionName() << "\n";
-    }
-  } // of child iteration
-    
-    file.close();
-    
-// approximately atomic delete + rename operation
-    SGPath cacheName(localPath);
-    cacheName.append(DAV_CACHE_NAME);
-    p.rename(cacheName);
-}
-
-void SVNDirectory::setBaseUrl(const string& url)
-{
-    if (_parent) {
-        SG_LOG(SG_TERRASYNC, SG_ALERT, "setting base URL on non-root directory " << url);
-        return;
-    }
-    
-    if (dav && (url == dav->url())) {
-        return;
-    }
-    
-    dav = new DAVCollection(url);
-}
-
-std::string SVNDirectory::url() const
-{
-  if (!_parent) {
-    return repo->baseUrl();
-  }
-  
-  return _parent->url() + "/" + name();
-}
-
-std::string SVNDirectory::name() const
-{
-    return dav->name();
-} 
-
-DAVResource*
-SVNDirectory::addChildFile(const std::string& fileName)
-{
-    DAVResource* child = NULL;
-    child = new DAVResource(dav->urlForChildWithName(fileName));
-    dav->addChild(child);
-  
-    writeCache();
-    return child;
-}
-
-SVNDirectory*
-SVNDirectory::addChildDirectory(const std::string& dirName)
-{
-    if (dav->childWithName(dirName)) {
-        // existing child, let's remove it
-        deleteChildByName(dirName);
-    }
-    
-    DAVCollection* childCol = dav->createChildCollection(dirName);
-    SVNDirectory* child = new SVNDirectory(this, childCol);
-    childCol->setVersionName(child->cachedRevision());
-    _children.push_back(child);
-    writeCache();
-    return child;
-}
-
-SVNDirectory*
-SVNDirectory::parseChildDirectory(const std::string& dirName)
-{
-    assert(!dav->childWithName(dirName));
-    DAVCollection* childCol = dav->createChildCollection(dirName);
-    SVNDirectory* child = new SVNDirectory(this, childCol);
-    childCol->setVersionName(child->cachedRevision());
-    _children.push_back(child);
-    return child;
-}
-
-void SVNDirectory::deleteChildByName(const std::string& nm)
-{
-    DAVResource* child = dav->childWithName(nm);
-    if (!child) {
-        return;
-    }
-
-    SGPath path = fsDir().file(nm);
-    
-    if (child->isCollection()) {
-        Dir d(path);
-        bool ok = d.remove(true);
-        if (!ok) {
-            SG_LOG(SG_TERRASYNC, SG_ALERT, "SVNDirectory::deleteChildByName: failed to remove dir:"
-                   << nm << " at path:\n\t" << path);
-        }
-
-        DirectoryList::iterator it = findChildDir(nm);
-        if (it != _children.end()) {
-            SVNDirectory* c = *it;
-            delete c;
-            _children.erase(it);
-        }
-    } else {
-        bool ok = path.remove();
-        if (!ok) {
-            SG_LOG(SG_TERRASYNC, SG_ALERT, "SVNDirectory::deleteChildByName: failed to remove path:" << nm
-                   << " at path:\n\t" << path);
-        }
-    }
-
-    dav->removeChild(child);
-    delete child;
-
-    writeCache();
-}
-  
-bool SVNDirectory::isDoingSync() const
-{
-  if (_doingUpdateReport) {
-      return true;
-  } 
-
-  BOOST_FOREACH(SVNDirectory* child, _children) {
-      if (child->isDoingSync()) {
-          return true;
-      } // of children
-  }
-    
-  return false;
-}
-
-void SVNDirectory::beginUpdateReport()
-{
-    _doingUpdateReport = true;
-    _cachedRevision.clear();
-    writeCache();
-}
-
-void SVNDirectory::updateReportComplete()
-{
-    _cachedRevision = dav->versionName();
-    _doingUpdateReport = false;
-    writeCache();
-    
-    SVNDirectory* pr = parent();
-    if (pr) {
-        pr->writeCache();
-    }    
-}
-
-SVNRepository* SVNDirectory::repository() const
-{
-    return repo;
-}
-
-void SVNDirectory::mergeUpdateReportDetails(unsigned int depth, 
-    string_list& items)
-{
-    // normal, easy case: we are fully in-sync at a revision
-    if (!_cachedRevision.empty()) {
-        std::ostringstream os;
-        os << "<S:entry rev=\"" << _cachedRevision << "\" depth=\"infinity\">"
-            << repoPath() << "</S:entry>";
-        items.push_back(os.str());
-        return;
-    }
-    
-    Dir d(localPath);
-    if (depth >= MAX_UPDATE_REPORT_DEPTH) {
-        d.removeChildren();
-        return;
-    }
-    
-    PathList cs = d.children(Dir::NO_DOT_OR_DOTDOT | Dir::INCLUDE_HIDDEN | Dir::TYPE_DIR);
-    BOOST_FOREACH(SGPath path, cs) {
-        SVNDirectory* c = child(path.file());
-        if (!c) {
-            // ignore this child, if it's an incomplete download,
-            // it will be over-written on the update anyway
-            //std::cerr << "unknown SVN child" << path << std::endl;
-        } else {
-            // recurse down into children
-            c->mergeUpdateReportDetails(depth+1, items);
-        }
-    } // of child dir iteration
-}
-
-std::string SVNDirectory::repoPath() const
-{
-    if (!_parent) {
-        return "/";
-    }
-    
-    // find the length of the repository base URL, then
-    // trim that off our repo URL - job done!
-    size_t baseUrlLen = repo->baseUrl().size();
-    return dav->url().substr(baseUrlLen + 1);
-}
-
-SVNDirectory* SVNDirectory::parent() const
-{
-    return _parent;
-}
-
-SVNDirectory* SVNDirectory::child(const std::string& dirName) const
-{
-    BOOST_FOREACH(SVNDirectory* d, _children) {
-        if (d->name() == dirName) {
-            return d;
-        }
-    }
-    
-    return NULL;
-}
-
-DirectoryList::iterator
-SVNDirectory::findChildDir(const std::string& dirName)
-{
-    DirectoryList::iterator it;
-    for (it=_children.begin(); it != _children.end(); ++it) {
-        if ((*it)->name() == dirName) {
-            return it;
-        }
-    }
-    return it;
-}
-
-simgear::Dir SVNDirectory::fsDir() const
-{
-    return Dir(localPath);
-}

simgear/io/SVNDirectory.hxx

@@ -1,109 +0,0 @@
-// DAVCollectionMirror.hxx - mirror a DAV collection to the local filesystem
-//
-// Copyright (C) 2013  James Turner <zakalawe@mac.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-
-#ifndef SG_IO_DAVCOLLECTIONMIRROR_HXX
-#define SG_IO_DAVCOLLECTIONMIRROR_HXX
-
-#include <string>
-#include <vector>
-#include <memory>
-
-#include <simgear/misc/sg_path.hxx>
-#include <simgear/misc/strutils.hxx>
-#include <simgear/io/DAVMultiStatus.hxx>
-
-namespace simgear  {
-
-class Dir;
-namespace HTTP { class Request; }
-
-// forward decls
-class DAVMirror;
-class SVNRepository;
-class SVNDirectory;
-
-typedef std::vector<SVNDirectory*> DirectoryList;
-
-class SVNDirectory
-{
-public:
-  // init from local
-  SVNDirectory(SVNRepository *repo, const SGPath& path);
-  ~SVNDirectory();
-  
-  void setBaseUrl(const std::string& url);
-  
-  // init from a collection
-  SVNDirectory(SVNDirectory* pr, DAVCollection* col);
-
-  void beginUpdateReport();
-  void updateReportComplete();
-  
-  bool isDoingSync() const;
-  
-  std::string url() const;
-  
-  std::string name() const;
-      
-  DAVResource* addChildFile(const std::string& fileName);
-  SVNDirectory* addChildDirectory(const std::string& dirName);
-      
- // void updateChild(DAVResource* child);
-  void deleteChildByName(const std::string& name);
-  
-  SGPath fsPath() const
-    { return localPath; }
-  
-  simgear::Dir fsDir() const;
-  
-  std::string repoPath() const;
-    
-  SVNRepository* repository() const;
-  DAVCollection* collection() const
-    { return dav; }
-  
-  std::string cachedRevision() const
-      { return _cachedRevision; }
-  
-  void mergeUpdateReportDetails(unsigned int depth, string_list& items);
-  
-  SVNDirectory* parent() const;
-  SVNDirectory* child(const std::string& dirName) const;
-private:
-  
-  void parseCache();
-  void writeCache();
-  
-  DirectoryList::iterator findChildDir(const std::string& dirName);
-  SVNDirectory* parseChildDirectory(const std::string& dirName);
-
-  SGPath localPath;
-  DAVCollection* dav;
-  SVNRepository* repo;
-  
-  std::string _cachedRevision;
-  bool _doingUpdateReport;
-  
-  SVNDirectory* _parent;
-  DirectoryList _children;
-};
-
-} // of namespace simgear
-
-#endif // of SG_IO_DAVCOLLECTIONMIRROR_HXX

simgear/io/SVNReportParser.cxx

@@ -1,605 +0,0 @@
-// SVNReportParser -- parser for SVN report XML data
-//
-// Copyright (C) 2012  James Turner <zakalawe@mac.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-#ifdef HAVE_CONFIG_H
-#  include <simgear_config.h>
-#endif
-     
-#include "SVNReportParser.hxx"
-
-#include <iostream>
-#include <cstring>
-#include <cassert>
-#include <algorithm>
-#include <sstream>
-#include <fstream>
-
-#include <boost/foreach.hpp>
-
-#include "simgear/misc/sg_path.hxx"
-#include "simgear/misc/sg_dir.hxx"
-#include "simgear/debug/logstream.hxx"
-#include "simgear/xml/easyxml.hxx"
-#include "simgear/misc/strutils.hxx"
-#include "simgear/package/md5.h"
-
-#ifdef SYSTEM_EXPAT
-#  include <expat.h>
-#else
-#  include "sg_expat.h"     
-#endif
-
-#include "SVNDirectory.hxx"
-#include "SVNRepository.hxx"
-#include "DAVMultiStatus.hxx"
-
-using std::cout;
-using std::cerr;
-using std::endl;
-using std::string;
-
-using namespace simgear;
-
-#define DAV_NS "DAV::"
-#define SVN_NS "svn::"
-#define SUBVERSION_DAV_NS "http://subversion.tigris.org/xmlns/dav/"
-
-namespace {
-    
-    #define MAX_ENCODED_INT_LEN 10
-    
-    static size_t
-    decode_size(unsigned char* &p,
-                const unsigned char *end)
-    {
-      if (p + MAX_ENCODED_INT_LEN < end)
-        end = p + MAX_ENCODED_INT_LEN;
-      /* Decode bytes until we're done.  */
-      size_t result = 0;
-      
-      while (p < end) {
-          result = (result << 7) | (*p & 0x7f);
-          if (((*p++ >> 7) & 0x1) == 0) {
-              break;
-          }
-      }
-      
-      return result;
-    }
-    
-    static bool
-    try_decode_size(unsigned char* &p,
-                const unsigned char *end)
-    {
-      if (p + MAX_ENCODED_INT_LEN < end)
-        end = p + MAX_ENCODED_INT_LEN;
-
-      while (p < end) {
-          if (((*p++ >> 7) & 0x1) == 0) {
-              return true;
-          }
-      }
-      
-      return false;
-    }
-    
-//  const char* SVN_UPDATE_REPORT_TAG = SVN_NS "update-report";
- // const char* SVN_TARGET_REVISION_TAG = SVN_NS "target-revision";
-  const char* SVN_OPEN_DIRECTORY_TAG = SVN_NS "open-directory";
-  const char* SVN_OPEN_FILE_TAG = SVN_NS "open-file";
-  const char* SVN_ADD_DIRECTORY_TAG = SVN_NS "add-directory";
-  const char* SVN_ADD_FILE_TAG = SVN_NS "add-file";
-  const char* SVN_TXDELTA_TAG = SVN_NS "txdelta";
-  const char* SVN_SET_PROP_TAG = SVN_NS "set-prop";
-  const char* SVN_PROP_TAG = SVN_NS "prop";
-  const char* SVN_DELETE_ENTRY_TAG = SVN_NS "delete-entry";
-  
-  const char* SVN_DAV_MD5_CHECKSUM = SUBVERSION_DAV_NS ":md5-checksum";
-  
-  const char* DAV_HREF_TAG = DAV_NS "href";
-  const char* DAV_CHECKED_IN_TAG = DAV_NS "checked-in";
-  
-
-  const int svn_txdelta_source = 0;
-  const int svn_txdelta_target = 1;
-  const int svn_txdelta_new = 2;
-
-  const size_t DELTA_HEADER_SIZE = 4;
-    
-  /**
-   * helper struct to decode and store the SVN delta header
-   * values
-   */
-  struct SVNDeltaWindow
-  {
-  public:
-
-      static bool isWindowComplete(unsigned char* buffer, size_t bytes)
-      {
-          unsigned char* p = buffer;
-          unsigned char* pEnd = p + bytes;
-          // if we can't decode five sizes, certainly incomplete
-          for (int i=0; i<5; i++) {
-              if (!try_decode_size(p, pEnd)) {
-                  return false;
-              }
-          }
-          
-          p = buffer;
-        // ignore these three
-          decode_size(p, pEnd);
-          decode_size(p, pEnd);
-          decode_size(p, pEnd);
-          size_t instructionLen = decode_size(p, pEnd);
-          size_t newLength = decode_size(p, pEnd);
-          size_t headerLength = p - buffer;
-          
-          return (bytes >= (instructionLen + newLength + headerLength));
-      }
-      
-     SVNDeltaWindow(unsigned char* p) :
-         headerLength(0),
-         _ptr(p)
-     {
-         sourceViewOffset = decode_size(p, p+20);
-         sourceViewLength = decode_size(p, p+20);
-         targetViewLength = decode_size(p, p+20);
-         instructionLength = decode_size(p, p+20);
-         newLength = decode_size(p, p+20);
-         
-         headerLength = p - _ptr;
-         _ptr = p;
-     }
-  
-    bool apply(std::vector<unsigned char>& output, std::istream& source)
-    {
-        unsigned char* pEnd = _ptr + instructionLength;
-        unsigned char* newData = pEnd;
-        
-        while (_ptr < pEnd) {
-          int op = ((*_ptr >> 6) & 0x3);  
-          if (op >= 3) {
-              SG_LOG(SG_IO, SG_INFO, "SVNDeltaWindow: bad opcode:" << op);
-              return false;
-          }
-      
-          int length = *_ptr++ & 0x3f;
-          int offset = 0;
-        
-          if (length == 0) {
-            length = decode_size(_ptr, pEnd);
-          }
-        
-          if (length == 0) {
-			SG_LOG(SG_IO, SG_INFO, "SVNDeltaWindow: malformed stream, 0 length" << op);
-            return false;
-          }
-      
-          // if op != new, decode another size value
-          if (op != svn_txdelta_new) {
-            offset = decode_size(_ptr, pEnd);
-          }
-
-          if (op == svn_txdelta_target) {
-              // this is inefficent, but ranges can overlap.
-              while (length > 0) {
-                  output.push_back(output[offset++]);
-                  --length;
-              }
-          } else if (op == svn_txdelta_new) {
-              output.insert(output.end(), newData, newData + length);
-              newData += length;
-          } else if (op == svn_txdelta_source) {
-            source.seekg(offset);
-            char* sourceBuf = (char*) malloc(length);
-            assert(sourceBuf);
-            source.read(sourceBuf, length);
-            output.insert(output.end(), sourceBuf, sourceBuf + length);
-            free(sourceBuf);
-          } else {
-              SG_LOG(SG_IO, SG_WARN, "bad opcode logic");
-              return false;
-          }
-        } // of instruction loop
-        
-        return true;
-    }  
-  
-    size_t size() const
-    {
-        return headerLength + instructionLength + newLength;
-    }
-  
-    unsigned int sourceViewOffset;
-    size_t sourceViewLength,
-      targetViewLength;
-    size_t headerLength,
-        instructionLength,
-        newLength;
-    
-private:  
-    unsigned char* _ptr;
-  };
-  
-  
-} // of anonymous namespace
-
-class SVNReportParser::SVNReportParserPrivate
-{
-public:
-  SVNReportParserPrivate(SVNRepository* repo) :
-    tree(repo),
-    status(AbstractRepository::REPO_NO_ERROR),
-    parserInited(false),
-    currentPath(repo->fsBase())
-  {
-    inFile = false;
-    currentDir = repo->rootDir();
-  }
-
-  ~SVNReportParserPrivate()
-  {
-  }
-  
-  void startElement (const char * name, const char** attributes)
-  {    
-      if (status != AbstractRepository::REPO_NO_ERROR) {
-          return;
-      }
-      
-    ExpatAtts attrs(attributes);
-    tagStack.push_back(name);
-    if (!strcmp(name, SVN_TXDELTA_TAG)) {
-        txDeltaData.clear();
-    } else if (!strcmp(name, SVN_ADD_FILE_TAG)) {
-      string fileName(attrs.getValue("name"));
-      SGPath filePath(currentDir->fsDir().file(fileName));
-      currentPath = filePath;
-      inFile = true;
-    } else if (!strcmp(name, SVN_OPEN_FILE_TAG)) {
-      string fileName(attrs.getValue("name"));
-      SGPath filePath(Dir(currentPath).file(fileName));
-      currentPath = filePath;
-       
-      if (!filePath.exists()) {
-          fail(AbstractRepository::REPO_ERROR_FILE_NOT_FOUND);
-          return;
-      }
-
-      inFile = true;
-    } else if (!strcmp(name, SVN_ADD_DIRECTORY_TAG)) {
-      string dirName(attrs.getValue("name"));
-      Dir d(currentDir->fsDir().file(dirName));
-      if (d.exists()) {
-          // policy decision : if we're doing an add, wipe the existing
-          d.remove(true);
-      }
-    
-      currentDir = currentDir->addChildDirectory(dirName);
-      currentPath = currentDir->fsPath();
-      currentDir->beginUpdateReport();
-      //cout << "addDir:" << currentPath << endl;
-    } else if (!strcmp(name, SVN_SET_PROP_TAG)) {
-      setPropName = attrs.getValue("name");
-      setPropValue.clear();
-    } else if (!strcmp(name, SVN_DAV_MD5_CHECKSUM)) {
-      md5Sum.clear();
-    } else if (!strcmp(name, SVN_OPEN_DIRECTORY_TAG)) {
-        string dirName;
-        if (attrs.getValue("name")) {
-            dirName = string(attrs.getValue("name"));
-        }
-        openDirectory(dirName);
-    } else if (!strcmp(name, SVN_DELETE_ENTRY_TAG)) {
-        string entryName(attrs.getValue("name"));
-        deleteEntry(entryName);
-    } else if (!strcmp(name, DAV_CHECKED_IN_TAG) ||
-               !strcmp(name, DAV_HREF_TAG) ||
-               !strcmp(name, SVN_PROP_TAG)) {
-        // don't warn on these ones
-    } else {
-        //SG_LOG(SG_IO, SG_WARN, "SVNReportParser: unhandled tag:" << name);
-    }
-  } // of startElement
-  
-  void openDirectory(const std::string& dirName)
-  {
-      if (dirName.empty()) {
-          // root directory, we shall assume
-          currentDir = tree->rootDir();
-      } else {
-          assert(currentDir);
-          currentDir = currentDir->child(dirName);
-      }
-      
-      assert(currentDir);
-      currentPath = currentDir->fsPath();
-      currentDir->beginUpdateReport();
-  }
-  
-  void deleteEntry(const std::string& entryName)
-  {
-      currentDir->deleteChildByName(entryName);
-  }
-  
-  bool decodeTextDelta(const SGPath& outputPath)
-  {
-      std::vector<unsigned char> output, decoded;
-    strutils::decodeBase64(txDeltaData, decoded);
-    size_t bytesToDecode = decoded.size();
-         
-    unsigned char* p = decoded.data();
-    if (memcmp(p, "SVN\0", DELTA_HEADER_SIZE) != 0) {
-        return false; // bad header
-    }
-    
-    bytesToDecode -= DELTA_HEADER_SIZE;
-    p += DELTA_HEADER_SIZE;
-    std::ifstream source;
-    source.open(outputPath.c_str(), std::ios::in | std::ios::binary);
-    
-    while (bytesToDecode > 0) {  
-        if (!SVNDeltaWindow::isWindowComplete(p, bytesToDecode)) {
-            SG_LOG(SG_IO, SG_WARN, "SVN txdelta broken window");
-            return false;
-        }
-	
-        SVNDeltaWindow window(p);      
-        assert(bytesToDecode >= window.size());
-        window.apply(output, source);
-        bytesToDecode -= window.size();
-        p += window.size();
-    }
-
-    source.close();
-
-    std::ofstream f;
-    f.open(outputPath.c_str(), 
-      std::ios::out | std::ios::trunc | std::ios::binary);
-    f.write((char*) output.data(), output.size());
-
-    // compute MD5 while we have the file in memory
-    memset(&md5Context, 0, sizeof(SG_MD5_CTX));
-    SG_MD5Init(&md5Context);
-    SG_MD5Update(&md5Context, (unsigned char*) output.data(), output.size());
-    unsigned char digest[MD5_DIGEST_LENGTH];
-    SG_MD5Final(digest, &md5Context);
-    decodedFileMd5 = strutils::encodeHex(digest, MD5_DIGEST_LENGTH);
-
-    return true;
-  }
-  
-  void endElement (const char * name)
-  {
-      if (status != SVNRepository::REPO_NO_ERROR) {
-          return;
-      }
-      
-    assert(tagStack.back() == name);
-    tagStack.pop_back();
-        
-    if (!strcmp(name, SVN_TXDELTA_TAG)) {
-      if (!decodeTextDelta(currentPath)) {
-        fail(SVNRepository::SVN_ERROR_TXDELTA);
-      }
-    } else if (!strcmp(name, SVN_ADD_FILE_TAG)) {
-      finishFile(currentPath);
-    } else if (!strcmp(name, SVN_OPEN_FILE_TAG)) {
-      finishFile(currentPath);
-    } else if (!strcmp(name, SVN_ADD_DIRECTORY_TAG)) {
-      // pop directory
-      currentPath = currentPath.dir();
-      currentDir->updateReportComplete();
-      currentDir = currentDir->parent();
-    } else if (!strcmp(name, SVN_SET_PROP_TAG)) {
-      if (setPropName == "svn:entry:committed-rev") {
-        revision = strutils::to_int(setPropValue);
-        currentVersionName = setPropValue;
-        if (!inFile) {
-          // for directories we have the resource already
-          // for adding files, we might not; we set the version name
-          // above when ending the add/open-file element
-          currentDir->collection()->setVersionName(currentVersionName);
-        } 
-      }
-    } else if (!strcmp(name, SVN_DAV_MD5_CHECKSUM)) {
-      // validate against (presumably) just written file
-      if (decodedFileMd5 != md5Sum) {
-        fail(SVNRepository::REPO_ERROR_CHECKSUM);
-      }
-    } else if (!strcmp(name, SVN_OPEN_DIRECTORY_TAG)) {
-        currentDir->updateReportComplete();
-        if (currentDir->parent()) {   
-          // pop the collection stack
-          currentDir = currentDir->parent();
-        }
-        
-        currentPath = currentDir->fsPath();
-    } else {
-    //  std::cout << "element:" << name;
-    }
-  }
-  
-  void finishFile(const SGPath& path)
-  {
-      currentPath = path.dir();
-      inFile = false;
-  }
-  
-  void data (const char * s, int length)
-  {
-      if (status != SVNRepository::REPO_NO_ERROR) {
-          return;
-      }
-      
-    if (tagStack.back() == SVN_SET_PROP_TAG) {
-      setPropValue.append(s, length);
-    } else if (tagStack.back() == SVN_TXDELTA_TAG) {
-      txDeltaData.append(s, length);
-    } else if (tagStack.back() == SVN_DAV_MD5_CHECKSUM) {
-      md5Sum.append(s, length);
-    }
-  }
-  
-  void pi (const char * target, const char * data) {}
-  
-  string tagN(const unsigned int n) const
-  {
-    size_t sz = tagStack.size();
-    if (n >= sz) {
-      return string();
-    }
-    
-    return tagStack[sz - (1 + n)];
-  }
-  
-  void fail(SVNRepository::ResultCode err)
-  {
-      status = err;
-  }
-  
-  SVNRepository* tree;
-  DAVCollection* rootCollection;
-  SVNDirectory* currentDir;
-  SVNRepository::ResultCode status;
-  
-  bool parserInited;
-  XML_Parser xmlParser;
-  
-// in-flight data
-  string_list tagStack;
-  string currentVersionName;
-  string txDeltaData;
-  SGPath currentPath;
-  bool inFile;
-    
-  unsigned int revision;
-  SG_MD5_CTX md5Context;
-  string md5Sum, decodedFileMd5;
-  std::string setPropName, setPropValue;
-};
-
-
-////////////////////////////////////////////////////////////////////////
-// Static callback functions for Expat.
-////////////////////////////////////////////////////////////////////////
-
-#define VISITOR static_cast<SVNReportParser::SVNReportParserPrivate *>(userData)
-
-static void
-start_element (void * userData, const char * name, const char ** atts)
-{
-  VISITOR->startElement(name, atts);
-}
-
-static void
-end_element (void * userData, const char * name)
-{
-  VISITOR->endElement(name);
-}
-
-static void
-character_data (void * userData, const char * s, int len)
-{
-  VISITOR->data(s, len);
-}
-
-static void
-processing_instruction (void * userData,
-                        const char * target,
-                        const char * data)
-{
-  VISITOR->pi(target, data);
-}
-
-#undef VISITOR
-
-///////////////////////////////////////////////////////////////////////////////
-
-SVNReportParser::SVNReportParser(SVNRepository* repo) :
-  _d(new SVNReportParserPrivate(repo))
-{
-  
-}
-
-SVNReportParser::~SVNReportParser()
-{
-}
-
-SVNRepository::ResultCode
-SVNReportParser::innerParseXML(const char* data, int size)
-{
-    if (_d->status != SVNRepository::REPO_NO_ERROR) {
-        return _d->status;
-    }
-    
-    bool isEnd = (data == NULL);
-    if (!XML_Parse(_d->xmlParser, data, size, isEnd)) {
-      SG_LOG(SG_IO, SG_INFO, "SVN parse error:" << XML_ErrorString(XML_GetErrorCode(_d->xmlParser))
-             << " at line:" << XML_GetCurrentLineNumber(_d->xmlParser)
-             << " column " << XML_GetCurrentColumnNumber(_d->xmlParser));
-    
-      XML_ParserFree(_d->xmlParser);
-      _d->parserInited = false;
-      return SVNRepository::SVN_ERROR_XML;
-    } else if (isEnd) {
-        XML_ParserFree(_d->xmlParser);
-        _d->parserInited = false;
-    }
-
-    return _d->status;
-}
-
-SVNRepository::ResultCode
-SVNReportParser::parseXML(const char* data, int size)
-{
-    if (_d->status != SVNRepository::REPO_NO_ERROR) {
-        return _d->status;
-    }
-    
-  if (!_d->parserInited) {
-    _d->xmlParser = XML_ParserCreateNS(0, ':');
-    XML_SetUserData(_d->xmlParser, _d.get());
-    XML_SetElementHandler(_d->xmlParser, start_element, end_element);
-    XML_SetCharacterDataHandler(_d->xmlParser, character_data);
-    XML_SetProcessingInstructionHandler(_d->xmlParser, processing_instruction);
-    _d->parserInited = true;
-  }
-  
-  return innerParseXML(data, size);
-}
-
-SVNRepository::ResultCode SVNReportParser::finishParse()
-{
-    if (_d->status != SVNRepository::REPO_NO_ERROR) {
-        return _d->status;
-    }
-    
-    return innerParseXML(NULL, 0);
-}
-
-std::string SVNReportParser::etagFromRevision(unsigned int revision)
-{
-  // etags look like W/"7//", hopefully this is stable
-  // across different servers and similar
-  std::ostringstream os;
-  os << "W/\"" << revision << "//";
-  return os.str();
-}
-
-

simgear/io/SVNReportParser.hxx

@@ -1,57 +0,0 @@
-// SVNReportParser -- parser for SVN report XML data
-//
-// Copyright (C) 2012  James Turner <zakalawe@mac.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-
-#ifndef SG_IO_SVNREPORTPARSER_HXX
-#define SG_IO_SVNREPORTPARSER_HXX
-
-#include <string>
-#include <memory> // for auto_ptr
-
-#include "SVNRepository.hxx"
-
-class SGPath;
-
-namespace simgear
-{
-  
-class SVNRepository;
-
-class SVNReportParser
-{
-public:
-  SVNReportParser(SVNRepository* repo);
-  ~SVNReportParser();
-  
-  // incremental XML parsing
-  SVNRepository::ResultCode parseXML(const char* data, int size);
-  
-  SVNRepository::ResultCode finishParse();
-        
-  static std::string etagFromRevision(unsigned int revision);
-          
-  class SVNReportParserPrivate;
-private:
-    SVNRepository::ResultCode innerParseXML(const char* data, int size);
-        
-  std::auto_ptr<SVNReportParserPrivate> _d;
-};
-
-} // of namespace simgear
-
-#endif // of SG_IO_SVNREPORTPARSER_HXX

simgear/io/SVNRepository.cxx

@@ -1,386 +0,0 @@
-// DAVMirrorTree -- mirror a DAV tree to the local file-system
-//
-// Copyright (C) 2012  James Turner <zakalawe@mac.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-#include "SVNRepository.hxx"
-
-#include <iostream>
-#include <cstring>
-#include <cassert>
-#include <algorithm>
-#include <sstream>
-#include <map>
-#include <set>
-#include <fstream>
-#include <memory>
-
-#include <boost/foreach.hpp>
-
-#include "simgear/debug/logstream.hxx"
-#include "simgear/misc/strutils.hxx"
-#include <simgear/misc/sg_dir.hxx>
-#include <simgear/io/HTTPClient.hxx>
-#include <simgear/io/DAVMultiStatus.hxx>
-#include <simgear/io/SVNDirectory.hxx>
-#include <simgear/io/sg_file.hxx>
-#include <simgear/io/SVNReportParser.hxx>
-
-using std::cout;
-using std::cerr;
-using std::endl;
-using std::string;
-
-namespace simgear
-{
-
-typedef std::vector<HTTP::Request_ptr> RequestVector;
-
-class SVNRepoPrivate
-{
-public:
-    SVNRepoPrivate(SVNRepository* parent) :
-        p(parent),
-        isUpdating(false),
-        status(SVNRepository::REPO_NO_ERROR)
-    { ; }
-
-    SVNRepository* p; // link back to outer
-    SVNDirectory* rootCollection;
-    HTTP::Client* http;
-    std::string baseUrl;
-    std::string vccUrl;
-    std::string targetRevision;
-    bool isUpdating;
-    SVNRepository::ResultCode status;
-
-    void svnUpdateDone()
-    {
-        isUpdating = false;
-    }
-
-    void updateFailed(HTTP::Request* req, SVNRepository::ResultCode err)
-    {
-        SG_LOG(SG_TERRASYNC, SG_WARN, "SVN: failed to update from:" << req->url()
-            << "\n(repository:" << p->baseUrl() << ")");
-        isUpdating = false;
-        status = err;
-    }
-
-    void propFindComplete(HTTP::Request* req, DAVCollection* col);
-    void propFindFailed(HTTP::Request* req, SVNRepository::ResultCode err);
-};
-
-
-namespace { // anonmouse
-
-    string makeAbsoluteUrl(const string& url, const string& base)
-    {
-      if (strutils::starts_with(url, "http://"))
-        return url; // already absolute
-
-      assert(strutils::starts_with(base, "http://"));
-      int schemeEnd = base.find("://");
-      int hostEnd = base.find('/', schemeEnd + 3);
-      if (hostEnd < 0) {
-        return url;
-      }
-
-      return base.substr(0, hostEnd) + url;
-    }
-
-    // keep the responses small by only requesting the properties we actually
-    // care about; the ETag, length and MD5-sum
-    const char* PROPFIND_REQUEST_BODY =
-      "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
-      "<D:propfind xmlns:D=\"DAV:\">"
-      "<D:prop xmlns:R=\"http://subversion.tigris.org/xmlns/dav/\">"
-      "<D:resourcetype/>"
-      "<D:version-name/>"
-      "<D:version-controlled-configuration/>"
-      "</D:prop>"
-      "</D:propfind>";
-
-    class PropFindRequest : public HTTP::Request
-    {
-    public:
-      PropFindRequest(SVNRepoPrivate* repo) :
-        Request(repo->baseUrl, "PROPFIND"),
-        _repo(repo)
-      {
-        assert(repo);
-        requestHeader("Depth") = "0";
-        setBodyData( PROPFIND_REQUEST_BODY,
-                     "application/xml; charset=\"utf-8\"" );
-      }
-
-    protected:
-      virtual void responseHeadersComplete()
-      {
-        if (responseCode() == 207) {
-            // fine
-        } else if (responseCode() == 404) {
-            _repo->propFindFailed(this, SVNRepository::REPO_ERROR_NOT_FOUND);
-        } else {
-            SG_LOG(SG_TERRASYNC, SG_WARN, "request for:" << url() <<
-                " return code " << responseCode());
-            _repo->propFindFailed(this, SVNRepository::REPO_ERROR_SOCKET);
-            _repo = NULL;
-        }
-
-        Request::responseHeadersComplete();
-      }
-
-      virtual void onDone()
-      {
-        if (responseCode() == 207) {
-          _davStatus.finishParse();
-          if (_davStatus.isValid()) {
-              _repo->propFindComplete(this, (DAVCollection*) _davStatus.resource());
-          } else {
-              _repo->propFindFailed(this, SVNRepository::REPO_ERROR_SOCKET);
-          }
-        }
-      }
-
-      virtual void gotBodyData(const char* s, int n)
-      {
-        if (responseCode() != 207) {
-          return;
-        }
-        _davStatus.parseXML(s, n);
-      }
-
-        virtual void onFail()
-        {
-            HTTP::Request::onFail();
-			if (_repo) {
-				_repo->propFindFailed(this, SVNRepository::REPO_ERROR_SOCKET);
-				_repo = NULL;
-			}
-        }
-
-    private:
-      SVNRepoPrivate* _repo;
-      DAVMultiStatus _davStatus;
-    };
-
-class UpdateReportRequest:
-  public HTTP::Request
-{
-public:
-  UpdateReportRequest(SVNRepoPrivate* repo,
-      const std::string& aVersionName,
-      bool startEmpty) :
-    HTTP::Request("", "REPORT"),
-    _parser(repo->p),
-    _repo(repo),
-    _failed(false)
-  {
-    setUrl(repo->vccUrl);
-    std::string request =
-    "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"
-    "<S:update-report send-all=\"true\" xmlns:S=\"svn:\">\n"
-    "<S:src-path>" + repo->baseUrl + "</S:src-path>\n"
-    "<S:depth>unknown</S:depth>\n"
-    "<S:entry rev=\"" + aVersionName + "\" depth=\"infinity\" start-empty=\"true\"/>\n";
-
-    if( !startEmpty )
-    {
-      string_list entries;
-      _repo->rootCollection->mergeUpdateReportDetails(0, entries);
-      BOOST_FOREACH(string e, entries)
-      {
-        request += e + "\n";
-      }
-    }
-
-    request += "</S:update-report>";
-
-    setBodyData(request, "application/xml; charset=\"utf-8\"");
-  }
-
-protected:
-  virtual void onDone()
-  {
-      if (_failed) {
-          return;
-      }
-
-    if (responseCode() == 200) {
-          SVNRepository::ResultCode err = _parser.finishParse();
-          if (err) {
-              _repo->updateFailed(this, err);
-              _failed = true;
-          } else {
-              _repo->svnUpdateDone();
-          }
-    } else if (responseCode() == 404) {
-        _repo->updateFailed(this, SVNRepository::REPO_ERROR_NOT_FOUND);
-        _failed = true;
-    } else {
-        SG_LOG(SG_TERRASYNC, SG_WARN, "SVN: request for:" << url() <<
-        " got HTTP status " << responseCode());
-        _repo->updateFailed(this, SVNRepository::REPO_ERROR_HTTP);
-        _failed = true;
-    }
-  }
-
-  virtual void gotBodyData(const char* s, int n)
-  {
-      if (_failed) {
-          return;
-      }
-
-    if (responseCode() != 200) {
-        return;
-    }
-
-    SVNRepository::ResultCode err = _parser.parseXML(s, n);
-    if (err) {
-        _failed = true;
-        SG_LOG(SG_IO, SG_WARN, this << ": SVN: request for:" << url() << " failed:" << err);
-        _repo->updateFailed(this, err);
-        _repo = NULL;
-    }
-  }
-
-    virtual void onFail()
-    {
-        HTTP::Request::onFail();
-        if (_repo) {
-            _repo->updateFailed(this, SVNRepository::REPO_ERROR_SOCKET);
-            _repo = NULL;
-        }
-    }
-private:
-  SVNReportParser _parser;
-  SVNRepoPrivate* _repo;
-  bool _failed;
-};
-
-} // anonymous
-
-SVNRepository::SVNRepository(const SGPath& base, HTTP::Client *cl) :
-    _d(new SVNRepoPrivate(this))
-{
-  _d->http = cl;
-  _d->rootCollection = new SVNDirectory(this, base);
-  _d->baseUrl = _d->rootCollection->url();
-}
-
-SVNRepository::~SVNRepository()
-{
-    delete _d->rootCollection;
-}
-
-void SVNRepository::setBaseUrl(const std::string &url)
-{
-  _d->baseUrl = url;
-  _d->rootCollection->setBaseUrl(url);
-}
-
-std::string SVNRepository::baseUrl() const
-{
-  return _d->baseUrl;
-}
-
-HTTP::Client* SVNRepository::http() const
-{
-  return _d->http;
-}
-
-SGPath SVNRepository::fsBase() const
-{
-  return _d->rootCollection->fsPath();
-}
-
-bool SVNRepository::isBare() const
-{
-    if (!fsBase().exists() || Dir(fsBase()).isEmpty()) {
-        return true;
-    }
-
-    if (_d->vccUrl.empty()) {
-        return true;
-    }
-
-    return false;
-}
-
-void SVNRepository::update()
-{
-    _d->status = REPO_NO_ERROR;
-    if (_d->targetRevision.empty() || _d->vccUrl.empty()) {
-        _d->isUpdating = true;
-        PropFindRequest* pfr = new PropFindRequest(_d.get());
-        http()->makeRequest(pfr);
-        return;
-    }
-
-    if (_d->targetRevision == rootDir()->cachedRevision()) {
-        SG_LOG(SG_TERRASYNC, SG_DEBUG, baseUrl() << " in sync at version " << _d->targetRevision);
-        _d->isUpdating = false;
-        return;
-    }
-
-    _d->isUpdating = true;
-    UpdateReportRequest* urr = new UpdateReportRequest(_d.get(),
-        _d->targetRevision, isBare());
-    http()->makeRequest(urr);
-}
-
-bool SVNRepository::isDoingSync() const
-{
-    if (_d->status != REPO_NO_ERROR) {
-        return false;
-    }
-
-    return _d->isUpdating || _d->rootCollection->isDoingSync();
-}
-
-SVNDirectory* SVNRepository::rootDir() const
-{
-    return _d->rootCollection;
-}
-
-SVNRepository::ResultCode
-SVNRepository::failure() const
-{
-    return _d->status;
-}
-
-///////////////////////////////////////////////////////////////////////////
-
-void SVNRepoPrivate::propFindComplete(HTTP::Request* req, DAVCollection* c)
-{
-    targetRevision = c->versionName();
-    vccUrl = makeAbsoluteUrl(c->versionControlledConfiguration(), baseUrl);
-    rootCollection->collection()->setVersionControlledConfiguration(vccUrl);
-    p->update();
-}
-
-void SVNRepoPrivate::propFindFailed(HTTP::Request *req, SVNRepository::ResultCode err)
-{
-    if (err != SVNRepository::REPO_ERROR_NOT_FOUND) {
-        SG_LOG(SG_TERRASYNC, SG_WARN, "PropFind failed for:" << req->url());
-    }
-
-    isUpdating = false;
-    status = err;
-}
-
-} // of namespace simgear

simgear/io/SVNRepository.hxx

@@ -1,59 +0,0 @@
-// DAVMirrorTree.hxx - mirror a DAV tree to the local file system
-//
-// Copyright (C) 2012  James Turner <zakalawe@mac.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-
-#ifndef SG_IO_SVN_REPOSITORY_HXX
-#define SG_IO_SVN_REPOSITORY_HXX
-
-#include <simgear/io/AbstractRepository.hxx>
-#include <memory>
-
-namespace simgear  {
-
-class SVNDirectory;
-class SVNRepoPrivate;
-
-class SVNRepository : public AbstractRepository
-{
-public:
-
-    SVNRepository(const SGPath& root, HTTP::Client* cl);
-    virtual ~SVNRepository();
-
-    SVNDirectory* rootDir() const;
-    virtual SGPath fsBase() const;
-
-    virtual void setBaseUrl(const std::string& url);
-    virtual std::string baseUrl() const;
-
-    virtual HTTP::Client* http() const;
-
-    virtual void update();
-
-    virtual bool isDoingSync() const;
-
-    virtual ResultCode failure() const;
-private:
-    bool isBare() const;
-
-    std::auto_ptr<SVNRepoPrivate> _d;
-};
-
-} // of namespace simgear
-
-#endif // of SG_IO_SVN_REPOSITORY_HXX

simgear/io/decode_binobj.cxx

@@ -14,6 +14,7 @@
 
 #include "sg_binobj.hxx"
 #include <simgear/debug/logstream.hxx>
+#include <simgear/misc/sg_path.hxx>
 
 using std::cout;
 using std::endl;
@@ -31,7 +32,7 @@ int main( int argc, char **argv ) {
     sglog().setLogLevels( SG_ALL, SG_ALERT );
 
     SGBinObject obj;
-    bool result = obj.read_bin( argv[1] );
+    bool result = obj.read_bin( SGPath::fromLocal8Bit(argv[1]) );
     if ( !result ) {
         cout << "error loading: " << argv[1] << endl;
         exit(-1);

simgear/io/http_repo_sync.cxx

@@ -73,7 +73,7 @@ int main(int argc, char* argv[])
         SGTimeStamp::sleepForMSec(100);
     }
 
-    if (repo->failure() != AbstractRepository::REPO_NO_ERROR) {
+    if (repo->failure() != HTTPRepository::REPO_NO_ERROR) {
         cerr << "got response:" << repo->failure() << endl;
         return EXIT_FAILURE;
     }

simgear/io/http_svn.cxx

@@ -1,51 +0,0 @@
-#include <cstdio>
-#include <cstring>
-#include <signal.h>
-
-#include <iostream>
-#include <boost/foreach.hpp>
-
-
-#include <simgear/io/sg_file.hxx>
-#include <simgear/io/HTTPClient.hxx>
-#include <simgear/io/HTTPRequest.hxx>
-#include <simgear/io/sg_netChannel.hxx>
-#include <simgear/io/DAVMultiStatus.hxx>
-#include <simgear/io/SVNRepository.hxx>
-#include <simgear/debug/logstream.hxx>
-
-#include <simgear/misc/strutils.hxx>
-#include <simgear/timing/timestamp.hxx>
-
-using namespace simgear;
-using std::cout;
-using std::endl;
-using std::cerr;
-using std::string;
-
-HTTP::Client* httpClient;
-
-int main(int argc, char* argv[])
-{
-  sglog().setLogLevels( SG_ALL, SG_INFO );
-  HTTP::Client cl;
-  httpClient = &cl;
-
-  
-  SGPath p("/Users/jmt/Desktop/traffic");
-  SVNRepository airports(p, &cl);
- //  airports.setBaseUrl("http://svn.goneabitbursar.com/testproject1");
-//  airports.setBaseUrl("http://terrascenery.googlecode.com/svn/trunk/data/Scenery/Models");
-  
-  airports.setBaseUrl("http://fgfs.goneabitbursar.com/fgfsai/trunk/AI/Traffic");
-  
-//  airports.setBaseUrl("http://terrascenery.googlecode.com/svn/trunk/data/Scenery/Airports");
-  airports.update();
-  
-  while (airports.isDoingSync()) {
-    cl.update(100);
-  }
-  
-  cout << "all done!" << endl;
-  return EXIT_SUCCESS;
-}

simgear/io/httpget.cxx

@@ -83,7 +83,7 @@ int main(int argc, char* argv[])
             } else if (!strcmp(argv[a], "--auth")) {
                 proxyAuth = argv[++a];
             } else if (!strcmp(argv[a], "-f") || !strcmp(argv[a], "--file")) {
-                outFile = new SGFile(argv[++a]);
+                outFile = new SGFile(SGPath::fromLocal8Bit(argv[++a]));
                 if (!outFile->open(SG_IO_OUT)) {
                     cerr << "failed to open output for writing:" << outFile->get_file_name() << endl;
                     return EXIT_FAILURE;

simgear/io/iostreams/CMakeLists.txt

@@ -0,0 +1,23 @@
+include (SimGearComponent)
+
+set(HEADERS
+    sgstream.hxx
+    gzfstream.hxx
+    gzcontainerfile.hxx
+    )
+
+set(SOURCES
+    sgstream.cxx
+    gzfstream.cxx
+    gzcontainerfile.cxx
+    )
+
+simgear_component(IOStreams io/iostreams "${SOURCES}" "${HEADERS}")
+
+if(ENABLE_TESTS)
+
+  add_executable(test_streams sgstream_test.cxx )
+  target_link_libraries(test_streams ${TEST_LIBS})
+  add_test(streams ${EXECUTABLE_OUTPUT_PATH}/test_streams)
+
+endif(ENABLE_TESTS)

simgear/io/iostreams/gzcontainerfile.cxx

@@ -47,6 +47,7 @@
 
 #include <simgear/props/props_io.hxx>
 #include <simgear/misc/stdint.hxx>
+#include <simgear/misc/sg_path.hxx>
 
 #include <string.h>
 
@@ -139,7 +140,7 @@ gzContainerWriter::writeContainer(ContainerType Type, SGPropertyNode* root)
 
 gzContainerReader::gzContainerReader(const std::string& name,
                                      const std::string& fileMagic) :
-        sg_gzifstream(name, ios_in | ios_binary),
+        sg_gzifstream(SGPath(name), ios_in | ios_binary),
         filename(name)
 {
     bool ok = (good() && !eof());

simgear/io/iostreams/gzcontainerfile.hxx

@@ -22,7 +22,7 @@
 #define GZ_CONTAINER_FILE_HXX
 
 #include <string>
-#include <simgear/misc/sgstream.hxx>
+#include <simgear/io/iostreams/sgstream.hxx>
 
 class SGPropertyNode;
 

simgear/io/iostreams/gzfstream.cxx

@@ -22,12 +22,19 @@
 // $Id$
 
 #include <simgear/compiler.h>
+#include <simgear_config.h>
 
 #include <cerrno>
 #include <memory.h>
 #include <stdio.h>
+#include <fcntl.h>
 
-#include "zfstream.hxx"
+#include <simgear/misc/strutils.hxx>
+#include <simgear/debug/logstream.hxx>
+#include <simgear/structure/exception.hxx>
+
+#include <zlib.h>
+#include "gzfstream.hxx"
 
 //
 // Construct a gzfilebuf object.
@@ -110,7 +117,14 @@ gzfilebuf::open( const char *name, ios_openmode io_mode )
 
     char char_mode[10];
     cvt_iomode( char_mode, io_mode );
+
+#if defined(SG_WINDOWS)
+	std::wstring ws = simgear::strutils::convertUtf8ToWString(std::string(name));
+	if ( (file = gzopen_w(ws.c_str(), char_mode)) == NULL ) {
+
+#else
     if ( (file = gzopen(name, char_mode)) == NULL ) {
+#endif
         // perror( "gzfilebuf::open(): " );
         errno = 0;
         return NULL;
@@ -169,6 +183,27 @@ gzfilebuf::setcompressionstrategy( int comp_strategy )
     return gzsetparams(file, -2, comp_strategy);
 }
 
+z_off_t
+gzfilebuf::approxOffset() {
+    z_off_t res = gzoffset(file);
+
+    if (res == -1) {
+        int errnum;
+        std::string errMsg = "gzoffset() error: ";
+        const char *gzMsg = gzerror(file, &errnum);
+
+        if (errnum == Z_ERRNO) {
+            errMsg += simgear::strutils::error_string(errno);
+        } else {
+            errMsg += std::string(gzMsg);
+        }
+
+        SG_LOG( SG_GENERAL, SG_ALERT, errMsg );
+        throw sg_io_exception(errMsg);
+    }
+
+    return res;
+}
 
 std::streampos
 gzfilebuf::seekoff( std::streamoff, ios_seekdir, ios_openmode )

simgear/io/iostreams/gzfstream.hxx

@@ -1,5 +1,5 @@
 /**
- * \file zfstream.hxx
+ * \file gzfstream.hxx
  * A C++ I/O streams interface to the zlib gz* functions.
  */
 
@@ -24,8 +24,8 @@
 //
 // $Id$
 
-#ifndef _zfstream_hxx
-#define _zfstream_hxx
+#ifndef _gzfstream_hxx
+#define _gzfstream_hxx
 
 #include <simgear/compiler.h>
 
@@ -66,7 +66,7 @@ public:
 
     /**
      * Open a stream
-     * @param name file name
+     * @param name file name, UTF-8 encoded
      * @param io_mode mode flags
      * @return file stream
      */
@@ -89,6 +89,15 @@ public:
     /** @return true if open, false otherwise */
     bool is_open() const { return (file != NULL); }
 
+    /**
+     * @return the current offset in the file being read or written.
+     * The offset corresponds to compressed data if the file is compressed,
+     * and is influenced by buffering performed in zlib, hence the "approx"
+     * qualifier. It should be suitable for progress indicators and such,
+     * though.
+     */
+    z_off_t approxOffset();
+
     /** @return stream position */
     virtual std::streampos seekoff( std::streamoff off, ios_seekdir way, ios_openmode which );
 
@@ -155,4 +164,4 @@ struct gzofstream_base
     gzfilebuf gzbuf;
 };
 
-#endif // _zfstream_hxx
+#endif // _gzfstream_hxx

simgear/io/iostreams/sgstream.cxx

@@ -25,8 +25,12 @@
 #include <ctype.h> // isspace()
 #include <cerrno>
 
+#include <zlib.h>
+
 #include "sgstream.hxx"
 
+#include <simgear/misc/sg_path.hxx>
+
 using std::istream;
 using std::ostream;
 
@@ -39,10 +43,11 @@ sg_gzifstream::sg_gzifstream()
 //
 // Open a possibly gzipped file for reading.
 //
-sg_gzifstream::sg_gzifstream( const std::string& name, ios_openmode io_mode )
+sg_gzifstream::sg_gzifstream( const SGPath& name, ios_openmode io_mode,
+  bool use_exact_name )
     : istream(&gzbuf)
 {
-    this->open( name, io_mode );
+    this->open( name, io_mode, use_exact_name );
 }
 
 //-----------------------------------------------------------------------------
@@ -58,32 +63,35 @@ sg_gzifstream::sg_gzifstream( int fd, ios_openmode io_mode )
 //-----------------------------------------------------------------------------
 //
 // Open a possibly gzipped file for reading.
-// If the initial open fails and the filename has a ".gz" extension then
-// remove the extension and try again.
-// If the initial open fails and the filename doesn't have a ".gz" extension
-// then append ".gz" and try again.
+// If 'use_exact_name' is true, just try to open the indicated file, nothing
+// else. Otherwise:
+//   - if the initial open fails and the filename has a ".gz" extension, then
+//     remove it and try again;
+//   - if the initial open fails and the filename doesn't have a ".gz"
+//     extension, then append ".gz" and try again.
 //
 void
-sg_gzifstream::open( const std::string& name, ios_openmode io_mode )
+sg_gzifstream::open( const SGPath& name, ios_openmode io_mode,
+                     bool use_exact_name )
 {
-    gzbuf.open( name.c_str(), io_mode );
-    if ( ! gzbuf.is_open() )
+    std::string s = name.utf8Str();
+    gzbuf.open( s.c_str(), io_mode );
+    if ( ! (gzbuf.is_open() || use_exact_name) )
     {
-    std::string s = name;
-	if ( s.substr( s.length() - 3, 3 ) == ".gz" )
-	{
-	    // remove ".gz" suffix
-	    s.replace( s.length() - 3, 3, "" );
-// 	    s.erase( s.length() - 3, 3 );
-	}
-	else
-	{
-	    // Append ".gz" suffix
-	    s += ".gz";
-	}
+        if ( s.substr( s.length() - 3, 3 ) == ".gz" )
+        {
+            // remove ".gz" suffix
+            s.replace( s.length() - 3, 3, "" );
+    // 	    s.erase( s.length() - 3, 3 );
+        }
+        else
+        {
+            // Append ".gz" suffix
+            s += ".gz";
+        }
 
-	// Try again.
-	gzbuf.open( s.c_str(), io_mode );
+        // Try again.
+        gzbuf.open( s.c_str(), io_mode );
     }
 }
 
@@ -93,6 +101,11 @@ sg_gzifstream::attach( int fd, ios_openmode io_mode )
     gzbuf.attach( fd, io_mode );
 }
 
+z_off_t
+sg_gzifstream::approxOffset() {
+  return gzbuf.approxOffset();
+}
+
 //
 // Manipulators
 //
@@ -159,7 +172,7 @@ sg_gzofstream::sg_gzofstream()
 //
 // Open a file for gzipped writing.
 //
-sg_gzofstream::sg_gzofstream( const std::string& name, ios_openmode io_mode )
+sg_gzofstream::sg_gzofstream( const SGPath& name, ios_openmode io_mode )
     : ostream(&gzbuf)
 {
     this->open( name, io_mode );
@@ -180,9 +193,10 @@ sg_gzofstream::sg_gzofstream( int fd, ios_openmode io_mode )
 // Open a file for gzipped writing.
 //
 void
-sg_gzofstream::open( const std::string& name, ios_openmode io_mode )
+sg_gzofstream::open( const SGPath& name, ios_openmode io_mode )
 {
-    gzbuf.open( name.c_str(), io_mode );
+    std::string s = name.utf8Str();
+    gzbuf.open( s.c_str(), io_mode );
 }
 
 void
@@ -190,3 +204,44 @@ sg_gzofstream::attach( int fd, ios_openmode io_mode )
 {
     gzbuf.attach( fd, io_mode );
 }
+
+
+sg_ifstream::sg_ifstream(const SGPath& path, ios_openmode io_mode)
+{
+#if defined(SG_WINDOWS)
+	std::wstring ps = path.wstr();
+#else
+    std::string ps = path.local8BitStr();
+#endif
+	std::ifstream::open(ps.c_str(), io_mode);
+}
+
+void sg_ifstream::open( const SGPath& name, ios_openmode io_mode )
+{
+#if defined(SG_WINDOWS)
+	std::wstring ps = name.wstr();
+#else
+	std::string ps = name.local8BitStr();
+#endif
+    std::ifstream::open(ps.c_str(), io_mode);
+}
+
+sg_ofstream::sg_ofstream(const SGPath& path, ios_openmode io_mode)
+{
+#if defined(SG_WINDOWS)
+	std::wstring ps = path.wstr();
+#else
+	std::string ps = path.local8BitStr();
+#endif
+    std::ofstream::open(ps.c_str(), io_mode);
+}
+
+void sg_ofstream::open( const SGPath& name, ios_openmode io_mode )
+{
+#if defined(SG_WINDOWS)
+	std::wstring ps = name.wstr();
+#else
+	std::string ps = name.local8BitStr();
+#endif
+    std::ofstream::open(ps.c_str(), io_mode);
+}

simgear/io/iostreams/sgstream.hxx

@@ -33,12 +33,16 @@
 
 #include <simgear/compiler.h>
 
-#  include <istream>
-#  include <ostream>
+#include <istream>
+#include <ostream>
+#include <fstream>
 
 #include <string>
 
-#include <simgear/misc/zfstream.hxx>
+#include <zlib.h>
+#include <simgear/io/iostreams/gzfstream.hxx>
+
+class SGPath;
 
 /**
  * An envelope class for gzifstream.
@@ -50,13 +54,15 @@ public:
     sg_gzifstream();
 
     /**
-     * Constructor that attempt to open a file with and without
-     * ".gz" extension.
+     * Constructor that attempts to open a file.
      * @param name name of file
      * @param io_mode file open mode(s) "or'd" together
+     * @param use_exact_name if false, try to add or remove a ".gz" extension
+     *                       in case the indicated file can't be opened
      */
-    sg_gzifstream( const std::string& name,
-		   ios_openmode io_mode = ios_in | ios_binary );
+    sg_gzifstream( const SGPath& name,
+		   ios_openmode io_mode = ios_in | ios_binary,
+                   bool use_exact_name = false );
 
     /**
      * Constructor that attaches itself to an existing file descriptor.
@@ -66,12 +72,15 @@ public:
     sg_gzifstream( int fd, ios_openmode io_mode = ios_in|ios_binary );
 
     /**
-     * Attempt to open a file with and without ".gz" extension.
+     * Attempt to open a file.
      * @param name name of file
      * @param io_mode file open mode(s) "or'd" together
+     * @param use_exact_name if false, try to add or remove a ".gz" extension
+     *                       in case the indicated file can't be opened
      */
-    void open( const std::string& name,
-	       ios_openmode io_mode = ios_in|ios_binary );
+    void open( const SGPath& name,
+	       ios_openmode io_mode = ios_in|ios_binary,
+               bool use_exact_name = false );
 
     /**
      * Attach to an existing file descriptor.
@@ -88,10 +97,19 @@ public:
     /** @return true if the file is successfully opened, false otherwise. */
     bool is_open() { return gzbuf.is_open(); }
 
+    /**
+     * @return the current offset in the file being read or written.
+     * The offset corresponds to compressed data if the file is compressed,
+     * and is influenced by buffering performed in zlib, hence the "approx"
+     * qualifier. It should be suitable for progress indicators and such,
+     * though.
+     */
+    z_off_t approxOffset();
+
 private:
     // Not defined!
-    sg_gzifstream( const sg_gzifstream& );    
-    void operator= ( const sg_gzifstream& );    
+    sg_gzifstream( const sg_gzifstream& );
+    void operator= ( const sg_gzifstream& );
 };
 
 /**
@@ -130,7 +148,7 @@ public:
      * @param name name of file
      * @param io_mode file open mode(s) "or'd" together
      */
-    sg_gzofstream( const std::string& name,
+    sg_gzofstream( const SGPath& name,
            ios_openmode io_mode = ios_out | ios_binary );
 
     /**
@@ -145,7 +163,7 @@ public:
      * @param name name of file
      * @param io_mode file open mode(s) "or'd" together
      */
-    void open( const std::string& name,
+    void open( const SGPath& name,
            ios_openmode io_mode = ios_out|ios_binary );
 
     /**
@@ -169,5 +187,25 @@ private:
     void operator= ( const sg_gzofstream& );
 };
 
-#endif /* _SGSTREAM_HXX */
+class sg_ifstream : public std::ifstream
+{
+public:
+    sg_ifstream() {}
 
+    sg_ifstream(const SGPath& path, ios_openmode io_mode = ios_in | ios_binary);
+
+    void open( const SGPath& name,
+	       ios_openmode io_mode = ios_in|ios_binary );
+};
+
+class sg_ofstream : public std::ofstream
+{
+public:
+    sg_ofstream() { }
+    sg_ofstream(const SGPath& path, ios_openmode io_mode = ios_out | ios_binary);
+
+    void open( const SGPath& name,
+	       ios_openmode io_mode = ios_out|ios_binary );
+};
+
+#endif /* _SGSTREAM_HXX */

simgear/io/iostreams/sgstream_test.cxx

@@ -1,50 +1,53 @@
 #include <iostream>
-#include <fstream>
+#include <cstdlib> // for EXIT_SUCCESS
 
-#include <cstdlib> // for EXIT_FAILURE
-
-using std::ofstream;
+using std::string;
 using std::cout;
 using std::endl;
 
-#include <simgear/misc/sgstream.hxx>
+#include <simgear/misc/test_macros.hxx>
+#include <simgear/io/iostreams/sgstream.hxx>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/misc/sg_dir.hxx>
 
 int main()
 {
-    const char* fileName = "testfile";
+    const string fileName = "testfile";
+    simgear::Dir tmpDir = simgear::Dir::tempDir("FlightGear");
+    tmpDir.setRemoveOnDestroy();
+    SGPath p(tmpDir.path() / fileName);
+
     {
-       ofstream f;
-       f.open(fileName, std::ios::binary | std::ios::trunc | std::ios::out);
+       sg_ofstream f(p, std::ios::binary | std::ios::trunc | std::ios::out);
        f.write("first line ends with line-feed\n"
            "second line ends with just a cr\r"
            "third line ends with both\r\n"
            "fourth line as well\r\n"
            "fifth line is another CR/LF line\r\n"
            "end of test\r\n", 158);
-       f.close();
-   }
+    }
 
-   sg_gzifstream sg(fileName);
+   sg_gzifstream sg(p);
    std::string stuff;
    sg >> skipeol;
    sg >> stuff;
-   if (stuff != "second") return EXIT_FAILURE;
+   SG_CHECK_EQUAL(stuff, "second");
    cout << "Detection of LF works." << endl;
 
    sg >> skipeol;
    sg >> stuff;
-   if (stuff != "third") return EXIT_FAILURE;
+   SG_CHECK_EQUAL(stuff, "third");
    cout << "Detection of CR works." << endl;
 
    sg >> skipeol;
    sg >> stuff;
-   if (stuff != "fourth") return EXIT_FAILURE;
+   SG_CHECK_EQUAL(stuff, "fourth");
    cout << "Detection of CR/LF works." << endl;
 
    sg >> skipeol;
    sg >> skipeol;
    sg >> stuff;
-   if (stuff != "end") return EXIT_FAILURE;
+   SG_CHECK_EQUAL(stuff, "end");
    cout << "Detection of 2 following CR/LF lines works." << endl;
 
    return EXIT_SUCCESS;

simgear/io/iostreams/zlibstream.cxx

@@ -0,0 +1,717 @@
+// -*- coding: utf-8 -*-
+//
+// zlibstream.cxx --- IOStreams classes for working with RFC 1950 and RFC 1952
+//                    compression formats (respectively known as the zlib and
+//                    gzip formats)
+//
+// Copyright (C) 2017  Florent Rougon
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+#include <string>
+#include <ios>                  // std::streamsize
+#include <istream>
+#include <algorithm>
+#include <stdexcept>
+#include <unordered_map>
+#include <limits>               // std::numeric_limits
+#include <cstddef>              // std::size_t, std::ptrdiff_t
+#include <cassert>
+
+#include <zlib.h>
+
+#include <simgear/io/iostreams/zlibstream.hxx>
+#include <simgear/misc/strutils.hxx>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/structure/exception.hxx>
+#include <simgear/debug/logstream.hxx>
+
+using std::string;
+using traits = std::char_traits<char>;
+
+
+// Private utility function
+static string zlibErrorMessage(const z_stream& zstream, int errorCode)
+{
+  string res;
+  std::unordered_map<int, string> errorCodeToMessageMap = {
+    {Z_OK,            "zlib: no error (code Z_OK)"},
+    {Z_STREAM_END,    "zlib stream end"},
+    {Z_NEED_DICT,     "zlib: Z_NEED_DICT"},
+    {Z_STREAM_ERROR,  "zlib stream error"},
+    {Z_DATA_ERROR,    "zlib data error"},
+    {Z_MEM_ERROR,     "zlib memory error"},
+    {Z_BUF_ERROR,     "zlib buffer error"},
+    {Z_VERSION_ERROR, "zlib version error"}
+  };
+
+  if (errorCode == Z_ERRNO) {
+    res = simgear::strutils::error_string(errno);
+  } else if (zstream.msg != nullptr) {
+    // Caution: this only works if the zstream structure hasn't been
+    // deallocated!
+    res = "zlib: " + string(zstream.msg);
+  } else {
+    try {
+      res = errorCodeToMessageMap.at(errorCode);
+    } catch (const std::out_of_range&) {
+      res = string("unknown zlib error (code " + std::to_string(errorCode) +
+                   ")");
+    }
+  }
+
+  return res;
+}
+
+// Return the largest value that can be represented with zlib's uInt type,
+// which is the type of z_stream.avail_in and z_stream.avail_out, hence the
+// function name.
+static std::size_t zlibMaxChunkSize()
+{
+  uLong flags = ::zlibCompileFlags();
+  std::size_t res;
+
+  switch (flags & 0x3) {
+  case 0x3:
+    SG_LOG(SG_IO, SG_WARN,
+           "Unknown size for zlib's uInt type (code 3). Will assume 64 bits, "
+           "but the actual value is probably higher.");
+    // No 'break' here, this is intentional.
+  case 0x2:
+    res = 0xFFFFFFFFFFFFFFFF;   // 2^64 - 1
+    break;
+  case 0x1:
+    res = 0xFFFFFFFF;             // 2^32 - 1
+    break;
+  case 0x0:
+    res = 0xFFFF;                 // 2^16 - 1
+    break;
+  default:
+    throw std::logic_error("It should be impossible to get here.");
+  }
+
+  return res;
+}
+
+static const std::size_t zlibMaxChunk = ::zlibMaxChunkSize();
+
+
+namespace simgear
+{
+
+// ***************************************************************************
+// *                      ZlibAbstractIStreambuf class                       *
+// ***************************************************************************
+
+// Common initialization. Subclasses must complete the z_stream struct
+// initialization with a call to deflateInit2() or inflateInit2(), typically.
+ZlibAbstractIStreambuf::ZlibAbstractIStreambuf(std::istream& iStream,
+                                               const SGPath& path,
+                                               char* inBuf,
+                                               std::size_t inBufSize,
+                                               char *outBuf,
+                                               std::size_t outBufSize,
+                                               std::size_t putbackSize)
+  : _iStream(iStream),
+    _path(path),
+    _inBuf(inBuf),
+    _inBufSize(inBufSize),
+    _outBuf(outBuf),
+    _outBufSize(outBufSize),
+    _putbackSize(putbackSize)
+
+{
+  assert(_inBufSize > 0);
+  assert(_putbackSize >= 0);    // guaranteed unless the type is changed...
+  assert(_putbackSize < _outBufSize);
+
+  if (_inBuf == nullptr) {
+    _inBuf = new char[_inBufSize];
+    _inBufMustBeFreed = true;
+  }
+
+  if (_outBuf == nullptr) {
+    _outBuf = new char[_outBufSize];
+    _outBufMustBeFreed = true;
+  }
+
+  _inBufEndPtr = _inBuf;
+  // The input buffer is empty.
+  _zstream.next_in = reinterpret_cast<unsigned char *>(_inBuf);
+  _zstream.avail_in = 0;
+  // ZLib's documentation says its init functions such as inflateInit2() might
+  // consume stream input, therefore let's fill the input buffer now. This
+  // way, constructors of derived classes just have to call the appropriate
+  // ZLib init function: the data will already be in place.
+  getInputData();
+
+  // Force underflow() of the stream buffer on the first read. We could use
+  // some other value, but I avoid nullptr in order to be sure we can always
+  // reliably compare the three pointers with < and >, as well as compute the
+  // difference between any two of them.
+  setg(_outBuf, _outBuf, _outBuf);
+}
+
+ZlibAbstractIStreambuf::~ZlibAbstractIStreambuf()
+{
+  if (_inBufMustBeFreed) {
+    delete[] _inBuf;
+  }
+
+  if (_outBufMustBeFreed) {
+    delete[] _outBuf;
+  }
+}
+
+// Fill or refill the output buffer, and update the three pointers
+// corresponding to eback(), gptr() and egptr().
+int ZlibAbstractIStreambuf::underflow()
+{
+  if (_allFinished) {
+    return traits::eof();
+  }
+
+  // According to the C++11 standard: “The public members of basic_streambuf
+  // call this virtual function only if gptr() is null or gptr() >= egptr()”.
+  // Still, it seems some people do the following or similar (maybe in case
+  // underflow() is called “incorrectly”?). See for instance N. Josuttis, The
+  // C++ Standard Library (1st edition), p. 584. One sure thing is that it
+  // can't hurt (except performance, marginally), so let's do it.
+  if (gptr() < egptr()) {
+    return traits::to_int_type(*gptr());
+  }
+
+  assert(gptr() == egptr());
+  assert(egptr() - eback() >= 0);
+  std::size_t nbPutbackChars = std::min(
+    static_cast<std::size_t>(egptr() - eback()), // OK because egptr() >= eback()
+    _putbackSize);
+  std::copy(egptr() - nbPutbackChars, egptr(),
+            _outBuf + _putbackSize - nbPutbackChars);
+
+  setg(_outBuf + _putbackSize - nbPutbackChars, // start of putback area
+       _outBuf + _putbackSize,                  // start of obtained data
+       fillOutputBuffer());                     // one-past-end of obtained data
+
+  return (gptr() == egptr()) ? traits::eof() : traits::to_int_type(*gptr());
+}
+
+// Simple utility method for fillOutputBuffer(), used to improve readability.
+// Return the remaining space available in the output buffer, where zlib can
+// write.
+std::size_t
+ZlibAbstractIStreambuf::fOB_remainingSpace(unsigned char* nextOutPtr) const
+{
+  std::ptrdiff_t remainingSpaceInOutBuf = _outBuf + _outBufSize -
+    reinterpret_cast<char*>(nextOutPtr);
+  assert(remainingSpaceInOutBuf >= 0);
+
+  return static_cast<std::size_t>(remainingSpaceInOutBuf);
+}
+
+// Simple method for dealing with the Z_BUF_ERROR code that may be returned
+// by zlib's deflate() and inflate() methods.
+[[ noreturn ]] void ZlibAbstractIStreambuf::handleZ_BUF_ERROR() const
+{
+  switch (operationType()) {
+  case OPERATION_TYPE_DECOMPRESSION:
+  {
+    string message = (_path.isNull()) ?
+      "Got Z_BUF_ERROR from zlib while decompressing a stream. The stream "
+      "was probably incomplete."
+      :
+      "Got Z_BUF_ERROR from zlib during decompression. The compressed stream "
+      "was probably incomplete.";
+    // When _path.isNull(), sg_location(_path) is equivalent to sg_location()
+    throw sg_io_exception(message, sg_location(_path));
+  }
+  case OPERATION_TYPE_COMPRESSION:
+    throw std::logic_error(
+      "Called ZlibAbstractIStreambuf::handleZ_BUF_ERROR() with "
+      "operationType() == OPERATION_TYPE_DECOMPRESSION");
+  default:
+    throw std::logic_error(
+      "Unexpected operationType() in "
+      "ZlibAbstractIStreambuf::handleZ_BUF_ERROR(): " +
+      std::to_string(operationType()));
+  }
+}
+
+// Fill or refill the output buffer. Return a pointer to the first unused char
+// in _outBuf (i.e., right after the data written by this method, if any;
+// otherwise: _outBuf + _putbackSize).
+char* ZlibAbstractIStreambuf::fillOutputBuffer()
+{
+  bool allInputRead = false;
+  std::size_t remainingSpaceInOutBuf;
+  int retCode;
+
+  // We have to do these unpleasant casts, because zlib uses pointers to
+  // unsigned char for its input and output buffers, while the IOStreams
+  // library in the C++ standard uses plain char pointers...
+  _zstream.next_out = reinterpret_cast<unsigned char*>(_outBuf + _putbackSize);
+  remainingSpaceInOutBuf = fOB_remainingSpace(_zstream.next_out);
+
+  while (remainingSpaceInOutBuf > 0) {
+    // This does fit in a zlib uInt: that's the whole point of zlibMaxChunk.
+    _zstream.avail_out = static_cast<uInt>(
+      std::min(remainingSpaceInOutBuf, zlibMaxChunk));
+
+    if (_zstream.avail_in == 0 && !allInputRead) {
+      // Get data from _iStream, store it in _inBuf
+      allInputRead = getInputData();
+    }
+
+    // Make zlib process some data (compress or decompress it). This updates
+    // _zstream.{avail,next}_{in,out} (4 fields of the z_stream struct).
+    retCode = zlibProcessData();
+
+    if (retCode == Z_BUF_ERROR) {
+      handleZ_BUF_ERROR();            // doesn't return
+    } else if (retCode == Z_STREAM_END) {
+      assert(_zstream.avail_in == 0); // all of _inBuf must have been used
+      _allFinished = true;
+      break;
+    } else if (retCode < 0) {         // negative codes are errors
+      throw sg_io_exception(::zlibErrorMessage(_zstream, retCode),
+                            sg_location(_path));
+    }
+
+    remainingSpaceInOutBuf = fOB_remainingSpace(_zstream.next_out);
+  }
+
+  return reinterpret_cast<char*>(_zstream.next_out);
+}
+
+// This method provides input data to zlib:
+//   - if data is already available in _inBuf, it updates _zstream.avail_in
+//     accordingly (using the largest possible amount given _zstream.avail_in's
+//     type, i.e., uInt);
+//   - otherwise, it reads() as much data as possible into _inBuf from
+//     _iStream and updates _zstream.avail_in to tell zlib about this new
+//     available data (again: largest possible amount given the uInt type).
+//
+// This method must be called only when _zstream.avail_in == 0, which means
+// zlib has read everything we fed it (and does *not* mean, by the way, that
+// the input buffer starting at _inBuf is empty; this is because the buffer
+// size might exceed what can be represented by an uInt).
+//
+// On return:
+//   - either EOF has been reached for _iStream, and the return value is true;
+//   - or _zstream.avail_in > 0, and the return value is false.
+//
+// Note: don't read more in the previous paragraph concerning the state on
+//       return. In the first case, there is *no guarantee* about
+//       _zstream.avail_in's value; in the second case, there is *no guarantee*
+//       about whether EOF has been reached for _iStream.
+bool ZlibAbstractIStreambuf::getInputData()
+{
+  bool allInputRead = false;
+
+  assert(_zstream.avail_in == 0);
+  std::ptrdiff_t alreadyAvailable =
+    _inBufEndPtr - reinterpret_cast<char*>(_zstream.next_in);
+  assert(alreadyAvailable >= 0);
+
+  // Data already available?
+  if (alreadyAvailable > 0) {
+    _zstream.avail_in = static_cast<uInt>(
+      std::min(static_cast<std::size_t>(alreadyAvailable),
+               zlibMaxChunk));
+    return allInputRead;
+  }
+
+  if (_inBufEndPtr == _inBuf + _inBufSize) { // buffer full, rewind
+    _inBufEndPtr = _inBuf;
+    _zstream.next_in = reinterpret_cast<unsigned char*>(_inBuf);
+  }
+
+  // Fill the input buffer (as much as possible)
+  while (_inBufEndPtr < _inBuf + _inBufSize && !_iStream.eof()) {
+    std::streamsize nbCharsToRead = std::min(
+      _inBuf + _inBufSize - _inBufEndPtr,
+      std::numeric_limits<std::streamsize>::max()); // max we can pass to read()
+    _iStream.read(_inBufEndPtr, nbCharsToRead);
+
+    if (_iStream.bad()) {
+      string errMsg = simgear::strutils::error_string(errno);
+      string msgStart = (_path.isNull()) ?
+        "Error while reading from a stream" : "Read error";
+      throw sg_io_exception(msgStart + ": " + errMsg, sg_location(_path));
+    }
+
+    // Could be zero if at EOF
+    std::streamsize nbCharsRead = _iStream.gcount();
+    // std::streamsize is a signed integral type!
+    assert(0 <= nbCharsRead);
+    _inBufEndPtr += nbCharsRead;
+  }
+
+  std::ptrdiff_t availableChars =
+    _inBufEndPtr - reinterpret_cast<char*>(_zstream.next_in);
+  assert(availableChars >= 0);
+  _zstream.avail_in = static_cast<uInt>(
+    std::min(static_cast<std::size_t>(availableChars),
+             zlibMaxChunk));
+
+  if (_iStream.eof()) {
+    allInputRead = true;
+  } else {
+    // Trying to rewind a fully read std::istringstream with seekg() can lead
+    // to a weird state, where the stream doesn't return any character but
+    // doesn't report EOF either. Make sure we are not in this situation.
+    assert(_zstream.avail_in > 0);
+  }
+
+  return allInputRead;
+}
+
+// Implementing this method is optional, but should provide better
+// performance. It makes zlib write the data directly in the buffer starting
+// at 'dest'. Without it, the data would go through an intermediate buffer
+// (_outBuf) before being copied to its (hopefully) final destination.
+std::streamsize ZlibAbstractIStreambuf::xsgetn(char* dest, std::streamsize n)
+{
+  std::size_t remaining = static_cast<std::size_t>(n);
+  std::size_t chunkSize;
+  std::ptrdiff_t avail;
+  const char* origGptr = gptr();
+  char* writePtr = dest;        // we'll need dest later -> work with a copy
+
+  // First, let's take data present in our internal buffer (_outBuf)
+  while (remaining > 0) {
+    avail = egptr() - gptr();   // number of available chars in _outBuf
+    if (avail == 0) {           // our internal buffer is empty
+      break;
+    }
+
+    chunkSize = std::min(remaining, static_cast<std::size_t>(avail));
+    std::copy(gptr(), gptr() + chunkSize, writePtr);
+    gbump(chunkSize);
+    writePtr += chunkSize;
+    remaining -= chunkSize;
+  }
+
+  if (remaining == 0) {
+    // Everything we needed was already in _outBuf. The putback area is set up
+    // as it should between eback() and the current gptr(), so we are fine to
+    // return.
+    return n;
+  }
+
+  // Now, let's make it so that the remaining data we need is directly written
+  // to the destination area, without going through _outBuf.
+  _zstream.next_out = reinterpret_cast<unsigned char*>(writePtr);
+  bool allInputRead = false;
+  int retCode;
+
+  while (remaining > 0) {
+    chunkSize = std::min(remaining, zlibMaxChunk);
+    // It does fit in a zlib uInt: that's the whole point of zlibMaxChunk.
+    _zstream.avail_out = static_cast<uInt>(chunkSize);
+
+    if (_zstream.avail_in == 0 && !allInputRead) {
+      allInputRead = getInputData();
+    }
+
+    // Make zlib process some data (compress or decompress). This updates
+    // _zstream.{avail,next}_{in,out} (4 fields of the z_stream struct).
+    retCode = zlibProcessData();
+    // chunkSize - _zstream.avail_out is the nb of chars written by zlib
+    remaining -= chunkSize - _zstream.avail_out;
+
+    if (retCode == Z_BUF_ERROR) {
+      handleZ_BUF_ERROR();            // doesn't return
+    } else if (retCode == Z_STREAM_END) {
+      assert(_zstream.avail_in == 0); // all of _inBuf must have been used
+      _allFinished = true;
+      break;
+    } else if (retCode < 0) {   // negative codes are errors
+      throw sg_io_exception(::zlibErrorMessage(_zstream, retCode),
+                            sg_location(_path));
+    }
+  }
+
+  // Finally, prepare the putback area.
+  //
+  // We could use reinterpret_cast<char*>(_zstream.next_out) everywhere below,
+  // except it is hardly readable. This points after the latest data we wrote.
+  writePtr = reinterpret_cast<char*>(_zstream.next_out);
+
+  // There are two buffers containing characters we potentially have to copy
+  // to the putback area: the one starting at _outBuf and the one starting at
+  // dest. In the following diagram, ***** represents those from _outBuf,
+  // which are right-aligned at origGptr[1], and the series of # represents
+  // those in the [dest, writePtr) address range:
+  //
+  // |_outBuf  |eback() *****|origGptr      |_outBuf + _outBufSize
+  //
+  // |dest #################|writePtr
+  //
+  // Together, these two memory blocks logically form a contiguous stream of
+  // chars we gave to the “client”: *****#################. All we have to do
+  // now is copy the appropriate amount of chars from this logical stream to
+  // the putback area, according to _putbackSize. These chars are the last
+  // ones in said stream (i.e., right portion of *****#################), but
+  // we have to copy them in order of increasing address to avoid possible
+  // overlapping problems in _outBuf. This is because some of the chars to
+  // copy may be located before _outBuf + _putbackSize (i.e., already be in
+  // the putback area).
+  //
+  //   [1] This means that the last char represented by a star is at address
+  //       origGptr-1.
+  assert(writePtr - dest >= 0);
+  std::size_t inDestBuffer = static_cast<std::size_t>(writePtr - dest);
+  assert(origGptr - eback() >= 0);
+  std::size_t nbPutbackChars = std::min(
+    static_cast<std::size_t>(origGptr - eback()) + inDestBuffer,
+    _putbackSize);
+  std::size_t nbPutbackCharsToGo = nbPutbackChars;
+
+  // chunkSize has an unsigned type; precomputing it before the following test
+  // wouldn't work.
+  // Are there chars in _outBuf that need to be copied to the putback area?
+  if (nbPutbackChars > inDestBuffer) {
+    chunkSize = nbPutbackChars - inDestBuffer; // yes, this number
+    std::copy(origGptr - chunkSize, origGptr,
+              _outBuf + _putbackSize - nbPutbackChars);
+    nbPutbackCharsToGo -= chunkSize;
+  }
+
+  std::copy(writePtr - nbPutbackCharsToGo, writePtr,
+            _outBuf + _putbackSize - nbPutbackCharsToGo);
+  setg(_outBuf + _putbackSize - nbPutbackChars, // start of putback area
+       _outBuf + _putbackSize,                  // the buffer for pending,
+       _outBuf + _putbackSize);                 // available data is empty
+
+  std::streamsize rem = static_cast<std::streamsize>(remaining);
+  // This is guaranteed because n is of type std::streamsize and the whole
+  // algorithm ensures that 0 <= remaining <= n.
+  assert(rem >= 0);
+  assert(static_cast<std::size_t>(rem) == remaining);
+  assert(n - rem >= 0);
+  // Total number of chars copied.
+  return n - rem;
+}
+
+// ***************************************************************************
+// *                     ZlibCompressorIStreambuf class                      *
+// ***************************************************************************
+
+ZlibCompressorIStreambuf::ZlibCompressorIStreambuf(
+  std::istream& iStream,
+  const SGPath& path,
+  int compressionLevel,
+  ZLibCompressionFormat format,
+  ZLibMemoryStrategy memStrategy,
+  char* inBuf,
+  std::size_t inBufSize,
+  char *outBuf,
+  std::size_t outBufSize,
+  std::size_t putbackSize)
+  : ZlibAbstractIStreambuf(iStream, path, inBuf, inBufSize, outBuf, outBufSize,
+                           putbackSize)
+{
+  zStreamInit(compressionLevel, format, memStrategy);
+}
+
+ZlibCompressorIStreambuf::~ZlibCompressorIStreambuf()
+{
+  int retCode = deflateEnd(&_zstream); // deallocate the z_stream struct
+  if (retCode != Z_OK) {
+    // In C++11, we can't throw exceptions from a destructor.
+    SG_LOG(SG_IO, SG_ALERT, "ZlibCompressorIStreambuf: " <<
+           ::zlibErrorMessage(_zstream, retCode));
+  }
+}
+
+ZlibAbstractIStreambuf::OperationType
+ZlibCompressorIStreambuf::operationType() const
+{
+  return OPERATION_TYPE_COMPRESSION;
+}
+
+void ZlibCompressorIStreambuf::zStreamInit(int compressionLevel,
+                                          ZLibCompressionFormat format,
+                                          ZLibMemoryStrategy memStrategy)
+{
+  int windowBits, memLevel;
+
+  // Intentionally not listing ZLIB_COMPRESSION_FORMAT_AUTODETECT here (it is
+  // only for decompression!)
+  switch (format) {
+  case ZLIB_COMPRESSION_FORMAT_ZLIB:
+    windowBits = 15;
+    break;
+  case ZLIB_COMPRESSION_FORMAT_GZIP:
+    windowBits = 31;
+    break;
+  default:
+    throw std::logic_error("Unexpected compression format: " +
+                           std::to_string(format));
+  }
+
+  switch (memStrategy) {
+  case ZLIB_FAVOR_MEMORY_OVER_SPEED:
+    memLevel = 8;
+    break;
+  case ZLIB_FAVOR_SPEED_OVER_MEMORY:
+    memLevel = 9;
+    break;
+  default:
+    throw std::logic_error("Unexpected memory strategy: " +
+                           std::to_string(memStrategy));
+  }
+
+  _zstream.zalloc = Z_NULL;     // No custom memory allocation routines
+  _zstream.zfree = Z_NULL;      // Ditto. Therefore, the 'opaque' field won't
+  _zstream.opaque = Z_NULL;     // be used, actually.
+
+  int retCode = deflateInit2(&_zstream, compressionLevel, Z_DEFLATED,
+                             windowBits, memLevel, Z_DEFAULT_STRATEGY);
+  if (retCode != Z_OK) {
+    throw sg_io_exception(::zlibErrorMessage(_zstream, retCode),
+                          sg_location(_path));
+  }
+}
+
+int ZlibCompressorIStreambuf::zlibProcessData()
+{
+  // Compress as much data as possible given _zstream.avail_in and
+  // _zstream.avail_out. The input data starts at _zstream.next_in, the output
+  // at _zstream.next_out, and these four fields are all updated by this call
+  // to reflect exactly the amount of data zlib has consumed and produced.
+  return deflate(&_zstream, _zstream.avail_in ? Z_NO_FLUSH : Z_FINISH);
+}
+
+// ***************************************************************************
+// *                    ZlibDecompressorIStreambuf class                     *
+// ***************************************************************************
+
+ZlibDecompressorIStreambuf::ZlibDecompressorIStreambuf(
+  std::istream& iStream,
+  const SGPath& path,
+  ZLibCompressionFormat format,
+  char* inBuf,
+  std::size_t inBufSize,
+  char *outBuf,
+  std::size_t outBufSize,
+  std::size_t putbackSize)
+  : ZlibAbstractIStreambuf(iStream, path, inBuf, inBufSize, outBuf, outBufSize,
+                           putbackSize)
+{
+  zStreamInit(format);
+}
+
+ZlibDecompressorIStreambuf::~ZlibDecompressorIStreambuf()
+{
+  int retCode = inflateEnd(&_zstream); // deallocate the z_stream struct
+  if (retCode != Z_OK) {
+    // In C++11, we can't throw exceptions from a destructor.
+    SG_LOG(SG_IO, SG_ALERT, "ZlibDecompressorIStreambuf: " <<
+           ::zlibErrorMessage(_zstream, retCode));
+  }
+}
+
+ZlibAbstractIStreambuf::OperationType
+ZlibDecompressorIStreambuf::operationType() const
+{
+  return OPERATION_TYPE_DECOMPRESSION;
+}
+
+void ZlibDecompressorIStreambuf::zStreamInit(ZLibCompressionFormat format)
+{
+  int windowBits;
+
+  switch (format) {
+  case ZLIB_COMPRESSION_FORMAT_ZLIB:
+    windowBits = 15;
+    break;
+  case ZLIB_COMPRESSION_FORMAT_GZIP:
+    windowBits = 31;
+    break;
+  case ZLIB_COMPRESSION_FORMAT_AUTODETECT:
+    windowBits = 47;            // 47 = 32 + 15
+    break;
+  default:
+    throw std::logic_error("Unexpected compression format: " +
+                           std::to_string(format));
+  }
+
+  _zstream.zalloc = Z_NULL;     // No custom memory allocation routines
+  _zstream.zfree = Z_NULL;      // Ditto. Therefore, the 'opaque' field won't
+  _zstream.opaque = Z_NULL;     // be used, actually.
+
+  int retCode = inflateInit2(&_zstream, windowBits);
+  if (retCode != Z_OK) {
+    throw sg_io_exception(::zlibErrorMessage(_zstream, retCode),
+                          sg_location(_path));
+  }
+}
+
+int ZlibDecompressorIStreambuf::zlibProcessData()
+{
+  // Decompress as much data as possible given _zstream.avail_in and
+  // _zstream.avail_out. The input data starts at _zstream.next_in, the output
+  // at _zstream.next_out, and these four fields are all updated by this call
+  // to reflect exactly the amount of data zlib has consumed and produced.
+  return inflate(&_zstream, _zstream.avail_in ? Z_NO_FLUSH : Z_FINISH);
+}
+
+// ***************************************************************************
+// *                       ZlibCompressorIStream class                       *
+// ***************************************************************************
+
+ZlibCompressorIStream::ZlibCompressorIStream(std::istream& iStream,
+                                             const SGPath& path,
+                                             int compressionLevel,
+                                             ZLibCompressionFormat format,
+                                             ZLibMemoryStrategy memStrategy,
+                                             char* inBuf,
+                                             std::size_t inBufSize,
+                                             char *outBuf,
+                                             std::size_t outBufSize,
+                                             std::size_t putbackSize)
+  : _streamBuf(iStream, path, compressionLevel, format, memStrategy, inBuf,
+               inBufSize, outBuf, outBufSize, putbackSize)
+{
+  rdbuf(&_streamBuf);            // Associate _streamBuf to 'this'
+}
+
+ZlibCompressorIStream::~ZlibCompressorIStream()
+{ }
+
+// ***************************************************************************
+// *                      ZlibDecompressorIStream class                      *
+// ***************************************************************************
+
+ZlibDecompressorIStream::ZlibDecompressorIStream(std::istream& iStream,
+                                                 const SGPath& path,
+                                                 ZLibCompressionFormat format,
+                                                 char* inBuf,
+                                                 std::size_t inBufSize,
+                                                 char *outBuf,
+                                                 std::size_t outBufSize,
+                                                 std::size_t putbackSize)
+  : _streamBuf(iStream, path, format, inBuf, inBufSize, outBuf, outBufSize,
+               putbackSize)
+{
+  rdbuf(&_streamBuf);            // Associate _streamBuf to 'this'
+}
+
+ZlibDecompressorIStream::~ZlibDecompressorIStream()
+{ }
+
+} // of namespace simgear

simgear/io/iostreams/zlibstream.hxx

@@ -0,0 +1,401 @@
+// -*- coding: utf-8 -*-
+//
+// zlibstream.hxx --- IOStreams classes for working with RFC 1950 and RFC 1952
+//                    compression formats (respectively known as the zlib and
+//                    gzip formats)
+//
+// Copyright (C) 2017  Florent Rougon
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+#ifndef SG_ZLIBSTREAM_HXX
+#define SG_ZLIBSTREAM_HXX
+
+#include <iosfwd>
+#include <ios>                  // std::streamsize
+#include <zlib.h>               // struct z_stream
+
+#include <simgear/misc/sg_path.hxx>
+
+// This file contains:
+//
+//  - two stream buffer classes (ZlibCompressorIStreambuf and
+//    ZlibDecompressorIStreambuf), both based on the same abstract class:
+//    ZlibAbstractIStreambuf;
+//
+//  - two std::istream subclasses (ZlibCompressorIStream and
+//    ZlibDecompressorIStream), each creating and using the corresponding
+//    stream buffer class from the previous item.
+//
+// All these allow one to work with RFC 1950 and RFC 1952 compression
+// formats, respectively known as the zlib and gzip formats.
+//
+// These classes are *input* streaming classes, which means they can
+// efficiently handle arbitrary amounts of data without using any disk
+// space nor increasing amounts of memory, and allow “client code” to pull
+// exactly as much data as it wants at any given time, resuming later
+// when it is ready to handle the next chunk.
+//
+// So, for example, assuming you've created an instance of
+// ZlibCompressorIStream (bound to some input stream of your choice, let's
+// call it iStream), you could read 512 bytes of data from it, and you
+// would get the first 512 bytes of *compressed* data corresponding to what
+// iStream provided. Then you could resume at any time and ask for the next
+// 512 bytes of compressed data (or any other amount), etc.
+//
+// Therefore, these classes are well suited, among others, to compress or
+// decompress data streams while at the same time packing the result into
+// discrete chunks or packets with size constraints (you can think of the
+// process as making sausages :).
+//
+// The input being in each case an std::istream (for compressing as well as
+// for decompressing), it can be tied to an arbitrary source: a file with
+// sg_ifstream or std::ifstream, a memory buffer with std::istringstream or
+// std::stringstream, a TCP socket with a custom std::streambuf subclass[1]
+// to interface with the sockets API, etc.
+//
+//   [1] Possibly wrapped in an std::istream.
+//
+// The stream buffer classes upon which ZlibCompressorIStream and
+// ZlibDecompressorIStream are built have an xsgetn() implementation that
+// avoids useless copies of data by asking zlib to write directly to the
+// destination buffer. This xsgetn() method is used when calling read() on
+// the std::istream subclasses, or sgetn() if you are using the stream
+// buffer classes directly (i.e., ZlibCompressorIStreambuf and
+// ZlibDecompressorIStreambuf). Other std::istream methods may instead rely
+// only on the internal buffer and the underflow() method, and therefore be
+// less efficient for large amounts of data. You may want to take a look at
+// zlibstream_test.cxx to see various ways of using these classes.
+//
+// In case you use std::istream& operator>>(std::istream&, std::string&) or
+// its overload friends, beware that it splits fields at spaces, and by
+// default ignores spaces at the beginning of a field (cf. std::skipws,
+// std::noskipws and friends). As far as I understand it, most of these
+// operators are mainly intended in the IOStreams library to be used to
+// read an int here, a double there, a space-delimited string afterwards,
+// etc. (the exception could be the overload writing to a stream buffer,
+// however it doesn't seem to be very efficient on my system with GNU
+// libstdc++ [it is not using xsgetn()], so beware also of this one if you
+// are handling large amounts of data). For moderately complex or large
+// input handling, I'd suggest to use std::istream methods such as read(),
+// gcount() and getline() (std::getline() can be useful too). Or directly
+// use the stream buffer classes, in particular with sgetn().
+
+
+namespace simgear
+{
+
+enum ZLibCompressionFormat {
+  ZLIB_COMPRESSION_FORMAT_ZLIB = 0,
+  ZLIB_COMPRESSION_FORMAT_GZIP,
+  ZLIB_COMPRESSION_FORMAT_AUTODETECT
+};
+
+enum ZLibMemoryStrategy {
+  ZLIB_FAVOR_MEMORY_OVER_SPEED = 0,
+  ZLIB_FAVOR_SPEED_OVER_MEMORY
+};
+
+// Abstract base class for both the compressor and decompressor stream buffers.
+class ZlibAbstractIStreambuf: public std::streambuf
+{
+public:
+  /**
+   *  @brief Constructor for ZlibAbstractIStreambuf.
+   *  @param iStream     Input stream to read from.
+   *  @param path        Optional path to the file corresponding to iStream,
+   *                     if any. Only used for error messages.
+   *  @param inBuf       Pointer to the input buffer (data read from iStream is
+   *                     written there before being compressed or decompressed).
+   *                     If nullptr, the buffer is allocated on the heap in the
+   *                     constructor and deallocated in the destructor.
+   *  @param inBufSize   Size of the input buffer, in chars.
+   *  @param outBuf      Pointer to the output buffer. Data is read by zlib
+   *                     from the input buffer, compressed or decompressed, and
+   *                     the result is directly written to the output buffer.
+   *                     If nullptr, the buffer is allocated on the heap in the
+   *                     constructor and deallocated in the destructor.
+   *  @param outBufSize  Size of the output buffer, in chars.
+   *  @param putbackSize Size of the putback area inside the output buffer, in
+   *                     chars.
+   *
+   *  It is required that putbackSize < outBufSize. It is guaranteed that,
+   *  if at least putbackSize chars have been read without any putback (or
+   *  unget) operation intermixed, then at least putbackSize chars can be
+   *  put back in sequence. If you don't need this feature, use zero for the
+   *  putbackSize value (the default) for best performance.
+  */
+  explicit ZlibAbstractIStreambuf(std::istream& iStream,
+                                  const SGPath& path = SGPath(),
+                                  char* inBuf = nullptr,
+                                  std::size_t inBufSize = 262144,
+                                  char* outBuf = nullptr,
+                                  std::size_t outBufSize = 262144,
+                                  std::size_t putbackSize = 0);
+  ZlibAbstractIStreambuf(const ZlibAbstractIStreambuf&) = delete;
+  ZlibAbstractIStreambuf& operator=(const ZlibAbstractIStreambuf&) = delete;
+  ~ZlibAbstractIStreambuf();
+
+protected:
+  enum OperationType {
+    OPERATION_TYPE_COMPRESSION = 0,
+    OPERATION_TYPE_DECOMPRESSION
+  };
+
+  virtual OperationType operationType() const = 0;
+
+  // Either compress or decompress a chunk of data (depending on the
+  // particular subclass implementation). The semantics are the same as for
+  // zlib's inflate() and deflate() functions applied to member _zstream,
+  // concerning 1) the return value and 2) where, and how much to read and
+  // write (which thus depends on _zstream.avail_in, _zstream.next_in,
+  // _zstream.avail_out and _zstream.next_out).
+  virtual int zlibProcessData() = 0;
+
+  // The input stream, from which data is read before being processed by zlib
+  std::istream& _iStream;
+  // Corresponding path, if any (default-constructed SGPath instance otherwise)
+  const SGPath _path;
+  // Structure used to communicate with zlib
+  z_stream _zstream;
+
+private:
+  // Callback whose role is to refill the output buffer when it's empty and
+  // the “client” tries to read more.
+  int underflow() override;
+  // Optional override when subclassing std::streambuf. This is the most
+  // efficient way of reading several characters (as soon as we've emptied the
+  // output buffer, data is written by zlib directly to the destination
+  // buffer).
+  std::streamsize xsgetn(char* dest, std::streamsize n) override;
+  // Make sure there is data to read in the input buffer, or signal EOF.
+  bool getInputData();
+  // Utility method for fillOutputBuffer()
+  std::size_t fOB_remainingSpace(unsigned char* nextOutPtr) const;
+  // Fill the output buffer (using zlib functions) as much as possible.
+  char* fillOutputBuffer();
+  // Utility method
+  [[ noreturn ]] void handleZ_BUF_ERROR() const;
+
+  bool _allFinished = false;
+
+  // The buffers
+  // ~~~~~~~~~~~
+  //
+  // The input buffer receives data obtained from _iStream, before it is
+  // processed by zlib. In underflow(), zlib reads from this buffer it and
+  // writes the resulting data(*) to the output buffer. Then we point the
+  // standard std::streambuf pointers (gptr() and friends) directly towards
+  // the data inside that output buffer. xsgetn() is even more optimized: it
+  // first empties the output buffer, then makes zlib write the remaining data
+  // directly to the destination area.
+  //
+  //   (*) Compressed or decompressed, depending on the particular
+  //       implementation of zlibProcessData() in each subclass.
+  char* _inBuf;
+  const std::size_t _inBufSize;
+  // _inBufEndPtr points right after the last data retrieved from _iStream and
+  // stored into _inBuf. When zlib has read all such data, _zstream.next_in is
+  // equal to _inBufEndPtr (after proper casting). Except in this particular
+  // situation, only _zstream.next_in <= _inBufEndPtr is guaranteed.
+  char* _inBufEndPtr;
+  // Layout of the _outBuf buffer:
+  //
+  // |_outBuf  <putback area>  |_outBuf + _putbackSize    |_outBuf + _outBufSize
+  //
+  // The first _putbackSize chars in _outBuf are reserved for the putback area
+  // (right-aligned at _outBuf + _putbackSize). The actual output buffer thus
+  // starts at _outBuf + _putbackSize. At any given time for callers of this
+  // class, the number of characters that can be put back is gptr() - eback().
+  // It may be lower than _putbackSize if we haven't read that many characters
+  // yet. It may also be larger if gptr() > _outBuf + _putbackSize, i.e.,
+  // when the buffer for pending data is non-empty.
+  //
+  // At any given time, callers should see:
+  //
+  //   _outBuf <= eback() <= _outBuf + _putbackSize <= gptr() <= egptr()
+  //                                                <= _outBuf + _outBufSize
+  //
+  // (hoping this won't get out of sync with the code!)
+  char *_outBuf;
+  const std::size_t _outBufSize;
+  // Space reserved for characters to be put back into the stream. Must be
+  // strictly smaller than _outBufSize (this is checked in the constructor).
+  // It is guaranteed that this number of chars can be put back, except of
+  // course if we haven't read that many characters from the input stream yet.
+  // If characters are buffered in _outBuf[2], then it may be that more
+  // characters than _putbackSize can be put back (it is essentially a matter
+  // for std::streambuf of decreasing the “next pointer for the input
+  // sequence”, i.e., the one returned by gptr()).
+  //
+  //   [2] In the [_outBuf + _putbackSize, _outBuf + _outBufSize) area.
+  const std::size_t _putbackSize;
+
+  // Since the constructor optionally allocates memory for the input and
+  // output buffers, these members allow the destructor to know which buffers
+  // have to be deallocated, if any.
+  bool _inBufMustBeFreed = false;
+  bool _outBufMustBeFreed = false;
+};
+
+
+// Stream buffer class for compressing data. Input data is obtained from an
+// std::istream instance; the corresponding compressed data can be read using
+// the standard std::streambuf read interface (mainly: sbumpc(), sgetc(),
+// snextc(), sgetn(), sputbackc(), sungetc()). Input, uncompressed data is
+// “pulled” as needed for the amount of compressed data requested by the
+// “client” using the methods I just listed.
+class ZlibCompressorIStreambuf: public ZlibAbstractIStreambuf
+{
+public:
+  // Same parameters as for ZlibAbstractIStreambuf, except:
+  //
+  //   compressionLevel: in the [0,9] range. 0 means no compression at all.
+  //                     Levels 1 to 9 yield compressed data, with 1 giving
+  //                     the highest compression speed but worst compression
+  //                     ratio, and 9 the highest compression ratio but lowest
+  //                     compression speed.
+  //   format            either ZLIB_COMPRESSION_FORMAT_ZLIB or
+  //                     ZLIB_COMPRESSION_FORMAT_GZIP
+  //   memStrategy       either ZLIB_FAVOR_MEMORY_OVER_SPEED or
+  //                     ZLIB_FAVOR_SPEED_OVER_MEMORY
+  explicit ZlibCompressorIStreambuf(
+    std::istream& iStream,
+    const SGPath& path = SGPath(),
+    int compressionLevel = Z_DEFAULT_COMPRESSION,
+    ZLibCompressionFormat format = ZLIB_COMPRESSION_FORMAT_ZLIB,
+    ZLibMemoryStrategy memStrategy = ZLIB_FAVOR_SPEED_OVER_MEMORY,
+    char* inBuf = nullptr,
+    std::size_t inBufSize = 262144,
+    char* outBuf = nullptr,
+    std::size_t outBufSize = 262144,
+    std::size_t putbackSize = 0);
+  ZlibCompressorIStreambuf(const ZlibCompressorIStreambuf&) = delete;
+  ZlibCompressorIStreambuf& operator=(const ZlibCompressorIStreambuf&) = delete;
+  ~ZlibCompressorIStreambuf();
+
+protected:
+  OperationType operationType() const override;
+  // Initialize the z_stream struct used by zlib
+  void zStreamInit(int compressionLevel, ZLibCompressionFormat format,
+                   ZLibMemoryStrategy memStrategy);
+  // Call zlib's deflate() function to compress data.
+  int zlibProcessData() override;
+};
+
+
+// Stream buffer class for decompressing data. Input data is obtained from an
+// std::istream instance; the corresponding decompressed data can be read
+// using the standard std::streambuf read interface (mainly: sbumpc(),
+// sgetc(), snextc(), sgetn(), sputbackc(), sungetc()). Input, compressed data
+// is “pulled” as needed for the amount of uncompressed data requested by the
+// “client” using the methods I just listed.
+class ZlibDecompressorIStreambuf: public ZlibAbstractIStreambuf
+{
+public:
+  // Same parameters as for ZlibAbstractIStreambuf, except:
+  //
+  //   format            ZLIB_COMPRESSION_FORMAT_ZLIB,
+  //                     ZLIB_COMPRESSION_FORMAT_GZIP or
+  //                     ZLIB_COMPRESSION_FORMAT_AUTODETECT
+  explicit ZlibDecompressorIStreambuf(
+    std::istream& iStream,
+    const SGPath& path = SGPath(),
+    ZLibCompressionFormat format = ZLIB_COMPRESSION_FORMAT_ZLIB,
+    char* inBuf = nullptr,
+    std::size_t inBufSize = 262144,
+    char* outBuf = nullptr,
+    std::size_t outBufSize = 262144,
+    std::size_t putbackSize = 0); // default optimized for speed
+  ZlibDecompressorIStreambuf(const ZlibDecompressorIStreambuf&) = delete;
+  ZlibDecompressorIStreambuf& operator=(const ZlibDecompressorIStreambuf&)
+                                                                      = delete;
+  ~ZlibDecompressorIStreambuf();
+
+protected:
+  OperationType operationType() const override;
+  void zStreamInit(ZLibCompressionFormat format);
+  int zlibProcessData() override;
+};
+
+// std::istream subclass for compressing data. Input data is obtained from an
+// std::istream instance; the corresponding compressed data can be read using
+// the standard std::istream interface (read(), readsome(), gcount(), get(),
+// getline(), operator>>(), peek(), putback(), ignore(), unget()... plus
+// operator overloads such as istream& operator>>(istream&, string&) as
+// defined in <string>, and std::getline()). Input, uncompressed data is
+// “pulled” as needed for the amount of compressed data requested by the
+// “client”.
+//
+// To get data efficiently from an instance of this class, use its read()
+// method (typically in conjunction with gcount(), inside a loop).
+class ZlibCompressorIStream: public std::istream
+{
+public:
+  // Same parameters as for ZlibCompressorIStreambuf
+  explicit ZlibCompressorIStream(
+    std::istream& iStream,
+    const SGPath& path = SGPath(),
+    int compressionLevel = Z_DEFAULT_COMPRESSION,
+    ZLibCompressionFormat format = ZLIB_COMPRESSION_FORMAT_ZLIB,
+    ZLibMemoryStrategy memStrategy = ZLIB_FAVOR_SPEED_OVER_MEMORY,
+    char* inBuf = nullptr,
+    std::size_t inBufSize = 262144,
+    char* outBuf = nullptr,
+    std::size_t outBufSize = 262144,
+    std::size_t putbackSize = 0); // default optimized for speed
+  ZlibCompressorIStream(const ZlibCompressorIStream&) = delete;
+  ZlibCompressorIStream& operator=(const ZlibCompressorIStream&) = delete;
+  ~ZlibCompressorIStream();
+
+private:
+  ZlibCompressorIStreambuf _streamBuf;
+};
+
+// std::istream subclass for decompressing data. Input data is obtained from
+// an std::istream instance; the corresponding decompressed data can be read
+// using the standard std::istream interface (read(), readsome(), gcount(),
+// get(), getline(), operator>>(), peek(), putback(), ignore(), unget()...
+// plus operator overloads such as istream& operator>>(istream&, string&) as
+// defined in <string>, and std::getline()). Input, compressed data is
+// “pulled” as needed for the amount of uncompressed data requested by the
+// “client”.
+//
+// To get data efficiently from an instance of this class, use its read()
+// method (typically in conjunction with gcount(), inside a loop).
+class ZlibDecompressorIStream: public std::istream
+{
+public:
+  // Same parameters as for ZlibDecompressorIStreambuf
+  explicit ZlibDecompressorIStream(
+    std::istream& iStream,
+    const SGPath& path = SGPath(),
+    ZLibCompressionFormat format = ZLIB_COMPRESSION_FORMAT_ZLIB,
+    char* inBuf = nullptr,
+    std::size_t inBufSize = 262144,
+    char* outBuf = nullptr,
+    std::size_t outBufSize = 262144,
+    std::size_t putbackSize = 0); // default optimized for speed
+  ZlibDecompressorIStream(const ZlibDecompressorIStream&) = delete;
+  ZlibDecompressorIStream& operator=(const ZlibDecompressorIStream&) = delete;
+  ~ZlibDecompressorIStream();
+
+private:
+  ZlibDecompressorIStreambuf _streamBuf;
+};
+
+} // of namespace simgear
+
+#endif  // of SG_ZLIBSTREAM_HXX

simgear/io/iostreams/zlibstream_test.cxx

@@ -0,0 +1,562 @@
+// -*- coding: utf-8 -*-
+//
+// zlibstream_test.cxx --- Automated tests for zlibstream.cxx / zlibstream.hxx
+//
+// Copyright (C) 2017  Florent Rougon
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+#include <ios>                  // std::basic_ios, std::streamsize...
+#include <iostream>             // std::ios_base, std::cerr, etc.
+#include <sstream>
+#include <array>
+#include <random>
+#include <limits>               // std::numeric_limits
+#include <functional>           // std::bind()
+#include <cassert>
+#include <cstdlib>              // EXIT_SUCCESS
+#include <cstddef>              // std::size_t
+#include <cstring>              // strcmp()
+
+using std::string;
+using std::cout;
+using std::cerr;
+using traits = std::char_traits<char>;
+
+#include <simgear/misc/test_macros.hxx>
+#include <simgear/io/iostreams/sgstream.hxx>
+#include <simgear/io/iostreams/zlibstream.hxx>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/misc/sg_dir.hxx>
+
+// In many tests below, I use very small buffer sizes. Of course, this is bad
+// for performance. The reason I do it this way is simply because it better
+// exercises the code we want to *test* here (we are more likely to find bugs
+// if the buffer(s) has/have to be refilled one or more times). Similarly, if
+// you don't need the putback feature in non-test code, best performance is
+// achieved with putback size = 0.
+//
+// I suggest you read roundTripWithIStreams() below to see how to use the
+// classes most efficiently (especially the comments!).
+
+static std::default_random_engine randomNumbersGenerator;
+
+// Sample string for tests
+static const string lipsum = "\
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque congue ornare\n\
+congue. Mauris mollis est et porttitor condimentum. Vivamus laoreet blandit\n\
+odio eget consectetur. Etiam quis magna eu enim luctus pretium. In et\n\
+tristique nunc, non efficitur metus. Nullam efficitur tristique velit.\n\
+Praesent et luctus nunc. Mauris eros eros, rutrum at molestie quis, egestas et\n\
+lorem. Ut nulla turpis, eleifend sed mauris ac, faucibus molestie nulla.\n\
+Quisque viverra vel turpis nec efficitur. Proin non rutrum velit. Nam sodales\n\
+metus felis, eu pharetra velit posuere ut.\n\
+\n\
+Suspendisse pellentesque tincidunt ligula et pretium. Etiam id justo mauris.\n\
+Aenean porta, sapien in suscipit tristique, metus diam malesuada dui, in porta\n\
+felis mi non felis. Etiam vel aliquam leo, non vehicula magna. Proin justo\n\
+massa, ultrices at porta eu, tempor in ligula. Duis enim ipsum, dictum quis\n\
+ultricies et, tempus eu libero. Morbi vulputate libero ut dolor rutrum, a\n\
+imperdiet nibh egestas. Phasellus finibus massa vel tempus hendrerit. Nulla\n\
+lobortis est non ligula viverra, quis egestas ante hendrerit. Pellentesque\n\
+finibus mollis blandit. In ac sollicitudin mauris, eget dignissim mauris.";
+
+// Utility function: generate a random string whose length is in the
+// [minLen, maxLen] range.
+string randomString(string::size_type minLen, string::size_type maxLen)
+{
+  std::uniform_int_distribution<string::size_type> sLenDist(minLen, maxLen);
+  std::uniform_int_distribution<int> byteDist(0, 255);
+  auto randomByte = std::bind(byteDist, randomNumbersGenerator);
+
+  string::size_type len = sLenDist(randomNumbersGenerator);
+  string str;
+
+  while (str.size() < len) {
+    str += traits::to_char_type(randomByte());
+  }
+
+  return str;
+}
+
+// Utility function: perform a compression-decompression cycle on the input
+// string using the stream buffer classes:
+//
+//   1) Compress the input string, write the result to a temporary file using
+//      std::ostream& operator<<(streambuf* sb), where 'sb' points to a
+//      ZlibCompressorIStreambuf instance.
+//
+//   2) Close the temporary file to make sure all the data is flushed.
+//
+//   3) Create a ZlibDecompressorIStreambuf instance reading from the
+//      temporary file, then decompress to an std::ostringstream using
+//      std::ostream& operator<<(streambuf* sb), where 'sb' points to our
+//      ZlibDecompressorIStreambuf instance.
+//
+//   4) Compare the result with the input string.
+//
+// Of course, it is possible to do this without any temporary file, even
+// without any std::stringstream or such to hold the intermediate, compressed
+// data. See the other tests for actual compressor + decompressor pipelines.
+void pipeCompOrDecompIStreambufIntoOStream(const string& input)
+{
+  // Test “std::ostream << &ZlibCompressorIStreambuf”
+  std::istringstream input_ss(input);
+  simgear::ZlibCompressorIStreambuf compSBuf(input_ss, SGPath(), 9);
+  simgear::Dir tmpDir = simgear::Dir::tempDir("FlightGear");
+  tmpDir.setRemoveOnDestroy();
+  SGPath path = tmpDir.path() / "testFile.dat";
+  sg_ofstream oFile(path,
+                    std::ios::binary | std::ios::trunc | std::ios::out);
+
+  oFile << &compSBuf;
+  // Make sure the compressed stream is flushed, otherwise when we read the
+  // file back, decompression is likely to fail with Z_BUF_ERROR.
+  oFile.close();
+  SG_CHECK_EQUAL(compSBuf.sgetc(), EOF);
+
+  // Read back and decompress the data we've written to 'path', testing
+  // “std::ostream << &ZlibDecompressorIStreambuf”
+  sg_ifstream iFile(path, std::ios::binary | std::ios::in);
+  simgear::ZlibDecompressorIStreambuf decompSBuf(iFile, path);
+  std::ostringstream roundTripResult_ss;
+  // This is also possible, though maybe not as good for error detection:
+  //
+  //   decompSBuf >> roundTripResult_ss.rdbuf();
+  roundTripResult_ss << &decompSBuf;
+  SG_CHECK_EQUAL(decompSBuf.sgetc(), EOF);
+  SG_CHECK_EQUAL(roundTripResult_ss.str(), input);
+}
+
+// Perform a compression-decompression cycle on bunch of strings, using the
+// stream buffer classes directly (not the std::istream subclasses).
+void test_pipeCompOrDecompIStreambufIntoOStream()
+{
+  cerr << "Compression-decompression cycles using the stream buffer classes "
+    "directly\n";
+
+  pipeCompOrDecompIStreambufIntoOStream(""); // empty string
+  pipeCompOrDecompIStreambufIntoOStream("a");
+  pipeCompOrDecompIStreambufIntoOStream("lorem ipsum");
+
+  for (int i=0; i < 10; i++) {
+    pipeCompOrDecompIStreambufIntoOStream(randomString(0, 20));
+  }
+
+  for (int i=0; i < 10; i++) {
+    pipeCompOrDecompIStreambufIntoOStream(randomString(21, 1000));
+  }
+
+  assert(std::numeric_limits<string::size_type>::max() >= 65535);
+  for (int i=0; i < 10; i++) {
+    pipeCompOrDecompIStreambufIntoOStream(randomString(1000, 65535));
+  }
+}
+
+void test_StreambufBasicOperations()
+{
+  cerr << "Testing basic operations on ZlibDecompressorIStreambuf\n";
+
+  const string text = "0123456789abcdefghijklmnopqrstuvwxyz\nABCDEF\nGHIJK "
+    "LMNOPQ";
+  std::istringstream text_ss(text);
+
+  static constexpr std::size_t compInBufSize = 6;
+  static constexpr std::size_t compOutBufSize = 4;
+  static constexpr std::size_t compPutbackSize = 0;
+  simgear::ZlibCompressorIStreambuf compSBuf(
+    text_ss, SGPath(), 8, simgear::ZLIB_COMPRESSION_FORMAT_ZLIB,
+    simgear::ZLIB_FAVOR_SPEED_OVER_MEMORY, nullptr, compInBufSize, nullptr,
+    compOutBufSize, compPutbackSize);
+  std::stringstream compressedOutput_ss;
+  compressedOutput_ss << &compSBuf;
+
+  static constexpr std::size_t decompInBufSize = 5;
+  static constexpr std::size_t decompOutBufSize = 4;
+  static constexpr std::size_t decompPutbackSize = 2;
+  simgear::ZlibDecompressorIStreambuf decompSBuf(
+    compressedOutput_ss, SGPath(), simgear::ZLIB_COMPRESSION_FORMAT_ZLIB,
+    nullptr, decompInBufSize, nullptr, decompOutBufSize, decompPutbackSize);
+
+  int ch = decompSBuf.sgetc();
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == '0');
+  ch = decompSBuf.sbumpc();
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == '0');
+  ch = decompSBuf.sbumpc();
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == '1');
+  ch = decompSBuf.snextc();
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == '3');
+  ch = decompSBuf.sbumpc();
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == '3');
+  ch = decompSBuf.sbumpc();
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == '4');
+  ch = decompSBuf.sputbackc('4');
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == '4');
+  ch = decompSBuf.sputbackc('u'); // doesn't match what we read from the stream
+  SG_VERIFY(ch == EOF);
+  ch = decompSBuf.sputbackc('3'); // this one does
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == '3');
+
+  static constexpr std::streamsize bufSize = 10;
+  char buf[bufSize];
+  // Most efficient way (with the underlying xsgetn()) to read several chars
+  // at once.
+  std::streamsize n = decompSBuf.sgetn(buf, bufSize);
+  SG_VERIFY(n == bufSize && string(buf, bufSize) == "3456789abc");
+
+  ch = decompSBuf.sungetc(); // same as sputbackc(), except no value to check
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == 'c');
+  ch = decompSBuf.sungetc();
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == 'b');
+  ch = decompSBuf.sbumpc();
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == 'b');
+  ch = decompSBuf.sputbackc('b'); // this one does
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == 'b');
+
+  n = decompSBuf.sgetn(buf, bufSize);
+  SG_VERIFY(n == bufSize && string(buf, bufSize) == "bcdefghijk");
+
+  ch = decompSBuf.sungetc();
+  SG_VERIFY(ch != EOF && traits::to_char_type(ch) == 'k');
+
+  static char buf2[64];
+  n = decompSBuf.sgetn(buf2, sizeof(buf2));
+  SG_VERIFY(n == 36 && string(buf2, n) == "klmnopqrstuvwxyz\nABCDEF\nGHIJK "
+            "LMNOPQ");
+
+  ch = decompSBuf.sbumpc();
+  SG_CHECK_EQUAL(ch, EOF);
+}
+
+// Utility function: take a string as input to compress and return the
+// compressed output as a string.
+string compress(const string& dataToCompress,
+                simgear::ZLibCompressionFormat compressionFormat,
+                int compressionLevel,
+                simgear::ZLibMemoryStrategy memStrategy,
+                std::size_t putbackSize,
+                SGPath path = SGPath())
+{
+  // Static storage is only okay for very small sizes like these, and because
+  // we won't call the function from several threads at the same time. Plain
+  // char arrays would be fine here, but I'll use std::array to show it can be
+  // used here too.
+  static std::array<char, 7> inBuf;
+  static std::array<char, 7> outBuf;
+
+  std::istringstream iss(dataToCompress);
+  simgear::ZlibCompressorIStream compressor(
+    iss, path, compressionLevel, compressionFormat, memStrategy,
+    &inBuf.front(), inBuf.size(), &outBuf.front(), outBuf.size(),
+    putbackSize);
+  compressor.exceptions(std::ios_base::badbit); // throw if badbit is set
+  std::ostringstream compressedData_ss;
+  compressor >> compressedData_ss.rdbuf();
+
+  return compressedData_ss.str();
+}
+
+void test_formattedInputFromDecompressor()
+{
+  cerr << "Testing ZlibDecompressorIStream >> std::string\n";
+
+  static char inBuf[6];
+  static char outBuf[15];
+  string compressed = compress(
+    lipsum, simgear::ZLIB_COMPRESSION_FORMAT_ZLIB, Z_BEST_COMPRESSION,
+    simgear::ZLIB_FAVOR_MEMORY_OVER_SPEED, /* putback size */ 0);
+  std::istringstream compressed_ss(compressed);
+
+  simgear::ZlibDecompressorIStream decompressor(
+    compressed_ss, SGPath(), simgear::ZLIB_COMPRESSION_FORMAT_ZLIB,
+    inBuf, sizeof(inBuf), outBuf, sizeof(outBuf), /* putback size */ 1);
+  decompressor.exceptions(std::ios_base::badbit); // throw if badbit is set
+
+  int count = 0;
+  string word;
+
+  while (decompressor >> word) {
+    count++;
+  }
+
+  SG_CHECK_EQUAL(count, 175);   // Number of words in 'lipsum'
+  // If set, badbit would have caused an exception to be raised
+  SG_VERIFY(!decompressor.bad());
+
+  if (!decompressor.eof()) {
+    assert(decompressor.fail());
+    cerr << "Decompressor: stream extraction (operator>>) failed before "
+      "reaching EOF.\n";
+    SG_TEST_FAIL("Did not expect operator>> to fail with an std::string "
+                 "argument.");
+  }
+}
+
+void test_ZlibDecompressorIStream_readPutbackEtc()
+{
+  cerr << "Testing many operations on ZlibDecompressorIStream (read(), "
+    "putback(), etc.\n";
+
+  static char compInBuf[4];
+  static char compOutBuf[6];
+  static char decompInBuf[8];
+  static char decompOutBuf[5];
+  const string text = "0123456789abcdefghijklmnopqrstuvwxyz\nABCDEF\nGHIJK "
+    "LMNOPQ";
+  std::istringstream text_ss(text);
+
+  simgear::ZlibCompressorIStream compressor(
+    text_ss, SGPath(), Z_BEST_COMPRESSION,
+    simgear::ZLIB_COMPRESSION_FORMAT_ZLIB,
+    simgear::ZLIB_FAVOR_MEMORY_OVER_SPEED,
+    compInBuf, sizeof(compInBuf), compOutBuf, sizeof(compOutBuf),
+    /* putback size */ 0);
+  compressor.exceptions(std::ios_base::badbit); // throw if badbit is set
+
+  // Use the compressor (subclass of std::istream) as input to the decompressor
+  simgear::ZlibDecompressorIStream decompressor(
+    compressor, SGPath(), simgear::ZLIB_COMPRESSION_FORMAT_ZLIB,
+    decompInBuf, sizeof(decompInBuf), decompOutBuf, sizeof(decompOutBuf),
+    /* putback size */ 3);
+  decompressor.exceptions(std::ios_base::badbit);
+
+  {
+    static std::array<char, 17> buf;
+    decompressor.read(&buf.front(), 10);
+    SG_VERIFY(decompressor.good() && decompressor.gcount() == 10);
+    SG_CHECK_EQUAL(string(&buf.front(), 10), "0123456789");
+
+    SG_VERIFY(decompressor.putback('9'));
+    SG_VERIFY(decompressor.putback('8'));
+    SG_VERIFY(decompressor.putback('7'));
+
+    SG_VERIFY(decompressor.get(buf[10]));
+    SG_VERIFY(decompressor.read(&buf[11], 6));
+    SG_CHECK_EQUAL(string(&buf.front(), 17), "0123456789789abcd");
+  }
+
+  {
+    bool gotException = false;
+    try {
+      // 'Z' is not the last character read from the stream
+      decompressor.putback('Z');
+    } catch (std::ios_base::failure) {
+      gotException = true;
+    }
+    SG_VERIFY(gotException && decompressor.bad());
+  }
+
+  {
+    int c;
+
+    decompressor.clear();
+    // Check we can resume normally now that we've cleared the error state flags
+    c = decompressor.get();
+    SG_VERIFY(c != traits::eof() && traits::to_char_type(c) == 'e');
+
+    // unget() and get() in sequence
+    SG_VERIFY(decompressor.unget());
+    c = decompressor.get();
+    SG_VERIFY(c != traits::eof() && traits::to_char_type(c)== 'e');
+
+    // peek() looks at, but doesn't consume
+    c = decompressor.peek();
+    SG_VERIFY(c != traits::eof() && traits::to_char_type(c) == 'f');
+    c = decompressor.get();
+    SG_VERIFY(c != traits::eof() && traits::to_char_type(c)== 'f');
+  }
+
+  {
+    static std::array<char, 21> buf; // 20 chars + terminating NUL char
+
+    // std::istream::getline() will be stopped by \n after reading 20 chars
+    SG_VERIFY(decompressor.getline(&buf.front(), 25));
+    SG_VERIFY(decompressor.gcount() == 21 &&
+              !strcmp(&buf.front(), "ghijklmnopqrstuvwxyz"));
+
+    string str;
+    // std::getline() will be stopped by \n after 7 chars have been extracted,
+    // namely 6 chars plus the \n which is extracted and discarded.
+    SG_VERIFY(std::getline(decompressor, str));
+    SG_CHECK_EQUAL(str, "ABCDEF");
+
+    SG_VERIFY(decompressor.ignore(2));
+    SG_VERIFY(decompressor >> str);
+    SG_CHECK_EQUAL(str, "IJK");
+
+    static char buf2[5];
+    // Read up to sizeof(buf) chars, without waiting if not that many are
+    // immediately avaiable.
+    int nbCharsRead = decompressor.readsome(buf2, sizeof(buf2));
+
+    string rest(buf2, nbCharsRead);
+    do {
+      decompressor.read(buf2, sizeof(buf2));
+      rest += string(buf2, decompressor.gcount());
+    } while (decompressor);
+
+    SG_CHECK_EQUAL(rest, " LMNOPQ");
+  }
+
+  // If set, badbit would have caused an exception to be raised, anyway
+  SG_VERIFY(decompressor.eof() && !decompressor.bad());
+}
+
+// Utility function: parametrized round-trip test with a compressor +
+// decompressor pipeline.
+//
+//
+// Note: this is nice conceptually, allows to keep memory use constant even in
+//       case an arbitrary amount of data is passed through, and exercises the
+//       stream buffer classes well, however this technique is more than twice
+//       as slow on my computer than using an intermediate buffer like this:
+//
+//         std::stringstream compressedData_ss;
+//         compressor >> compressedData_ss.rdbuf();
+//
+//         simgear::ZlibDecompressorIStream decompressor(compressedData_ss,
+//                                                       SGPath(), ...
+void roundTripWithIStreams(
+  simgear::ZLibCompressionFormat compressionFormat,
+  int compressionLevel,
+  simgear::ZLibMemoryStrategy memStrategy,
+  std::size_t compInBufSize,
+  std::size_t compOutBufSize,
+  std::size_t decompInBufSize,
+  std::size_t decompOutBufSize,
+  std::size_t compPutbackSize,
+  std::size_t decompPutbackSize,
+  bool useAutoFormatForDecompression = false)
+{
+  const simgear::ZLibCompressionFormat decompFormat =
+    (useAutoFormatForDecompression) ?
+    simgear::ZLIB_COMPRESSION_FORMAT_AUTODETECT : compressionFormat;
+
+  std::istringstream lipsum_ss(lipsum);
+  // This tests the optional dynamic buffer allocation in ZlibAbstractIStreambuf
+  simgear::ZlibCompressorIStream compressor(
+    lipsum_ss, SGPath(), compressionLevel, compressionFormat, memStrategy,
+    nullptr, compInBufSize, nullptr, compOutBufSize, compPutbackSize);
+  compressor.exceptions(std::ios_base::badbit); // throw if badbit is set
+
+  // Use the compressor as input to the decompressor (pipeline). The
+  // decompressor uses read() with chunks that are as large as possible given
+  // the available space in its input buffer. These read() calls are served by
+  // ZlibCompressorIStreambuf::xsgetn(), which is efficient.
+  simgear::ZlibDecompressorIStream decompressor(
+    compressor, SGPath(), decompFormat,
+    nullptr, decompInBufSize, nullptr, decompOutBufSize, decompPutbackSize);
+  decompressor.exceptions(std::ios_base::badbit);
+  std::ostringstream roundTripResult;
+  // This, on the other hand, appears not to use xsgetn() (tested with the GNU
+  // libstdc++ from g++ 6.3.0, 20170124). This causes useless copying of the
+  // data to the decompressor output buffer, instead of writing it directly to
+  // roundTripResult's internal buffer. This is simple and nice in appearance,
+  // but if you are after performance, better use decompressor.read()
+  // (typically in conjunction with gcount(), inside a loop).
+  decompressor >> roundTripResult.rdbuf();
+  SG_CHECK_EQUAL(roundTripResult.str(), lipsum);
+}
+
+// Round-trip conversion with simgear::ZlibCompressorIStream and
+// simgear::ZlibDecompressorIStream, using various parameter combinations.
+void test_RoundTripMultiWithIStreams()
+{
+  cerr <<
+    "Compression-decompression cycles using the std::istream subclasses (many\n"
+    "combinations of buffer sizes and compression parameters tested)\n";
+
+  { // More variations on these later
+    const std::size_t compPutbackSize = 1;
+    const std::size_t decompPutbackSize = 1;
+
+    for (auto format: {simgear::ZLIB_COMPRESSION_FORMAT_ZLIB,
+          simgear::ZLIB_COMPRESSION_FORMAT_GZIP}) {
+      for (int compressionLevel: {1, 4, 7, 9}) {
+        for (auto memStrategy: {simgear::ZLIB_FAVOR_MEMORY_OVER_SPEED,
+              simgear::ZLIB_FAVOR_SPEED_OVER_MEMORY}) {
+          for (std::size_t compInBufSize: {3, 4}) {
+            for (std::size_t compOutBufSize: {3, 5}) {
+              for (std::size_t decompInBufSize: {3, 4}) {
+                for (std::size_t decompOutBufSize: {3, 4,}) {
+                  roundTripWithIStreams(
+                    format, compressionLevel, memStrategy, compInBufSize,
+                    compOutBufSize, decompInBufSize, decompOutBufSize,
+                    compPutbackSize, decompPutbackSize);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  {
+    const auto format = simgear::ZLIB_COMPRESSION_FORMAT_ZLIB;
+    const int compressionLevel = Z_DEFAULT_COMPRESSION;
+    const auto memStrategy = simgear::ZLIB_FAVOR_SPEED_OVER_MEMORY;
+
+    for (std::size_t compInBufSize: {3, 4, 31, 256, 19475}) {
+      for (std::size_t compOutBufSize: {3, 5, 9, 74, 4568}) {
+        for (std::size_t decompInBufSize: {3, 4, 256, 24568}) {
+          for (std::size_t decompOutBufSize: {3, 5, 42, 4568}) {
+            for (std::size_t compPutbackSize: {0, 1, 2}) {
+              for (std::size_t decompPutbackSize: {0, 1, 2}) {
+                roundTripWithIStreams(
+                  format, compressionLevel, memStrategy, compInBufSize,
+                  compOutBufSize, decompInBufSize, decompOutBufSize,
+                  compPutbackSize, decompPutbackSize);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  {
+    const std::size_t compInBufSize = 5;
+    const std::size_t compOutBufSize = 107;
+    const std::size_t decompInBufSize = 65536;
+    const std::size_t decompOutBufSize = 84;
+    int i = 0;
+
+    for (std::size_t compPutbackSize: {25, 40, 105}) {
+      for (std::size_t decompPutbackSize: {30, 60, 81}) {
+        const simgear::ZLibCompressionFormat compFormat = (i++ % 2) ?
+          simgear::ZLIB_COMPRESSION_FORMAT_ZLIB :
+          simgear::ZLIB_COMPRESSION_FORMAT_GZIP;
+
+        roundTripWithIStreams(
+          compFormat, Z_BEST_COMPRESSION, simgear::ZLIB_FAVOR_MEMORY_OVER_SPEED,
+          compInBufSize, compOutBufSize, decompInBufSize, decompOutBufSize,
+          compPutbackSize, decompPutbackSize,
+          /* automatic format detection for decompression */ true);
+      }
+    }
+  }
+}
+
+int main(int argc, char** argv)
+{
+  test_pipeCompOrDecompIStreambufIntoOStream();
+  test_StreambufBasicOperations();
+  test_RoundTripMultiWithIStreams();
+  test_formattedInputFromDecompressor();
+  test_ZlibDecompressorIStream_readPutbackEtc();
+
+  return EXIT_SUCCESS;
+}

simgear/io/sg_binobj.cxx

@@ -94,6 +94,17 @@ enum sgVertexAttributeTypes {
     SG_VA_FLOAT_3 =   0x00000800,
 };
 
+static gzFile gzFileFromSGPath(const SGPath& path, const char* mode)
+{
+  #if defined(SG_WINDOWS)
+  	std::wstring ws = path.wstr();
+  	return gzopen_w(ws.c_str(), mode);
+  #else
+    std::string ps = path.utf8Str();
+    return gzopen(ps.c_str(), mode);
+  #endif
+}
+
 enum sgPropertyTypes {
     SG_MATERIAL = 0,
     SG_INDEX_TYPES = 1,
@@ -125,115 +136,115 @@ public:
 
     unsigned int get_size() const { return size; }
     char *get_ptr() const { return ptr; }
-    
+
     void reset()
     {
         offset = 0;
     }
-    
+
     void resize( unsigned int s )
     {
         if ( s > size ) {
             if ( ptr != NULL ) {
                 delete [] ptr;
             }
-          
+
             if ( size == 0) {
                 size = 16;
             }
-          
+
             while ( size < s ) {
               size = size << 1;
             }
             ptr = new char[size];
         }
     }
-    
+
     float readInt()
     {
         unsigned int* p = reinterpret_cast<unsigned int*>(ptr + offset);
-        if ( sgIsBigEndian() ) {            
+        if ( sgIsBigEndian() ) {
             sgEndianSwap((uint32_t *) p);
         }
-        
+
         offset += sizeof(unsigned int);
         return *p;
     }
-    
+
     SGVec3d readVec3d()
     {
         double* p = reinterpret_cast<double*>(ptr + offset);
-        
-        if ( sgIsBigEndian() ) {            
+
+        if ( sgIsBigEndian() ) {
             sgEndianSwap((uint64_t *) p + 0);
             sgEndianSwap((uint64_t *) p + 1);
             sgEndianSwap((uint64_t *) p + 2);
         }
-        
+
         offset += 3 * sizeof(double);
         return SGVec3d(p);
     }
-    
+
     float readFloat()
     {
         float* p = reinterpret_cast<float*>(ptr + offset);
-        if ( sgIsBigEndian() ) {            
+        if ( sgIsBigEndian() ) {
             sgEndianSwap((uint32_t *) p);
         }
-        
+
         offset += sizeof(float);
         return *p;
     }
-    
+
     SGVec2f readVec2f()
     {
         float* p = reinterpret_cast<float*>(ptr + offset);
-        
-        if ( sgIsBigEndian() ) {            
+
+        if ( sgIsBigEndian() ) {
             sgEndianSwap((uint32_t *) p + 0);
             sgEndianSwap((uint32_t *) p + 1);
         }
-        
+
         offset += 2 * sizeof(float);
         return SGVec2f(p);
     }
-    
+
     SGVec3f readVec3f()
     {
         float* p = reinterpret_cast<float*>(ptr + offset);
-        
-        if ( sgIsBigEndian() ) {            
+
+        if ( sgIsBigEndian() ) {
             sgEndianSwap((uint32_t *) p + 0);
             sgEndianSwap((uint32_t *) p + 1);
             sgEndianSwap((uint32_t *) p + 2);
         }
-        
+
         offset += 3 * sizeof(float);
         return SGVec3f(p);
     }
-    
+
     SGVec4f readVec4f()
     {
         float* p = reinterpret_cast<float*>(ptr + offset);
-        
-        if ( sgIsBigEndian() ) {            
+
+        if ( sgIsBigEndian() ) {
             sgEndianSwap((uint32_t *) p + 0);
             sgEndianSwap((uint32_t *) p + 1);
             sgEndianSwap((uint32_t *) p + 2);
             sgEndianSwap((uint32_t *) p + 3);
         }
-        
+
         offset += 4 * sizeof(float);
         return SGVec4f(p);
     }
 };
 
 template <class T>
-static void read_indices(char* buffer, 
+static void read_indices(char* buffer,
                          size_t bytes,
                          int indexMask,
                          int vaMask,
-                         int_list& vertices, 
+                         int_list& vertices,
                          int_list& normals,
                          int_list& colors,
                          tci_list& texCoords,
@@ -243,7 +254,7 @@ static void read_indices(char* buffer,
     const int indexSize = sizeof(T) * std::bitset<32>((int)indexMask).count();
     const int vaSize = sizeof(T) * std::bitset<32>((int)vaMask).count();
     const int count = bytes / (indexSize + vaSize);
-    
+
     // fix endian-ness of the whole lot, if required
     if (sgIsBigEndian()) {
         int indices = bytes / sizeof(T);
@@ -252,7 +263,7 @@ static void read_indices(char* buffer,
             sgEndianSwap(src++);
         }
     }
-    
+
     T* src = reinterpret_cast<T*>(buffer);
     for (int i=0; i<count; ++i) {
         if (indexMask & SG_IDX_VERTICES) vertices.push_back(*src++);
@@ -262,7 +273,7 @@ static void read_indices(char* buffer,
         if (indexMask & SG_IDX_TEXCOORDS_1) texCoords[1].push_back(*src++);
         if (indexMask & SG_IDX_TEXCOORDS_2) texCoords[2].push_back(*src++);
         if (indexMask & SG_IDX_TEXCOORDS_3) texCoords[3].push_back(*src++);
-        
+
         if ( vaMask ) {
             if (vaMask & SG_VA_INTEGER_0) vas[0].push_back(*src++);
             if (vaMask & SG_VA_INTEGER_1) vas[1].push_back(*src++);
@@ -274,11 +285,11 @@ static void read_indices(char* buffer,
             if (vaMask & SG_VA_FLOAT_3) vas[7].push_back(*src++);
         }
     } // of elements in the index
-    
+
     // WS2.0 fix : toss zero area triangles
     if ( ( count == 3 ) && (indexMask & SG_IDX_VERTICES) ) {
-        if ( (vertices[0] == vertices[1]) || 
-             (vertices[1] == vertices[2]) || 
+        if ( (vertices[0] == vertices[1]) ||
+             (vertices[1] == vertices[2]) ||
              (vertices[2] == vertices[0]) ) {
             vertices.clear();
         }
@@ -306,11 +317,11 @@ void write_indice(gzFile fp, uint32_t value)
 
 
 template <class T>
-void write_indices(gzFile fp, 
-    unsigned char indexMask, 
+void write_indices(gzFile fp,
+    unsigned char indexMask,
     unsigned int vaMask,
-    const int_list& vertices, 
-    const int_list& normals, 
+    const int_list& vertices,
+    const int_list& normals,
     const int_list& colors,
     const tci_list& texCoords,
     const vai_list& vas )
@@ -319,10 +330,10 @@ void write_indices(gzFile fp,
     const int indexSize = sizeof(T) * std::bitset<32>((int)indexMask).count();
     const int vaSize = sizeof(T) * std::bitset<32>((int)vaMask).count();
     sgWriteUInt(fp, (indexSize + vaSize) * count);
-            
+
     for (unsigned int i=0; i < count; ++i) {
         write_indice(fp, static_cast<T>(vertices[i]));
-        
+
         if (indexMask & SG_IDX_NORMALS) {
             write_indice(fp, static_cast<T>(normals[i]));
         }
@@ -341,7 +352,7 @@ void write_indices(gzFile fp,
         if (indexMask & SG_IDX_TEXCOORDS_3) {
             write_indice(fp, static_cast<T>(texCoords[3][i]));
         }
-        
+
         if (vaMask) {
             if (vaMask & SG_VA_INTEGER_0) {
                 write_indice(fp, static_cast<T>(vas[0][i]));
@@ -378,7 +389,7 @@ void SGBinObject::read_object( gzFile fp,
                          int obj_type,
                          int nproperties,
                          int nelements,
-                         group_list& vertices, 
+                         group_list& vertices,
                          group_list& normals,
                          group_list& colors,
                          group_tci_list& texCoords,
@@ -399,15 +410,15 @@ void SGBinObject::read_object( gzFile fp,
         idx_mask = (char)(SG_IDX_VERTICES | SG_IDX_TEXCOORDS_0);
     }
     vertex_attrib_mask = 0;
-    
+
     for ( j = 0; j < nproperties; ++j ) {
         char prop_type;
         sgReadChar( fp, &prop_type );
         sgReadUInt( fp, &nbytes );
-        
+
         buf.resize(nbytes);
         char *ptr = buf.get_ptr();
-        
+
         switch( prop_type )
         {
             case SG_MATERIAL:
@@ -418,12 +429,12 @@ void SGBinObject::read_object( gzFile fp,
                 strncpy( material, ptr, nbytes );
                 material[nbytes] = '\0';
                 break;
-                
+
             case SG_INDEX_TYPES:
                 if (nbytes == 1) {
-                    sgReadChar( fp, (char *)&idx_mask );                    
+                    sgReadChar( fp, (char *)&idx_mask );
                 } else {
-                    sgReadBytes( fp, nbytes, ptr );                    
+                    sgReadBytes( fp, nbytes, ptr );
                 }
                 break;
 
@@ -434,7 +445,7 @@ void SGBinObject::read_object( gzFile fp,
                     sgReadBytes( fp, nbytes, ptr );
                 }
                 break;
-                
+
             default:
                 sgReadBytes( fp, nbytes, ptr );
                 SG_LOG(SG_IO, SG_ALERT, "Found UNKNOWN property type with nbytes == " << nbytes << " mask is " << (int)idx_mask );
@@ -445,26 +456,26 @@ void SGBinObject::read_object( gzFile fp,
     if ( sgReadError() ) {
         throw sg_exception("Error reading object properties");
     }
-    
+
     size_t indexCount = std::bitset<32>((int)idx_mask).count();
     if (indexCount == 0) {
         throw sg_exception("object index mask has no bits set");
     }
-    
+
     for ( j = 0; j < nelements; ++j ) {
         sgReadUInt( fp, &nbytes );
         if ( sgReadError() ) {
             throw sg_exception("Error reading element size");
         }
-        
+
         buf.resize( nbytes );
         char *ptr = buf.get_ptr();
         sgReadBytes( fp, nbytes, ptr );
-        
+
         if ( sgReadError() ) {
             throw sg_exception("Error reading element bytes");
         }
-                
+
         int_list vs;
         int_list ns;
         int_list cs;
@@ -491,7 +502,7 @@ void SGBinObject::read_object( gzFile fp,
 
 
 // read a binary file and populate the provided structures.
-bool SGBinObject::read_bin( const string& file ) {
+bool SGBinObject::read_bin( const SGPath& file ) {
     SGVec3d p;
     int i, k;
     size_t j;
@@ -534,12 +545,14 @@ bool SGBinObject::read_bin( const string& file ) {
     fans_vas.clear();
     fan_materials.clear();
 
-    gzFile fp;
-    if ( (fp = gzopen( file.c_str(), "rb" )) == NULL ) {
-        string filegz = file + ".gz";
-        if ( (fp = gzopen( filegz.c_str(), "rb" )) == NULL ) {
+    gzFile fp = gzFileFromSGPath(file, "rb");
+    if ( fp == NULL ) {
+        SGPath withGZ = file;
+        withGZ.concat(".gz");
+        fp = gzFileFromSGPath(withGZ, "rb");
+        if (fp == nullptr) {
             SG_LOG( SG_EVENT, SG_ALERT,
-               "ERROR: opening " << file << " or " << filegz << " for reading!");
+               "ERROR: opening " << file << " or " << withGZ << " for reading!");
 
             throw sg_io_exception("Error opening for reading (and .gz)", sg_location(file));
         }
@@ -552,7 +565,7 @@ bool SGBinObject::read_bin( const string& file ) {
     sgReadUInt( fp, &header );
     if ( ((header & 0xFF000000) >> 24) == 'S' &&
          ((header & 0x00FF0000) >> 16) == 'G' ) {
-    
+
         // read file version
         version = (header & 0x0000FFFF);
     } else {
@@ -560,7 +573,7 @@ bool SGBinObject::read_bin( const string& file ) {
         gzclose(fp);
         throw sg_io_exception("Bad BTG magic/version", sg_location(file));
     }
-    
+
     // read creation time
     unsigned int foo_calendar_time;
     sgReadUInt( fp, &foo_calendar_time );
@@ -591,13 +604,13 @@ bool SGBinObject::read_bin( const string& file ) {
         sgReadShort( fp, &v );
         nobjects = v;
     }
-     
+
     SG_LOG(SG_IO, SG_DEBUG, "SGBinObject::read_bin Total objects to read = " << nobjects);
 
     if ( sgReadError() ) {
         throw sg_io_exception("Error reading BTG file header", sg_location(file));
     }
-    
+
     // read in objects
     for ( i = 0; i < nobjects; ++i ) {
         // read object header
@@ -621,14 +634,14 @@ bool SGBinObject::read_bin( const string& file ) {
             nelements = v;
         }
 
-        SG_LOG(SG_IO, SG_DEBUG, "SGBinObject::read_bin object " << i << 
-                " = " << (int)obj_type << " props = " << nproperties << 
+        SG_LOG(SG_IO, SG_DEBUG, "SGBinObject::read_bin object " << i <<
+                " = " << (int)obj_type << " props = " << nproperties <<
                 " elements = " << nelements);
-         
+
         if ( obj_type == SG_BOUNDING_SPHERE ) {
             // read bounding sphere properties
             read_properties( fp, nproperties );
-            
+
             // read bounding sphere elements
             for ( j = 0; j < nelements; ++j ) {
                 sgReadUInt( fp, &nbytes );
@@ -688,10 +701,10 @@ bool SGBinObject::read_bin( const string& file ) {
                 sgReadBytes( fp, nbytes, ptr );
                 int count = nbytes / 3;
                 normals.reserve( count );
- 
+
                 for ( k = 0; k < count; ++k ) {
                     SGVec3f normal( (ptr[0]) / 127.5 - 1.0,
-                                    (ptr[1]) / 127.5 - 1.0, 
+                                    (ptr[1]) / 127.5 - 1.0,
                                     (ptr[2]) / 127.5 - 1.0);
                     normals.push_back(normalize(normal));
                     ptr += 3;
@@ -717,7 +730,7 @@ bool SGBinObject::read_bin( const string& file ) {
         } else if ( obj_type == SG_VA_FLOAT_LIST ) {
             // read vertex attribute (float) properties
             read_properties( fp, nproperties );
-            
+
             // read vertex attribute list elements
             for ( j = 0; j < nelements; ++j ) {
                 sgReadUInt( fp, &nbytes );
@@ -734,7 +747,7 @@ bool SGBinObject::read_bin( const string& file ) {
         } else if ( obj_type == SG_VA_INTEGER_LIST ) {
             // read vertex attribute (integer) properties
             read_properties( fp, nproperties );
-            
+
             // read vertex attribute list elements
             for ( j = 0; j < nelements; ++j ) {
                 sgReadUInt( fp, &nbytes );
@@ -781,7 +794,7 @@ bool SGBinObject::read_bin( const string& file ) {
                 sgReadBytes( fp, nbytes, ptr );
             }
         }
-        
+
         if ( sgReadError() ) {
             throw sg_io_exception("Error while reading object", sg_location(file, i));
         }
@@ -811,38 +824,38 @@ unsigned int SGBinObject::count_objects(const string_list& materials)
     unsigned int start = 0, end = 1;
     unsigned int count = materials.size();
     string m;
-    
+
     while ( start < count ) {
         m = materials[start];
-        for (end = start+1; (end < count) && (m == materials[end]); ++end) { }     
+        for (end = start+1; (end < count) && (m == materials[end]); ++end) { }
         ++result;
-        start = end; 
+        start = end;
     }
-    
+
     return result;
 }
 
-void SGBinObject::write_objects(gzFile fp, int type, 
+void SGBinObject::write_objects(gzFile fp, int type,
                                 const group_list& verts,
-                                const group_list& normals, 
-                                const group_list& colors, 
+                                const group_list& normals,
+                                const group_list& colors,
                                 const group_tci_list& texCoords,
-                                const group_vai_list& vertexAttribs, 
+                                const group_vai_list& vertexAttribs,
                                 const string_list& materials)
 {
     if (verts.empty()) {
         return;
     }
-        
+
     unsigned int start = 0, end = 1;
     string m;
     int_list emptyList;
-    
+
     while (start < materials.size()) {
         m = materials[start];
         // find range of objects with identical material, write out as a single object
         for (end = start+1; (end < materials.size()) && (m == materials[end]); ++end) {}
-    
+
         // calc the number of elements
         const int count = end - start;
 
@@ -860,13 +873,13 @@ void SGBinObject::write_objects(gzFile fp, int type,
         } else {
             write_header(fp, type, 2, count);
         }
-        
+
     // properties
         // material property
         sgWriteChar( fp, (char)SG_MATERIAL );        // property
         sgWriteUInt( fp, m.length() );        // nbytes
         sgWriteBytes( fp, m.length(), m.c_str() );
-    
+
         // index mask property
         unsigned char idx_mask = 0;
         if ( !verts.empty() && !verts[start].empty()) idx_mask |= SG_IDX_VERTICES;
@@ -876,7 +889,7 @@ void SGBinObject::write_objects(gzFile fp, int type,
         if ( !texCoords.empty() && !texCoords[start][1].empty()) idx_mask |= SG_IDX_TEXCOORDS_1;
         if ( !texCoords.empty() && !texCoords[start][2].empty()) idx_mask |= SG_IDX_TEXCOORDS_2;
         if ( !texCoords.empty() && !texCoords[start][3].empty()) idx_mask |= SG_IDX_TEXCOORDS_3;
-        
+
         if (idx_mask == 0) {
             SG_LOG(SG_IO, SG_ALERT, "SGBinObject::write_objects: object with material:"
                 << m << "has no indices set");
@@ -892,28 +905,28 @@ void SGBinObject::write_objects(gzFile fp, int type,
             sgWriteUInt( fp, 4 );                        // nbytes
             sgWriteChar( fp, va_mask );
         }
-        
+
     // elements
         for (unsigned int i=start; i < end; ++i) {
             const int_list& va(verts[i]);
             const int_list& na((idx_mask & SG_IDX_NORMALS) ? normals[i] : emptyList);
             const int_list& ca((idx_mask & SG_IDX_COLORS) ? colors[i] : emptyList);
 
-            // pass the whole texcoord array - we'll figure out which indicies to write 
+            // pass the whole texcoord array - we'll figure out which indicies to write
             // in write_indices
             const tci_list& tca( texCoords[i] );
 
-            // pass the whole vertex array - we'll figure out which indicies to write 
+            // pass the whole vertex array - we'll figure out which indicies to write
             // in write_indices
             const vai_list& vaa( vertexAttribs[i] );
-            
+
             if (version == 7) {
                 write_indices<uint16_t>(fp, idx_mask, va_mask, va, na, ca, tca, vaa);
             } else {
                 write_indices<uint32_t>(fp, idx_mask, va_mask, va, na, ca, tca, vaa);
             }
         }
-    
+
         start = end;
     } // of materials iteration
 }
@@ -952,25 +965,25 @@ const unsigned int VERSION_7_MATERIAL_LIMIT = 0x7fff;
 bool SGBinObject::write_bin_file(const SGPath& file)
 {
     int i;
-    
+
     SGPath file2(file);
     file2.create_dir( 0755 );
 
-    gzFile fp;
-    if ( (fp = gzopen( file.c_str(), "wb9" )) == NULL ) {
-        cout << "ERROR: opening " << file.str() << " for writing!" << endl;
+    gzFile fp = gzFileFromSGPath(file, "wb9");
+    if ( fp == nullptr ) {
+        cout << "ERROR: opening " << file << " for writing!" << endl;
         return false;
     }
 
     sgClearWriteError();
 
-    SG_LOG(SG_IO, SG_DEBUG, "points size = " << pts_v.size() 
+    SG_LOG(SG_IO, SG_DEBUG, "points size = " << pts_v.size()
          << "  pt_materials = " << pt_materials.size() );
-    SG_LOG(SG_IO, SG_DEBUG, "triangles size = " << tris_v.size() 
+    SG_LOG(SG_IO, SG_DEBUG, "triangles size = " << tris_v.size()
          << "  tri_materials = " << tri_materials.size() );
-    SG_LOG(SG_IO, SG_DEBUG, "strips size = " << strips_v.size() 
+    SG_LOG(SG_IO, SG_DEBUG, "strips size = " << strips_v.size()
          << "  strip_materials = " << strip_materials.size() );
-    SG_LOG(SG_IO, SG_DEBUG, "fans size = " << fans_v.size() 
+    SG_LOG(SG_IO, SG_DEBUG, "fans size = " << fans_v.size()
          << "  fan_materials = " << fan_materials.size() );
 
     SG_LOG(SG_IO, SG_DEBUG, "nodes = " << wgs84_nodes.size() );
@@ -979,12 +992,12 @@ bool SGBinObject::write_bin_file(const SGPath& file)
     SG_LOG(SG_IO, SG_DEBUG, "tex coords = " << texcoords.size() );
 
     version = 10;
-    bool shortMaterialsRanges = 
+    bool shortMaterialsRanges =
         (max_object_size(pt_materials) < VERSION_7_MATERIAL_LIMIT) &&
         (max_object_size(fan_materials) < VERSION_7_MATERIAL_LIMIT) &&
         (max_object_size(strip_materials) < VERSION_7_MATERIAL_LIMIT) &&
         (max_object_size(tri_materials) < VERSION_7_MATERIAL_LIMIT);
-                    
+
     if ((wgs84_nodes.size() < 0xffff) &&
         (normals.size() < 0xffff) &&
         (texcoords.size() < 0xffff) &&
@@ -993,10 +1006,10 @@ bool SGBinObject::write_bin_file(const SGPath& file)
     }
 
     // write header magic
-    
+
     /** Magic Number for our file format */
     #define SG_FILE_MAGIC_NUMBER  ( ('S'<<24) + ('G'<<16) + version )
-    
+
     sgWriteUInt( fp, SG_FILE_MAGIC_NUMBER );
     time_t calendar_time = time(NULL);
     sgWriteLong( fp, (int32_t)calendar_time );
@@ -1014,8 +1027,8 @@ bool SGBinObject::write_bin_file(const SGPath& file)
         sgWriteUShort( fp, (uint16_t) nobjects );
     } else {
         sgWriteInt( fp, nobjects );
-    } 
-    
+    }
+
     // write bounding sphere
     write_header( fp, SG_BOUNDING_SPHERE, 0, 1);
     sgWriteUInt( fp, sizeof(double) * 3 + sizeof(float) ); // nbytes
@@ -1059,12 +1072,12 @@ bool SGBinObject::write_bin_file(const SGPath& file)
     write_objects(fp, SG_TRIANGLE_FACES, tris_v, tris_n, tris_c, tris_tcs, tris_vas, tri_materials);
     write_objects(fp, SG_TRIANGLE_STRIPS, strips_v, strips_n, strips_c, strips_tcs, strips_vas, strip_materials);
     write_objects(fp, SG_TRIANGLE_FANS, fans_v, fans_n, fans_c, fans_tcs, fans_vas, fan_materials);
-    
+
     // close the file
     gzclose(fp);
 
     if ( sgWriteError() ) {
-        cout << "Error while writing file " << file.str() << endl;
+        cout << "Error while writing file " << file << endl;
         return false;
     }
 
@@ -1082,19 +1095,20 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
 
     SGPath file = base + "/" + b.gen_base_path() + "/" + name;
     file.create_dir( 0755 );
-    cout << "Output file = " << file.str() << endl;
+    cout << "Output file = " << file << endl;
 
     FILE *fp;
-    if ( (fp = fopen( file.c_str(), "w" )) == NULL ) {
-        cout << "ERROR: opening " << file.str() << " for writing!" << endl;
+    std::string path = file.local8BitStr();
+    if ( (fp = fopen( path.c_str(), "w" )) == NULL ) {
+        cout << "ERROR: opening " << file << " for writing!" << endl;
         return false;
     }
 
-    cout << "triangles size = " << tris_v.size() << "  tri_materials = " 
+    cout << "triangles size = " << tris_v.size() << "  tri_materials = "
          << tri_materials.size() << endl;
-    cout << "strips size = " << strips_v.size() << "  strip_materials = " 
+    cout << "strips size = " << strips_v.size() << "  strip_materials = "
          << strip_materials.size() << endl;
-    cout << "fans size = " << fans_v.size() << "  fan_materials = " 
+    cout << "fans size = " << fans_v.size() << "  fan_materials = "
          << fan_materials.size() << endl;
 
     cout << "points = " << wgs84_nodes.size() << endl;
@@ -1120,7 +1134,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
     fprintf(fp, "# vertex list\n");
     for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
         SGVec3d p = wgs84_nodes[i] - gbs_center;
-        
+
         fprintf(fp,  "v %.5f %.5f %.5f\n", p.x(), p.y(), p.z() );
     }
     fprintf(fp, "\n");
@@ -1150,7 +1164,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
         while ( start < (int)tri_materials.size() ) {
             // find next group
             material = tri_materials[start];
-            while ( (end < (int)tri_materials.size()) && 
+            while ( (end < (int)tri_materials.size()) &&
                     (material == tri_materials[end]) )
             {
                 // cout << "end = " << end << endl;
@@ -1164,10 +1178,10 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
           d.expandBy(wgs84_nodes[ tris_v[i][j] ]);
         }
       }
-      
+
       SGVec3d bs_center = d.getCenter();
       double bs_radius = d.getRadius();
-            
+
             // write group headers
             fprintf(fp, "\n");
             fprintf(fp, "# usemtl %s\n", material.c_str());
@@ -1198,7 +1212,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
         while ( start < (int)strip_materials.size() ) {
             // find next group
             material = strip_materials[start];
-            while ( (end < (int)strip_materials.size()) && 
+            while ( (end < (int)strip_materials.size()) &&
                     (material == strip_materials[end]) )
                 {
                     // cout << "end = " << end << endl;
@@ -1213,7 +1227,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
           d.expandBy(wgs84_nodes[ tris_v[i][j] ]);
         }
       }
-      
+
       SGVec3d bs_center = d.getCenter();
       double bs_radius = d.getRadius();
 
@@ -1231,7 +1245,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
                 }
                 fprintf(fp, "\n");
             }
-            
+
             start = end;
             end = start + 1;
         }
@@ -1240,11 +1254,11 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
     // close the file
     fclose(fp);
 
-    string command = "gzip --force --best " + file.str();
+    string command = "gzip --force --best " + file.local8BitStr();
     int err = system(command.c_str());
     if (err)
     {
-        cout << "ERROR: gzip " << file.str() << " failed!" << endl;
+        cout << "ERROR: gzip " << file << " failed!" << endl;
     }
 
     return (err == 0);
@@ -1254,7 +1268,7 @@ void SGBinObject::read_properties(gzFile fp, int nproperties)
 {
     sgSimpleBuffer buf;
     uint32_t nbytes;
-    
+
     // read properties
     for ( int j = 0; j < nproperties; ++j ) {
         char prop_type;
@@ -1271,11 +1285,11 @@ bool SGBinObject::add_point( const SGBinObjectPoint& pt )
 {
     // add the point info
     pt_materials.push_back( pt.material );
-    
+
     pts_v.push_back( pt.v_list );
-    pts_n.push_back( pt.n_list );    
+    pts_n.push_back( pt.n_list );
     pts_c.push_back( pt.c_list );
-    
+
     return true;
 }
 
@@ -1288,6 +1302,6 @@ bool SGBinObject::add_triangle( const SGBinObjectTriangle& tri )
     tris_c.push_back( tri.c_list );
     tris_tcs.push_back( tri.tc_list );
     tris_vas.push_back( tri.va_list );
-    
+
     return true;
-}
+}

simgear/io/sg_binobj.hxx

@@ -268,7 +268,7 @@ public:
      * @param file input file name
      * @return result of read
      */
-    bool read_bin( const std::string& file );
+    bool read_bin( const SGPath& file );
 
     /** 
      * Write out the structures to a binary file.  We assume that the

simgear/io/sg_file.cxx

@@ -45,7 +45,7 @@
 #include "sg_file.hxx"
 
 
-SGFile::SGFile(const std::string &file, int repeat_, int extraoflags_ )
+SGFile::SGFile(const SGPath &file, int repeat_, int extraoflags_ )
     : file_name(file), fp(-1), eof_flag(true), repeat(repeat_), iteration(0),
       extraoflags(extraoflags_)
 {
@@ -69,24 +69,36 @@ SGFile::~SGFile() {
 bool SGFile::open( const SGProtocolDir d ) {
     set_dir( d );
 
+#if defined(SG_WINDOWS)
+    std::wstring n = file_name.wstr();
+#else
+    std::string n = file_name.utf8Str();
+#endif
+
+
     if ( get_dir() == SG_IO_OUT ) {
-#ifdef _WIN32
+#if defined(SG_WINDOWS)
         int mode = _S_IREAD | _S_IWRITE;
+        fp = ::_wopen(n.c_str(), O_WRONLY | O_CREAT | O_TRUNC | extraoflags, mode);
 #else
         mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+        fp = ::open( n.c_str(), O_WRONLY | O_CREAT | O_TRUNC | extraoflags, mode );
 #endif
-	fp = ::open( file_name.c_str(), O_WRONLY | O_CREAT | O_TRUNC | extraoflags, mode );
     } else if ( get_dir() == SG_IO_IN ) {
-	fp = ::open( file_name.c_str(), O_RDONLY | extraoflags );
+#if defined(SG_WINDOWS)
+        fp = ::_wopen( n.c_str(), O_RDONLY | extraoflags );
+#else
+        fp = ::open( n.c_str(), O_RDONLY | extraoflags );
+#endif
     } else {
-	SG_LOG( SG_IO, SG_ALERT, 
-		"Error:  bidirection mode not available for files." );
-	return false;
+        SG_LOG( SG_IO, SG_ALERT,
+            "Error:  bidirection mode not available for files." );
+        return false;
     }
 
     if ( fp == -1 ) {
-	SG_LOG( SG_IO, SG_ALERT, "Error opening file: "	<< file_name );
-	return false;
+        SG_LOG( SG_IO, SG_ALERT, "Error opening file: "	<< file_name );
+        return false;
     }
 
     eof_flag = false;
@@ -144,7 +156,7 @@ int SGFile::readline( char *buf, int length ) {
 	result = i;
     }
     lseek( fp, pos + result, SEEK_SET );
-    
+
     // just in case ...
     buf[ result ] = '\0';
 
@@ -180,7 +192,7 @@ bool SGFile::close() {
     return true;
 }
 
-SGBinaryFile::SGBinaryFile( const std::string& file, int repeat_ ) :
+SGBinaryFile::SGBinaryFile( const SGPath& file, int repeat_ ) :
 #ifdef _WIN32
     SGFile(file,repeat_, _O_BINARY)
 #else

simgear/io/sg_file.hxx

@@ -23,6 +23,9 @@
 #define _SG_FILE_HXX
 
 #include <simgear/compiler.h>
+
+#include <simgear/misc/sg_path.hxx>
+
 #include "iochannel.hxx"
 
 #include <string>
@@ -32,7 +35,7 @@
  */
 class SGFile : public SGIOChannel {
 
-    std::string file_name;
+    SGPath file_name;
     int fp;
     bool eof_flag;
     // Number of repetitions to play. -1 means loop infinitely.
@@ -51,7 +54,7 @@ public:
      * @param file name of file to open
      * @param repeat On eof restart at the beginning of the file
      */
-    SGFile( const std::string& file, int repeat_ = 1, int extraoflags = 0);
+    SGFile( const SGPath& file, int repeat_ = 1, int extraoflags = 0);
 
     /**
      * Create an SGFile from an existing, open file-descriptor
@@ -80,7 +83,7 @@ public:
     bool close();
 
     /** @return the name of the file being manipulated. */
-    inline std::string get_file_name() const { return file_name; }
+    std::string get_file_name() const { return file_name.utf8Str(); }
 
     /** @return true of eof conditions exists */
     virtual bool eof() const { return eof_flag; };
@@ -88,7 +91,7 @@ public:
 
 class SGBinaryFile : public SGFile {
 public:
-    SGBinaryFile( const std::string& file, int repeat_ = 1 );
+    SGBinaryFile( const SGPath& file, int repeat_ = 1 );
 };
 
 #endif // _SG_FILE_HXX

simgear/io/test_DNS.cxx

@@ -4,6 +4,8 @@
 #include <map>
 #include <sstream>
 #include <errno.h>
+#include <thread>
+#include <atomic>
 
 #include <boost/algorithm/string/case_conv.hpp>
 
@@ -16,6 +18,7 @@
 #include <simgear/debug/logstream.hxx>
 #include <simgear/misc/strutils.hxx>
 #include <simgear/timing/timestamp.hxx>
+#include <simgear/misc/test_macros.hxx>
 
 using std::cout;
 using std::cerr;
@@ -23,23 +26,80 @@ using std::endl;
 
 using namespace simgear;
 
-#define COMPARE(a, b) \
-    if ((a) != (b))  { \
-        cerr << "failed:" << #a << " != " << #b << endl; \
-        cerr << "\tgot:'" << a << "'" << endl; \
-        exit(1); \
+
+class Watchdog
+{
+public:
+    Watchdog() : _interval(0), _timer(0), _running(false) {}
+    ~Watchdog() {
+      stop();
     }
 
+    void start(unsigned int milliseconds)
+    {
+        _interval = milliseconds;
+        _timer = 0;
+        _running = true;
+        _thread = std::thread(&Watchdog::loop, this);
+    }
+
+    void stop()
+    {
+        _running = false;
+        _thread.join();
+    }
+
+private:
+    unsigned int _interval;
+    std::atomic<unsigned int> _timer;
+    std::atomic<bool> _running;
+    std::thread _thread;
+
+    void loop()
+    {
+        while (_running)
+        {
+            _timer++;
+
+            if (_timer >= _interval)
+            {
+                _running = false;
+                std::cerr << "Failure: timeout." << endl;
+                exit(EXIT_FAILURE);
+            }
+
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+    }
+};
+
 
 int main(int argc, char* argv[])
 {
     sglog().setLogLevels( SG_ALL, SG_DEBUG );
 
-    DNS::Client cl;
-#define EXISTING_RECORD "terrasync.flightgear.org"
+    Watchdog watchdog;
+    watchdog.start(100);
 
-    // test existing NAPTR
-    // fgtest.t3r.de.                600        IN        NAPTR        999 99 "U" "test" "!^.*$!http://dnstest.flightgear.org/!" .
+    simgear::Socket::initSockets();
+
+
+    DNS::Client cl;
+
+    cout << "test update without prior pending request" << endl;
+    {
+        cout << "polling.";
+        for( int i = 0; i < 20; i++ ) {
+            SGTimeStamp::sleepForMSec(200);
+            cl.update(0);
+            cout << ".";
+            cout.flush();
+        }
+        cout << "done" << endl;
+    }
+
+#define EXISTING_RECORD "terrasync.flightgear.org"
+    cout << "test existing NAPTR: " EXISTING_RECORD << endl;
     {
         DNS::NAPTRRequest * naptrRequest = new DNS::NAPTRRequest(EXISTING_RECORD);
         DNS::Request_ptr r(naptrRequest);
@@ -58,15 +118,15 @@ int main(int argc, char* argv[])
             return EXIT_FAILURE;
         }
 
-        // test for ascending preference/order
+        cout << "test for ascending preference/order" << endl;
         int order = -1, preference = -1;
         for( DNS::NAPTRRequest::NAPTR_list::const_iterator it = naptrRequest->entries.begin(); it != naptrRequest->entries.end(); ++it ) {
             // currently only support "U" which implies empty replacement
-            COMPARE((*it)->flags, "U" );
-            COMPARE(naptrRequest->entries[0]->replacement, "" );
+            SG_CHECK_EQUAL((*it)->flags, "U" );
+            SG_CHECK_EQUAL(naptrRequest->entries[0]->replacement, "" );
 
             // currently only support ws20
-            COMPARE((*it)->service, "ws20" );
+            SG_CHECK_EQUAL((*it)->service, "ws20" );
 
             if( (*it)->order < order ) {
                 cerr << "NAPTR entries not ascending for field 'order'" << endl;
@@ -95,7 +155,7 @@ int main(int argc, char* argv[])
         }
     }
 
-    // test non-existing NAPTR
+    cout << "test non-existing NAPTR" << endl;
     {
         DNS::NAPTRRequest * naptrRequest = new DNS::NAPTRRequest("jurkxkqdiufqzpfvzqok.prozhqrlcaavbxifkkhf");
         DNS::Request_ptr r(naptrRequest);
@@ -109,7 +169,7 @@ int main(int argc, char* argv[])
             cerr << "timeout testing non-existing record." << endl;
             return EXIT_FAILURE;
         }
-        COMPARE(naptrRequest->entries.size(), 0 );
+        SG_CHECK_EQUAL(naptrRequest->entries.size(), 0 );
     }
 
     cout << "all tests passed ok" << endl;

simgear/io/test_HTTP.cxx

@@ -3,7 +3,7 @@
 #include <iostream>
 #include <map>
 #include <sstream>
-#include <errno.h>
+#include <cerrno>
 
 #include <boost/algorithm/string/case_conv.hpp>
 
@@ -17,6 +17,7 @@
 #include <simgear/misc/strutils.hxx>
 #include <simgear/timing/timestamp.hxx>
 #include <simgear/debug/logstream.hxx>
+#include <simgear/misc/test_macros.hxx>
 
 #include <curl/multi.h>
 
@@ -41,18 +42,6 @@ const char* BODY3 = "Cras ut neque nulla. Duis ut velit neque, sit amet "
 const unsigned int body2Size = 8 * 1024;
 char body2[body2Size];
 
-#define COMPARE(a, b) \
-    if ((a) != (b))  { \
-        cerr << "failed:" << #a << " != " << #b << endl; \
-        cerr << "\tgot:'" << a << "'" << endl; \
-        exit(1); \
-    }
-
-#define VERIFY(a) \
-    if (!(a))  { \
-        cerr << "failed:" << #a << endl; \
-        exit(1); \
-    }
 
 class TestRequest : public HTTP::Request
 {
@@ -126,8 +115,9 @@ public:
             d << contentStr;
             push(d.str().c_str());
         } else if (path == "/test_headers") {
-            COMPARE(requestHeaders["X-Foo"], string("Bar"));
-            COMPARE(requestHeaders["X-AnotherHeader"], string("A longer value"));
+            SG_CHECK_EQUAL(requestHeaders["X-Foo"], string("Bar"));
+            SG_CHECK_EQUAL(requestHeaders["X-AnotherHeader"],
+                           string("A longer value"));
 
             string contentStr(BODY1);
             stringstream d;
@@ -304,7 +294,7 @@ public:
         } else if (path == "/test_put") {
           std::cerr << "sending PUT response" << std::endl;
 
-          COMPARE(buffer, BODY3);
+          SG_CHECK_EQUAL(buffer, BODY3);
           stringstream d;
           d << "HTTP/1.1 " << 204 << " " << reasonForCode(204) << "\r\n";
           d << "\r\n"; // final CRLF to terminate the headers
@@ -314,7 +304,7 @@ public:
 
           std::string entityStr = "http://localhost:2000/something.txt";
 
-          COMPARE(buffer, BODY3);
+          SG_CHECK_EQUAL(buffer, BODY3);
           stringstream d;
           d << "HTTP/1.1 " << 201 << " " << reasonForCode(201) << "\r\n";
           d << "Location:" << entityStr << "\r\n";
@@ -385,18 +375,18 @@ int main(int argc, char* argv[])
 
 // test URL parsing
     TestRequest* tr1 = new TestRequest("http://localhost.woo.zar:2000/test1?foo=bar");
-    COMPARE(tr1->scheme(), "http");
-    COMPARE(tr1->hostAndPort(), "localhost.woo.zar:2000");
-    COMPARE(tr1->host(), "localhost.woo.zar");
-    COMPARE(tr1->port(), 2000);
-    COMPARE(tr1->path(), "/test1");
+    SG_CHECK_EQUAL(tr1->scheme(), "http");
+    SG_CHECK_EQUAL(tr1->hostAndPort(), "localhost.woo.zar:2000");
+    SG_CHECK_EQUAL(tr1->host(), "localhost.woo.zar");
+    SG_CHECK_EQUAL(tr1->port(), 2000);
+    SG_CHECK_EQUAL(tr1->path(), "/test1");
 
     TestRequest* tr2 = new TestRequest("http://192.168.1.1/test1/dir/thing/file.png");
-    COMPARE(tr2->scheme(), "http");
-    COMPARE(tr2->hostAndPort(), "192.168.1.1");
-    COMPARE(tr2->host(), "192.168.1.1");
-    COMPARE(tr2->port(), 80);
-    COMPARE(tr2->path(), "/test1/dir/thing/file.png");
+    SG_CHECK_EQUAL(tr2->scheme(), "http");
+    SG_CHECK_EQUAL(tr2->hostAndPort(), "192.168.1.1");
+    SG_CHECK_EQUAL(tr2->host(), "192.168.1.1");
+    SG_CHECK_EQUAL(tr2->port(), 80);
+    SG_CHECK_EQUAL(tr2->path(), "/test1/dir/thing/file.png");
 
 // basic get request
     {
@@ -405,11 +395,11 @@ int main(int argc, char* argv[])
         cl.makeRequest(tr);
 
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseReason(), string("OK"));
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseReason(), string("OK"));
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
     }
 
     {
@@ -418,11 +408,11 @@ int main(int argc, char* argv[])
       cl.makeRequest(tr);
 
       waitForComplete(&cl, tr);
-      COMPARE(tr->responseCode(), 200);
-      COMPARE(tr->responseReason(), string("OK"));
-      COMPARE(tr->responseLength(), strlen(BODY3));
-      COMPARE(tr->responseBytesReceived(), strlen(BODY3));
-      COMPARE(tr->bodyData, string(BODY3));
+      SG_CHECK_EQUAL(tr->responseCode(), 200);
+      SG_CHECK_EQUAL(tr->responseReason(), string("OK"));
+      SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY3));
+      SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY3));
+      SG_CHECK_EQUAL(tr->bodyData, string(BODY3));
     }
 
     {
@@ -430,7 +420,7 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
     }
 
     {
@@ -441,11 +431,11 @@ int main(int argc, char* argv[])
         cl.makeRequest(tr);
 
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseReason(), string("OK"));
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseReason(), string("OK"));
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
     }
 
 // larger get request
@@ -458,9 +448,9 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseBytesReceived(), body2Size);
-        COMPARE(tr->bodyData, string(body2, body2Size));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), body2Size);
+        SG_CHECK_EQUAL(tr->bodyData, string(body2, body2Size));
     }
 
     cerr << "testing chunked transfer encoding" << endl;
@@ -470,12 +460,12 @@ int main(int argc, char* argv[])
         cl.makeRequest(tr);
 
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseReason(), string("OK"));
-        COMPARE(tr->responseBytesReceived(), 30);
-        COMPARE(tr->bodyData, "ABCDEFGHABCDEFABCDSTUVABCDSTUV");
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseReason(), string("OK"));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), 30);
+        SG_CHECK_EQUAL(tr->bodyData, "ABCDEFGHABCDEFABCDSTUVABCDSTUV");
     // check trailers made it too
-        COMPARE(tr->headers["x-foobar"], string("wibble"));
+        SG_CHECK_EQUAL(tr->headers["x-foobar"], string("wibble"));
     }
 
 // test 404
@@ -484,9 +474,9 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 404);
-        COMPARE(tr->responseReason(), string("not found"));
-        COMPARE(tr->responseLength(), 0);
+        SG_CHECK_EQUAL(tr->responseCode(), 404);
+        SG_CHECK_EQUAL(tr->responseReason(), string("not found"));
+        SG_CHECK_EQUAL(tr->responseLength(), 0);
     }
 
     cout << "done 404 test" << endl;
@@ -496,7 +486,7 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
     }
 
     cout << "done1" << endl;
@@ -506,9 +496,9 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
     }
 
     cout << "done2" << endl;
@@ -518,9 +508,9 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
     }
     cout << "done3" << endl;
 // test connectToHost failure
@@ -534,7 +524,7 @@ int main(int argc, char* argv[])
 
 
         const int HOST_NOT_FOUND_CODE = CURLE_COULDNT_RESOLVE_HOST;
-        COMPARE(tr->responseCode(), HOST_NOT_FOUND_CODE);
+        SG_CHECK_EQUAL(tr->responseCode(), HOST_NOT_FOUND_CODE);
     }
 
   cout << "testing abrupt close" << endl;
@@ -546,7 +536,7 @@ int main(int argc, char* argv[])
         waitForFailed(&cl, tr);
 
         const int SERVER_NO_DATA_CODE = CURLE_GOT_NOTHING;
-        COMPARE(tr->responseCode(), SERVER_NO_DATA_CODE);
+        SG_CHECK_EQUAL(tr->responseCode(), SERVER_NO_DATA_CODE);
     }
 
 cout << "testing proxy close" << endl;
@@ -557,9 +547,9 @@ cout << "testing proxy close" << endl;
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseLength(), body2Size);
-        COMPARE(tr->bodyData, string(body2, body2Size));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseLength(), body2Size);
+        SG_CHECK_EQUAL(tr->bodyData, string(body2, body2Size));
     }
 
     {
@@ -568,16 +558,16 @@ cout << "testing proxy close" << endl;
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseBytesReceived(), body2Size);
-        COMPARE(tr->bodyData, string(body2, body2Size));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), body2Size);
+        SG_CHECK_EQUAL(tr->bodyData, string(body2, body2Size));
     }
 
 // pipelining
     cout << "testing HTTP 1.1 pipelining" << endl;
 
     {
-        testServer.resetConnectCount();
+        testServer.disconnectAll();
         cl.clearAllConnections();
 
         cl.setProxy("", 80);
@@ -595,17 +585,17 @@ cout << "testing proxy close" << endl;
         cl.makeRequest(tr3);
 
         waitForComplete(&cl, tr3);
-        VERIFY(tr->complete);
-        VERIFY(tr2->complete);
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_VERIFY(tr->complete);
+        SG_VERIFY(tr2->complete);
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
 
-        COMPARE(tr2->responseLength(), strlen(BODY3));
-        COMPARE(tr2->responseBytesReceived(), strlen(BODY3));
-        COMPARE(tr2->bodyData, string(BODY3));
+        SG_CHECK_EQUAL(tr2->responseLength(), strlen(BODY3));
+        SG_CHECK_EQUAL(tr2->responseBytesReceived(), strlen(BODY3));
+        SG_CHECK_EQUAL(tr2->bodyData, string(BODY3));
 
-        COMPARE(tr3->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr3->bodyData, string(BODY1));
 
-        COMPARE(testServer.connectCount(), 1);
+        SG_CHECK_EQUAL(testServer.connectCount(), 1);
     }
 
 // multiple requests with an HTTP 1.0 server
@@ -626,17 +616,17 @@ cout << "testing proxy close" << endl;
         cl.makeRequest(tr3);
 
         waitForComplete(&cl, tr3);
-        VERIFY(tr->complete);
-        VERIFY(tr2->complete);
+        SG_VERIFY(tr->complete);
+        SG_VERIFY(tr2->complete);
 
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
 
-        COMPARE(tr2->responseLength(), strlen(BODY3));
-        COMPARE(tr2->responseBytesReceived(), strlen(BODY3));
-        COMPARE(tr2->bodyData, string(BODY3));
-        COMPARE(tr3->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr2->responseLength(), strlen(BODY3));
+        SG_CHECK_EQUAL(tr2->responseBytesReceived(), strlen(BODY3));
+        SG_CHECK_EQUAL(tr2->bodyData, string(BODY3));
+        SG_CHECK_EQUAL(tr3->bodyData, string(BODY1));
     }
 
 // POST
@@ -648,7 +638,7 @@ cout << "testing proxy close" << endl;
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 204);
+        SG_CHECK_EQUAL(tr->responseCode(), 204);
     }
 
     // PUT
@@ -660,7 +650,7 @@ cout << "testing proxy close" << endl;
             HTTP::Request_ptr own(tr);
             cl.makeRequest(tr);
             waitForComplete(&cl, tr);
-            COMPARE(tr->responseCode(), 204);
+            SG_CHECK_EQUAL(tr->responseCode(), 204);
         }
 
         {
@@ -671,7 +661,7 @@ cout << "testing proxy close" << endl;
             HTTP::Request_ptr own(tr);
             cl.makeRequest(tr);
             waitForComplete(&cl, tr);
-            COMPARE(tr->responseCode(), 201);
+            SG_CHECK_EQUAL(tr->responseCode(), 201);
         }
 
     // test_zero_length_content
@@ -681,15 +671,15 @@ cout << "testing proxy close" << endl;
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->bodyData, string());
-        COMPARE(tr->responseBytesReceived(), 0);
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->bodyData, string());
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), 0);
     }
 
     // test cancel
     {
         cout <<  "cancel  request" << endl;
-        testServer.resetConnectCount();
+        testServer.disconnectAll();
         cl.clearAllConnections();
 
         cl.setProxy("", 80);
@@ -711,18 +701,18 @@ cout << "testing proxy close" << endl;
 
         waitForComplete(&cl, tr3);
 
-        COMPARE(tr->responseCode(), -1);
-        COMPARE(tr2->responseReason(), "my reason 2");
+        SG_CHECK_EQUAL(tr->responseCode(), -1);
+        SG_CHECK_EQUAL(tr2->responseReason(), "my reason 2");
 
-        COMPARE(tr3->responseLength(), strlen(BODY1));
-        COMPARE(tr3->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr3->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr3->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr3->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr3->bodyData, string(BODY1));
     }
 
     // test cancel
     {
         cout <<  "cancel middle request" << endl;
-        testServer.resetConnectCount();
+        testServer.disconnectAll();
         cl.clearAllConnections();
 
         cl.setProxy("", 80);
@@ -742,16 +732,16 @@ cout << "testing proxy close" << endl;
 
         waitForComplete(&cl, tr3);
 
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
 
-        COMPARE(tr2->responseCode(), -1);
+        SG_CHECK_EQUAL(tr2->responseCode(), -1);
 
-        COMPARE(tr3->responseLength(), strlen(BODY1));
-        COMPARE(tr3->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr3->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr3->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr3->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr3->bodyData, string(BODY1));
     }
 
     {
@@ -776,12 +766,12 @@ cout << "testing proxy close" << endl;
         cl.makeRequest(tr2);
 
         waitForComplete(&cl, tr2);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->bodyData, string(BODY3));
-        COMPARE(tr->responseBytesReceived(), strlen(BODY3));
-        COMPARE(tr2->responseCode(), 200);
-        COMPARE(tr2->bodyData, string(BODY1));
-        COMPARE(tr2->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY3));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY3));
+        SG_CHECK_EQUAL(tr2->responseCode(), 200);
+        SG_CHECK_EQUAL(tr2->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr2->responseBytesReceived(), strlen(BODY1));
     }
 
     cout << "all tests passed ok" << endl;

simgear/io/test_HTTP.hxx

@@ -2,6 +2,7 @@
 #define SIMGEAR_IO_TEST_HTTP_HXX
 
 #include <sstream>
+#include <vector>
 
 #include <simgear/io/sg_netChat.hxx>
 #include <simgear/misc/strutils.hxx>
@@ -27,6 +28,11 @@ public:
 
     }
 
+    virtual ~TestServerChannel()
+    {
+        std::cerr << "dtor test server channel" << std::endl;
+    }
+
     virtual void collectIncomingData(const char* s, int n)
     {
         buffer += std::string(s, n);
@@ -160,6 +166,13 @@ public:
         }
     }
 
+    virtual void handleClose (void)
+    {
+        std::cerr << "channel close" << std::endl;
+        NetBufferChannel::handleClose();
+    }
+
+
     State state;
     std::string buffer;
     std::string method;
@@ -170,17 +183,25 @@ public:
     int requestContentLength;
 };
 
+class EraseIfClosed
+{
+public:
+    bool operator()(simgear::NetChannel* chan) const
+    {
+        return chan->isClosed();
+    }
+};
+
 template <class T>
 class TestServer : public NetChannel
 {
     simgear::NetChannelPoller _poller;
-    int _connectCount;
+    std::vector<T*> _channels;
 public:
     TestServer()
     {
         Socket::initSockets();
 
-        _connectCount = 0;
 
         open();
         bind(NULL, 2000); // localhost, any port
@@ -199,27 +220,42 @@ public:
     {
         simgear::IPAddress addr ;
         int handle = accept ( &addr ) ;
-        TestServerChannel* chan = new T();
+        T* chan = new T();
         chan->setHandle(handle);
 
+        _channels.push_back(chan);
         _poller.addChannel(chan);
-
-        _connectCount++;
     }
 
     void poll()
     {
         _poller.poll();
-    }
 
-    void resetConnectCount()
-    {
-        _connectCount = 0;
+        typename std::vector<T*>::iterator it;
+        it = std::remove_if(_channels.begin(), _channels.end(), EraseIfClosed());
+
+        for (typename std::vector<T*>::iterator it2 = it; it2 != _channels.end(); ++it2) {
+            delete *it2;
+        }
+
+        _channels.erase(it, _channels.end());
+
     }
 
     int connectCount()
     {
-        return _connectCount;
+        return _channels.size();
+    }
+
+    void disconnectAll()
+    {
+        typename std::vector<T*>::iterator it;
+        for (it = _channels.begin(); it != _channels.end(); ++it) {
+            _poller.removeChannel(*it);
+            delete *it;
+        }
+
+        _channels.clear();
     }
 };
 

simgear/io/test_binobj.cxx

@@ -14,6 +14,7 @@
 #endif
 
 #include <simgear/misc/sg_dir.hxx>
+#include <simgear/misc/test_macros.hxx>
 
 #include "sg_binobj.hxx"
 
@@ -22,19 +23,7 @@ using std::cerr;
 using std::endl;
 using std::string;
 
-#define COMPARE(a, b) \
-    if ((a) != (b))  { \
-        cerr << "failed:" << #a << " != " << #b << endl; \
-        cerr << "\tgot:" << a << endl; \
-        exit(1); \
-    }
 
-#define VERIFY(a) \
-    if (!(a))  { \
-        cerr << "failed:" << #a << endl; \
-        exit(1); \
-    }
-    
 void generate_points(int count, std::vector<SGVec3d>& vec)
 {
     for (int i=0; i<count; ++i) {
@@ -61,15 +50,15 @@ void test_empty()
     SGBinObject empty;
     SGPath path(simgear::Dir::current().file("empty.btg.gz"));
     bool ok = empty.write_bin_file(path);
-    VERIFY( ok );
+    SG_VERIFY(ok);
     SGBinObject rd;
-   ok = rd.read_bin(path.str()) ;
-   VERIFY( ok);
+    ok = rd.read_bin(path) ;
+    SG_VERIFY(ok);
+
+    SG_CHECK_EQUAL(rd.get_wgs84_nodes().size(), 0);
+    SG_VERIFY(rd.get_pt_materials().empty());
+}
 
-   COMPARE(rd.get_wgs84_nodes().size(), 0);
-   VERIFY(rd.get_pt_materials().empty());
-}   
- 
 void comparePoints(const SGBinObject& rd, const std::vector<SGVec3d>& b)
 {
     for (unsigned int i=1; i<b.size(); i += 10) {
@@ -82,7 +71,7 @@ void comparePoints(const SGBinObject& rd, const std::vector<SGVec3d>& b)
             cout << pos << endl;
         }
         
-        VERIFY(equivalent(pos, b[i], 0.1));        
+        SG_VERIFY(equivalent(pos, b[i], 0.1));        
     }
 }
 
@@ -90,7 +79,7 @@ void compareTexCoords(const SGBinObject& rd, const std::vector<SGVec2f>& b)
 {
     for (unsigned int i=1; i<b.size(); i += 10) {
         SGVec2f pos = rd.get_texcoords()[i];
-        VERIFY(equivalent(pos, b[i], 0.001f));        
+        SG_VERIFY(equivalent(pos, b[i], 0.001f));        
     }
 }
 
@@ -137,13 +126,13 @@ void compareTris(const SGBinObject& a, const SGBinObject& b)
     for (unsigned int i=0; i<count; i += 39) {
         const int_list& vA(a.get_tris_v()[i]);
         const int_list& vB(b.get_tris_v()[i]);
-        VERIFY(vA == vB);
+        SG_VERIFY(vA == vB);
+
+        SG_CHECK_EQUAL(a.get_tri_materials()[i], b.get_tri_materials()[i]);
 
-        COMPARE(a.get_tri_materials()[i], b.get_tri_materials()[i]);
-        
         const int_list& tA(a.get_tris_tcs()[i][0]);
         const int_list& tB(b.get_tris_tcs()[i][0]);
-        VERIFY(tA == tB);
+        SG_VERIFY(tA == tB);
     }
 }
 
@@ -189,16 +178,17 @@ void test_basic()
     basic.set_texcoords(texCoords);
     
     bool ok = basic.write_bin_file(path);
-    VERIFY( ok );
+    SG_VERIFY( ok );
     
     SGBinObject rd;
-   ok = rd.read_bin(path.str()) ;
-   VERIFY( ok);
-   COMPARE(rd.get_version(), 7); // should be version 7 since indices are < 2^16
-   COMPARE(rd.get_gbs_center(), center);
-   COMPARE(rd.get_gbs_radius(), 12345);
-   COMPARE(rd.get_wgs84_nodes().size(), points.size());
-   
+   ok = rd.read_bin(path) ;
+   SG_VERIFY( ok);
+   // Should be version 7 since indices are < 2^16
+   SG_CHECK_EQUAL(rd.get_version(), 7);
+   SG_CHECK_EQUAL(rd.get_gbs_center(), center);
+   SG_CHECK_EQUAL(rd.get_gbs_radius(), 12345);
+   SG_CHECK_EQUAL(rd.get_wgs84_nodes().size(), points.size());
+
    comparePoints(rd, points);
    compareTexCoords(rd, texCoords);
 }
@@ -226,15 +216,16 @@ void test_many_tcs()
     generate_tris(basic, 20000);
     
     bool ok = basic.write_bin_file(path);
-    VERIFY( ok );
+    SG_VERIFY( ok );
     
     SGBinObject rd;
-   ok = rd.read_bin(path.str()) ;
-   VERIFY( ok);
-   COMPARE(rd.get_version(), 10); // should be version 10 since indices are > 2^16
-   COMPARE(rd.get_wgs84_nodes().size(), points.size());
-   COMPARE(rd.get_texcoords().size(), texCoords.size());
-   
+   ok = rd.read_bin(path) ;
+   SG_VERIFY( ok);
+   // Should be version 10 since indices are > 2^16
+   SG_CHECK_EQUAL(rd.get_version(), 10);
+   SG_CHECK_EQUAL(rd.get_wgs84_nodes().size(), points.size());
+   SG_CHECK_EQUAL(rd.get_texcoords().size(), texCoords.size());
+
    comparePoints(rd, points);
    compareTexCoords(rd, texCoords);
    compareTris(basic, rd);
@@ -263,15 +254,16 @@ void test_big()
     generate_tris(basic, 200000);
     
     bool ok = basic.write_bin_file(path);
-    VERIFY( ok );
+    SG_VERIFY( ok );
     
     SGBinObject rd;
-   ok = rd.read_bin(path.str()) ;
-   VERIFY( ok);
-   COMPARE(rd.get_version(), 10); // should be version 10 since indices are > 2^16
-   COMPARE(rd.get_wgs84_nodes().size(), points.size());
-   COMPARE(rd.get_texcoords().size(), texCoords.size());
-   
+   ok = rd.read_bin(path) ;
+   SG_VERIFY( ok);
+   // Should be version 10 since indices are > 2^16
+   SG_CHECK_EQUAL(rd.get_version(), 10);
+   SG_CHECK_EQUAL(rd.get_wgs84_nodes().size(), points.size());
+   SG_CHECK_EQUAL(rd.get_texcoords().size(), texCoords.size());
+
    comparePoints(rd, points);
    compareTexCoords(rd, texCoords);
    compareTris(basic, rd);
@@ -300,15 +292,15 @@ void test_some_objects()
     generate_tris(basic, 30000); // a number smaller than 2^15!
     
     bool ok = basic.write_bin_file(path);
-    VERIFY( ok );
+    SG_VERIFY( ok );
     
     SGBinObject rd;
-    ok = rd.read_bin(path.str()) ;
-    VERIFY( ok);
-    COMPARE(rd.get_version(), 7); // since we have less than 2^15 tris
-    COMPARE(rd.get_wgs84_nodes().size(), points.size());
-    COMPARE(rd.get_texcoords().size(), texCoords.size());
-   
+    ok = rd.read_bin(path) ;
+    SG_VERIFY( ok);
+    SG_CHECK_EQUAL(rd.get_version(), 7); // since we have less than 2^15 tris
+    SG_CHECK_EQUAL(rd.get_wgs84_nodes().size(), points.size());
+    SG_CHECK_EQUAL(rd.get_texcoords().size(), texCoords.size());
+
     comparePoints(rd, points);
     compareTexCoords(rd, texCoords);
     compareTris(basic, rd);
@@ -337,15 +329,16 @@ void test_many_objects()
     generate_tris(basic, 200000);
     
     bool ok = basic.write_bin_file(path);
-    VERIFY( ok );
+    SG_VERIFY( ok );
     
     SGBinObject rd;
-    ok = rd.read_bin(path.str()) ;
-    VERIFY( ok);
-    COMPARE(rd.get_version(), 10); // should be version 10 since indices are > 2^16
-    COMPARE(rd.get_wgs84_nodes().size(), points.size());
-    COMPARE(rd.get_texcoords().size(), texCoords.size());
-   
+    ok = rd.read_bin(path) ;
+    SG_VERIFY( ok);
+    // Should be version 10 since indices are > 2^16
+    SG_CHECK_EQUAL(rd.get_version(), 10);
+    SG_CHECK_EQUAL(rd.get_wgs84_nodes().size(), points.size());
+    SG_CHECK_EQUAL(rd.get_texcoords().size(), texCoords.size());
+
     comparePoints(rd, points);
     compareTexCoords(rd, texCoords);
     compareTris(basic, rd);

simgear/io/test_repository.cxx

@@ -18,7 +18,10 @@
 #include <simgear/timing/timestamp.hxx>
 #include <simgear/debug/logstream.hxx>
 #include <simgear/misc/sg_dir.hxx>
+#include <simgear/io/iostreams/sgstream.hxx>
 #include <simgear/structure/exception.hxx>
+#include <simgear/structure/callback.hxx>
+
 #include <simgear/io/sg_file.hxx>
 
 using namespace simgear;
@@ -68,9 +71,12 @@ public:
     int requestCount;
     bool getWillFail;
     bool returnCorruptData;
+    std::unique_ptr<SGCallback> accessCallback;
 
     void clearRequestCounts();
 
+    void clearFailFlags();
+
     void setGetWillFail(bool b)
     {
         getWillFail = b;
@@ -113,7 +119,7 @@ public:
         if (path.empty()) {
             return this;
         }
-        
+
         string_list pathParts = strutils::split(path, "/");
         TestRepoEntry* entry = childEntry(pathParts.front());
         if (pathParts.size() == 1) {
@@ -213,6 +219,18 @@ void TestRepoEntry::clearRequestCounts()
     }
 }
 
+void TestRepoEntry::clearFailFlags()
+{
+    getWillFail = false;
+    returnCorruptData = false;
+
+    if (isDir) {
+        for (size_t i=0; i<children.size(); ++i) {
+            children[i]->clearFailFlags();
+        }
+    }
+}
+
 TestRepoEntry* global_repo = NULL;
 
 class TestRepositoryChannel : public TestServerChannel
@@ -238,6 +256,10 @@ public:
                 repoPath = repoPath.substr(0, suffix);
             }
 
+            if (repoPath.find("/") == 0) { // trim leading /
+                repoPath = repoPath.substr(1);
+            }
+
             TestRepoEntry* entry = global_repo->findEntry(repoPath);
             if (!entry) {
                 sendErrorResponse(404, false, "unknown repo path:" + repoPath);
@@ -249,6 +271,10 @@ public:
                 return;
             }
 
+            if (entry->accessCallback.get()) {
+                (*entry->accessCallback)();
+            }
+
             if (entry->getWillFail) {
                 sendErrorResponse(404, false, "entry marked to fail explicitly:" + repoPath);
                 return;
@@ -286,7 +312,7 @@ std::string test_computeHashForPath(const SGPath& p)
     char* buf = static_cast<char*>(alloca(1024 * 1024));
     size_t readLen;
 
-    SGBinaryFile f(p.str());
+    SGBinaryFile f(p);
     f.open(SG_IO_IN);
 
     while ((readLen = f.read(buf, 1024 * 1024)) > 0) {
@@ -316,6 +342,15 @@ void verifyFileState(const SGPath& fsRoot, const std::string& relPath)
     }
 }
 
+void verifyFileNotPresent(const SGPath& fsRoot, const std::string& relPath)
+{
+    SGPath p(fsRoot);
+    p.append(relPath);
+    if (p.exists()) {
+        throw sg_error("Present file system entry", relPath);
+    }
+}
+
 void verifyRequestCount(const std::string& relPath, int count)
 {
     TestRepoEntry* entry = global_repo->findEntry(relPath);
@@ -340,7 +375,7 @@ void createFile(const SGPath& basePath, const std::string& relPath, int revision
 
     std::string prName = comps.at(comps.size() - 2);
     {
-        std::ofstream f(p.c_str(), std::ios::trunc | std::ios::out);
+        sg_ofstream f(p, std::ios::trunc | std::ios::out);
         f << dataForFile(prName, comps.back(), revision);
     }
 }
@@ -350,7 +385,7 @@ TestServer<TestRepositoryChannel> testServer;
 void waitForUpdateComplete(HTTP::Client* cl, HTTPRepository* repo)
 {
     SGTimeStamp start(SGTimeStamp::now());
-    while (start.elapsedMSec() <  10000) {
+    while (start.elapsedMSec() <  20000) {
         cl->update();
         testServer.poll();
 
@@ -365,12 +400,12 @@ void waitForUpdateComplete(HTTP::Client* cl, HTTPRepository* repo)
 
 void testBasicClone(HTTP::Client* cl)
 {
-    std::auto_ptr<HTTPRepository> repo;
+    std::unique_ptr<HTTPRepository> repo;
     SGPath p(simgear::Dir::current().path());
     p.append("http_repo_basic");
     simgear::Dir pd(p);
     pd.removeChildren();
-    
+
     repo.reset(new HTTPRepository(p, cl));
     repo->setBaseUrl("http://localhost:2000/repo");
     repo->update();
@@ -400,7 +435,7 @@ void testBasicClone(HTTP::Client* cl)
 
 void testModifyLocalFiles(HTTP::Client* cl)
 {
-    std::auto_ptr<HTTPRepository> repo;
+    std::unique_ptr<HTTPRepository> repo;
     SGPath p(simgear::Dir::current().path());
     p.append("http_repo_modify_local_2");
     simgear::Dir pd(p);
@@ -418,7 +453,7 @@ void testModifyLocalFiles(HTTP::Client* cl)
     SGPath modFile(p);
     modFile.append("dirB/subdirA/fileBAA");
     {
-        std::ofstream of(modFile.c_str(), std::ios::out | std::ios::trunc);
+        sg_ofstream of(modFile, std::ios::out | std::ios::trunc);
         of << "complete nonsense";
         of.close();
     }
@@ -441,7 +476,7 @@ void testNoChangesUpdate()
 
 void testMergeExistingFileWithoutDownload(HTTP::Client* cl)
 {
-    std::auto_ptr<HTTPRepository> repo;
+    std::unique_ptr<HTTPRepository> repo;
     SGPath p(simgear::Dir::current().path());
     p.append("http_repo_merge_existing");
     simgear::Dir pd(p);
@@ -483,7 +518,7 @@ void testMergeExistingFileWithoutDownload(HTTP::Client* cl)
 
 void testLossOfLocalFiles(HTTP::Client* cl)
 {
-    std::auto_ptr<HTTPRepository> repo;
+    std::unique_ptr<HTTPRepository> repo;
     SGPath p(simgear::Dir::current().path());
     p.append("http_repo_lose_local");
     simgear::Dir pd(p);
@@ -517,7 +552,7 @@ void testLossOfLocalFiles(HTTP::Client* cl)
 
 void testAbandonMissingFiles(HTTP::Client* cl)
 {
-    std::auto_ptr<HTTPRepository> repo;
+    std::unique_ptr<HTTPRepository> repo;
     SGPath p(simgear::Dir::current().path());
     p.append("http_repo_missing_files");
     simgear::Dir pd(p);
@@ -532,7 +567,7 @@ void testAbandonMissingFiles(HTTP::Client* cl)
     repo->setBaseUrl("http://localhost:2000/repo");
     repo->update();
     waitForUpdateComplete(cl, repo.get());
-    if (repo->failure() != AbstractRepository::REPO_PARTIAL_UPDATE) {
+    if (repo->failure() != HTTPRepository::REPO_PARTIAL_UPDATE) {
         throw sg_exception("Bad result from missing files test");
     }
 
@@ -541,7 +576,7 @@ void testAbandonMissingFiles(HTTP::Client* cl)
 
 void testAbandonCorruptFiles(HTTP::Client* cl)
 {
-    std::auto_ptr<HTTPRepository> repo;
+    std::unique_ptr<HTTPRepository> repo;
     SGPath p(simgear::Dir::current().path());
     p.append("http_repo_corrupt_files");
     simgear::Dir pd(p);
@@ -556,13 +591,143 @@ void testAbandonCorruptFiles(HTTP::Client* cl)
     repo->setBaseUrl("http://localhost:2000/repo");
     repo->update();
     waitForUpdateComplete(cl, repo.get());
-    if (repo->failure() != AbstractRepository::REPO_PARTIAL_UPDATE) {
+    if (repo->failure() != HTTPRepository::REPO_ERROR_CHECKSUM) {
+        std::cerr << "Got failure state:" << repo->failure() << std::endl;
         throw sg_exception("Bad result from corrupt files test");
     }
 
+    repo.reset();
+    if (cl->hasActiveRequests()) {
+        cl->debugDumpRequests();
+        throw sg_exception("Connection still has requests active");
+    }
+
     std::cout << "Passed test: detect corrupted download" << std::endl;
 }
 
+void modifyBTree()
+{
+    std::cout << "Modifying sub-tree" << std::endl;
+
+    global_repo->findEntry("dirB/subdirA/fileBAC")->revision++;
+    global_repo->defineFile("dirB/subdirZ/fileBZA");
+    global_repo->findEntry("dirB/subdirB/fileBBB")->revision++;
+}
+
+void testServerModifyDuringSync(HTTP::Client* cl)
+{
+    std::unique_ptr<HTTPRepository> repo;
+    SGPath p(simgear::Dir::current().path());
+    p.append("http_repo_server_modify_during_sync");
+    simgear::Dir pd(p);
+    if (pd.exists()) {
+        pd.removeChildren();
+    }
+
+    global_repo->clearRequestCounts();
+    global_repo->clearFailFlags();
+
+    repo.reset(new HTTPRepository(p, cl));
+    repo->setBaseUrl("http://localhost:2000/repo");
+
+    global_repo->findEntry("dirA/fileAA")->accessCallback.reset(make_callback(&modifyBTree));
+
+    repo->update();
+    waitForUpdateComplete(cl, repo.get());
+
+    global_repo->findEntry("dirA/fileAA")->accessCallback.reset();
+
+    if (repo->failure() != HTTPRepository::REPO_ERROR_CHECKSUM) {
+        throw sg_exception("Bad result from modify during sync test");
+    }
+
+    std::cout << "Passed test modify server during sync" << std::endl;
+
+}
+
+void testDestroyDuringSync(HTTP::Client* cl)
+{
+    std::unique_ptr<HTTPRepository> repo;
+    SGPath p(simgear::Dir::current().path());
+    p.append("http_repo_destory_during_sync");
+    simgear::Dir pd(p);
+    if (pd.exists()) {
+        pd.removeChildren();
+    }
+
+    global_repo->clearRequestCounts();
+    global_repo->clearFailFlags();
+
+    repo.reset(new HTTPRepository(p, cl));
+    repo->setBaseUrl("http://localhost:2000/repo");
+
+    repo->update();
+
+    // would ideally spin slightly here
+
+    repo.reset();
+
+    if (cl->hasActiveRequests()) {
+        throw sg_exception("destory of repo didn't clean up requests");
+    }
+
+    std::cout << "Passed test destory during sync" << std::endl;
+}
+
+void testCopyInstalledChildren(HTTP::Client* cl)
+{
+    std::unique_ptr<HTTPRepository> repo;
+    SGPath p(simgear::Dir::current().path());
+    p.append("http_repo_copy_installed_children");
+    simgear::Dir pd(p);
+    if (pd.exists()) {
+        pd.removeChildren();
+    }
+
+    // setup installation data
+    SGPath p2(simgear::Dir::current().path());
+    p2.append("http_repo_copy_installed_children_install");
+    simgear::Dir pd2(p2);
+    if (pd2.exists()) {
+        pd2.removeChildren();
+    } else {
+        pd2.create(0700);
+    }
+
+    // fill in 'install' tree data
+    createFile(p, "dirJ/fileJA", 2);
+    createFile(p, "dirJ/fileJB", 3);
+    createFile(p, "dirJ/fileJC", 1);
+
+    global_repo->defineFile("dirJ/fileJA", 2);
+    global_repo->defineFile("dirJ/fileJB", 3);
+    global_repo->defineFile("dirJ/fileJC", 3); // newer
+    global_repo->defineFile("dirJ/fileJD", 3); // not present in install
+
+    global_repo->clearRequestCounts();
+    global_repo->clearFailFlags();
+
+    repo.reset(new HTTPRepository(p, cl));
+    repo->setBaseUrl("http://localhost:2000/repo");
+    repo->setInstalledCopyPath(p2);
+    repo->update();
+
+    // verify correct files were downloaded, only dirs
+
+    waitForUpdateComplete(cl, repo.get());
+    verifyFileState(p, "dirJ/fileJA");
+    verifyFileState(p, "dirJ/fileJB");
+    verifyFileState(p, "dirJ/fileJC");
+    verifyFileState(p, "dirJ/fileJD");
+
+    verifyRequestCount("dirJ/fileJA", 0);
+    verifyRequestCount("dirJ/fileJB", 0);
+    verifyRequestCount("dirJ/fileJC", 1);
+    verifyRequestCount("dirJ/fileJD", 1);
+
+    std::cout << "Copy installed children" << std::endl;
+}
+
 int main(int argc, char* argv[])
 {
   sglog().setLogLevels( SG_ALL, SG_INFO );
@@ -581,6 +746,8 @@ int main(int argc, char* argv[])
     global_repo->defineFile("dirB/subdirA/fileBAA");
     global_repo->defineFile("dirB/subdirA/fileBAB");
     global_repo->defineFile("dirB/subdirA/fileBAC");
+    global_repo->defineFile("dirB/subdirB/fileBBA");
+    global_repo->defineFile("dirB/subdirB/fileBBB");
     global_repo->defineFile("dirC/subdirA/subsubA/fileCAAA");
 
     testBasicClone(&cl);
@@ -595,5 +762,17 @@ int main(int argc, char* argv[])
 
     testAbandonCorruptFiles(&cl);
 
+    testServer.disconnectAll();
+    cl.clearAllConnections();
+
+    testServerModifyDuringSync(&cl);
+    testDestroyDuringSync(&cl);
+
+    testServer.disconnectAll();
+    cl.clearAllConnections();
+
+    testCopyInstalledChildren(&cl);
+
+    std::cout << "all tests passed ok" << std::endl;
     return 0;
 }

simgear/io/test_untar.cxx

@@ -0,0 +1,58 @@
+////////////////////////////////////////////////////////////////////////
+// Test harness.
+////////////////////////////////////////////////////////////////////////
+
+#include <simgear/compiler.h>
+
+#include <iostream>
+
+#include "untar.hxx"
+
+#include <simgear/misc/test_macros.hxx>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/io/sg_file.hxx>
+
+
+using std::cout;
+using std::cerr;
+using std::endl;
+
+using namespace simgear;
+
+void testTarGz()
+{
+    SGPath p = SGPath(SRC_DIR);
+    p.append("test.tar.gz");
+
+    SGBinaryFile f(p);
+    f.open(SG_IO_IN);
+
+    uint8_t* buf = (uint8_t*) alloca(8192);
+    size_t bufSize = f.read((char*) buf, 8192);
+
+    SG_VERIFY(TarExtractor::isTarData(buf, bufSize));
+
+}
+
+void testPlainTar()
+{
+    SGPath p = SGPath(SRC_DIR);
+    p.append("test2.tar");
+
+    SGBinaryFile f(p);
+    f.open(SG_IO_IN);
+
+    uint8_t* buf = (uint8_t*) alloca(8192);
+    size_t bufSize = f.read((char*) buf, 8192);
+
+    SG_VERIFY(TarExtractor::isTarData(buf, bufSize));
+
+}
+
+int main (int ac, char ** av)
+{
+    testTarGz();
+    testPlainTar();
+
+	return 0;
+}

simgear/io/text_DNS.cxx

@@ -17,6 +17,7 @@
 #include <simgear/misc/strutils.hxx>
 #include <simgear/timing/timestamp.hxx>
 #include <simgear/debug/logstream.hxx>
+#include <simgear/misc/test_macros.hxx>
 
 #include <curl/multi.h>
 
@@ -41,18 +42,6 @@ const char* BODY3 = "Cras ut neque nulla. Duis ut velit neque, sit amet "
 const unsigned int body2Size = 8 * 1024;
 char body2[body2Size];
 
-#define COMPARE(a, b) \
-    if ((a) != (b))  { \
-        cerr << "failed:" << #a << " != " << #b << endl; \
-        cerr << "\tgot:'" << a << "'" << endl; \
-        exit(1); \
-    }
-
-#define VERIFY(a) \
-    if (!(a))  { \
-        cerr << "failed:" << #a << endl; \
-        exit(1); \
-    }
 
 class TestRequest : public HTTP::Request
 {
@@ -126,8 +115,9 @@ public:
             d << contentStr;
             push(d.str().c_str());
         } else if (path == "/test_headers") {
-            COMPARE(requestHeaders["X-Foo"], string("Bar"));
-            COMPARE(requestHeaders["X-AnotherHeader"], string("A longer value"));
+            SG_CHECK_EQUAL(requestHeaders["X-Foo"], string("Bar"));
+            SG_CHECK_EQUAL(requestHeaders["X-AnotherHeader"],
+                           string("A longer value"));
 
             string contentStr(BODY1);
             stringstream d;
@@ -304,7 +294,7 @@ public:
         } else if (path == "/test_put") {
           std::cerr << "sending PUT response" << std::endl;
 
-          COMPARE(buffer, BODY3);
+          SG_CHECK_EQUAL(buffer, BODY3);
           stringstream d;
           d << "HTTP/1.1 " << 204 << " " << reasonForCode(204) << "\r\n";
           d << "\r\n"; // final CRLF to terminate the headers
@@ -314,7 +304,7 @@ public:
 
           std::string entityStr = "http://localhost:2000/something.txt";
 
-          COMPARE(buffer, BODY3);
+          SG_CHECK_EQUAL(buffer, BODY3);
           stringstream d;
           d << "HTTP/1.1 " << 201 << " " << reasonForCode(201) << "\r\n";
           d << "Location:" << entityStr << "\r\n";
@@ -385,18 +375,18 @@ int main(int argc, char* argv[])
 
 // test URL parsing
     TestRequest* tr1 = new TestRequest("http://localhost.woo.zar:2000/test1?foo=bar");
-    COMPARE(tr1->scheme(), "http");
-    COMPARE(tr1->hostAndPort(), "localhost.woo.zar:2000");
-    COMPARE(tr1->host(), "localhost.woo.zar");
-    COMPARE(tr1->port(), 2000);
-    COMPARE(tr1->path(), "/test1");
+    SG_CHECK_EQUAL(tr1->scheme(), "http");
+    SG_CHECK_EQUAL(tr1->hostAndPort(), "localhost.woo.zar:2000");
+    SG_CHECK_EQUAL(tr1->host(), "localhost.woo.zar");
+    SG_CHECK_EQUAL(tr1->port(), 2000);
+    SG_CHECK_EQUAL(tr1->path(), "/test1");
 
     TestRequest* tr2 = new TestRequest("http://192.168.1.1/test1/dir/thing/file.png");
-    COMPARE(tr2->scheme(), "http");
-    COMPARE(tr2->hostAndPort(), "192.168.1.1");
-    COMPARE(tr2->host(), "192.168.1.1");
-    COMPARE(tr2->port(), 80);
-    COMPARE(tr2->path(), "/test1/dir/thing/file.png");
+    SG_CHECK_EQUAL(tr2->scheme(), "http");
+    SG_CHECK_EQUAL(tr2->hostAndPort(), "192.168.1.1");
+    SG_CHECK_EQUAL(tr2->host(), "192.168.1.1");
+    SG_CHECK_EQUAL(tr2->port(), 80);
+    SG_CHECK_EQUAL(tr2->path(), "/test1/dir/thing/file.png");
 
 // basic get request
     {
@@ -405,11 +395,11 @@ int main(int argc, char* argv[])
         cl.makeRequest(tr);
 
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseReason(), string("OK"));
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseReason(), string("OK"));
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
     }
 
     {
@@ -418,11 +408,11 @@ int main(int argc, char* argv[])
       cl.makeRequest(tr);
 
       waitForComplete(&cl, tr);
-      COMPARE(tr->responseCode(), 200);
-      COMPARE(tr->responseReason(), string("OK"));
-      COMPARE(tr->responseLength(), strlen(BODY3));
-      COMPARE(tr->responseBytesReceived(), strlen(BODY3));
-      COMPARE(tr->bodyData, string(BODY3));
+      SG_CHECK_EQUAL(tr->responseCode(), 200);
+      SG_CHECK_EQUAL(tr->responseReason(), string("OK"));
+      SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY3));
+      SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY3));
+      SG_CHECK_EQUAL(tr->bodyData, string(BODY3));
     }
 
     {
@@ -430,7 +420,7 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
     }
 
     {
@@ -441,11 +431,11 @@ int main(int argc, char* argv[])
         cl.makeRequest(tr);
 
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseReason(), string("OK"));
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseReason(), string("OK"));
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
     }
 
 // larger get request
@@ -458,9 +448,9 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseBytesReceived(), body2Size);
-        COMPARE(tr->bodyData, string(body2, body2Size));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), body2Size);
+        SG_CHECK_EQUAL(tr->bodyData, string(body2, body2Size));
     }
 
     cerr << "testing chunked transfer encoding" << endl;
@@ -470,12 +460,12 @@ int main(int argc, char* argv[])
         cl.makeRequest(tr);
 
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseReason(), string("OK"));
-        COMPARE(tr->responseBytesReceived(), 30);
-        COMPARE(tr->bodyData, "ABCDEFGHABCDEFABCDSTUVABCDSTUV");
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseReason(), string("OK"));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), 30);
+        SG_CHECK_EQUAL(tr->bodyData, "ABCDEFGHABCDEFABCDSTUVABCDSTUV");
     // check trailers made it too
-        COMPARE(tr->headers["x-foobar"], string("wibble"));
+        SG_CHECK_EQUAL(tr->headers["x-foobar"], string("wibble"));
     }
 
 // test 404
@@ -484,9 +474,9 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 404);
-        COMPARE(tr->responseReason(), string("not found"));
-        COMPARE(tr->responseLength(), 0);
+        SG_CHECK_EQUAL(tr->responseCode(), 404);
+        SG_CHECK_EQUAL(tr->responseReason(), string("not found"));
+        SG_CHECK_EQUAL(tr->responseLength(), 0);
     }
 
     cout << "done 404 test" << endl;
@@ -496,7 +486,7 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
     }
 
     cout << "done1" << endl;
@@ -506,9 +496,9 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
     }
 
     cout << "done2" << endl;
@@ -518,9 +508,9 @@ int main(int argc, char* argv[])
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
     }
     cout << "done3" << endl;
 // test connectToHost failure
@@ -532,7 +522,7 @@ int main(int argc, char* argv[])
         waitForFailed(&cl, tr);
 
         const int HOST_NOT_FOUND_CODE = CURLE_COULDNT_RESOLVE_HOST;
-        COMPARE(tr->responseCode(), HOST_NOT_FOUND_CODE);
+        SG_CHECK_EQUAL(tr->responseCode(), HOST_NOT_FOUND_CODE);
     }
 
   cout << "testing abrupt close" << endl;
@@ -544,7 +534,7 @@ int main(int argc, char* argv[])
         waitForFailed(&cl, tr);
 
         const int SERVER_NO_DATA_CODE = CURLE_GOT_NOTHING;
-        COMPARE(tr->responseCode(), SERVER_NO_DATA_CODE);
+        SG_CHECK_EQUAL(tr->responseCode(), SERVER_NO_DATA_CODE);
     }
 
 cout << "testing proxy close" << endl;
@@ -555,9 +545,9 @@ cout << "testing proxy close" << endl;
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseLength(), body2Size);
-        COMPARE(tr->bodyData, string(body2, body2Size));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseLength(), body2Size);
+        SG_CHECK_EQUAL(tr->bodyData, string(body2, body2Size));
     }
 
     {
@@ -566,9 +556,9 @@ cout << "testing proxy close" << endl;
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseBytesReceived(), body2Size);
-        COMPARE(tr->bodyData, string(body2, body2Size));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), body2Size);
+        SG_CHECK_EQUAL(tr->bodyData, string(body2, body2Size));
     }
 
 // pipelining
@@ -593,17 +583,17 @@ cout << "testing proxy close" << endl;
         cl.makeRequest(tr3);
 
         waitForComplete(&cl, tr3);
-        VERIFY(tr->complete);
-        VERIFY(tr2->complete);
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_VERIFY(tr->complete);
+        SG_VERIFY(tr2->complete);
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
 
-        COMPARE(tr2->responseLength(), strlen(BODY3));
-        COMPARE(tr2->responseBytesReceived(), strlen(BODY3));
-        COMPARE(tr2->bodyData, string(BODY3));
+        SG_CHECK_EQUAL(tr2->responseLength(), strlen(BODY3));
+        SG_CHECK_EQUAL(tr2->responseBytesReceived(), strlen(BODY3));
+        SG_CHECK_EQUAL(tr2->bodyData, string(BODY3));
 
-        COMPARE(tr3->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr3->bodyData, string(BODY1));
 
-        COMPARE(testServer.connectCount(), 1);
+        SG_CHECK_EQUAL(testServer.connectCount(), 1);
     }
 
 // multiple requests with an HTTP 1.0 server
@@ -624,17 +614,17 @@ cout << "testing proxy close" << endl;
         cl.makeRequest(tr3);
 
         waitForComplete(&cl, tr3);
-        VERIFY(tr->complete);
-        VERIFY(tr2->complete);
+        SG_VERIFY(tr->complete);
+        SG_VERIFY(tr2->complete);
 
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
 
-        COMPARE(tr2->responseLength(), strlen(BODY3));
-        COMPARE(tr2->responseBytesReceived(), strlen(BODY3));
-        COMPARE(tr2->bodyData, string(BODY3));
-        COMPARE(tr3->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr2->responseLength(), strlen(BODY3));
+        SG_CHECK_EQUAL(tr2->responseBytesReceived(), strlen(BODY3));
+        SG_CHECK_EQUAL(tr2->bodyData, string(BODY3));
+        SG_CHECK_EQUAL(tr3->bodyData, string(BODY1));
     }
 
 // POST
@@ -646,7 +636,7 @@ cout << "testing proxy close" << endl;
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 204);
+        SG_CHECK_EQUAL(tr->responseCode(), 204);
     }
 
     // PUT
@@ -658,7 +648,7 @@ cout << "testing proxy close" << endl;
             HTTP::Request_ptr own(tr);
             cl.makeRequest(tr);
             waitForComplete(&cl, tr);
-            COMPARE(tr->responseCode(), 204);
+            SG_CHECK_EQUAL(tr->responseCode(), 204);
         }
 
         {
@@ -669,7 +659,7 @@ cout << "testing proxy close" << endl;
             HTTP::Request_ptr own(tr);
             cl.makeRequest(tr);
             waitForComplete(&cl, tr);
-            COMPARE(tr->responseCode(), 201);
+            SG_CHECK_EQUAL(tr->responseCode(), 201);
         }
 
     // test_zero_length_content
@@ -679,9 +669,9 @@ cout << "testing proxy close" << endl;
         HTTP::Request_ptr own(tr);
         cl.makeRequest(tr);
         waitForComplete(&cl, tr);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->bodyData, string());
-        COMPARE(tr->responseBytesReceived(), 0);
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->bodyData, string());
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), 0);
     }
 
     // test cancel
@@ -709,12 +699,12 @@ cout << "testing proxy close" << endl;
 
         waitForComplete(&cl, tr3);
 
-        COMPARE(tr->responseCode(), -1);
-        COMPARE(tr2->responseReason(), "my reason 2");
+        SG_CHECK_EQUAL(tr->responseCode(), -1);
+        SG_CHECK_EQUAL(tr2->responseReason(), "my reason 2");
 
-        COMPARE(tr3->responseLength(), strlen(BODY1));
-        COMPARE(tr3->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr3->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr3->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr3->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr3->bodyData, string(BODY1));
     }
 
     // test cancel
@@ -740,16 +730,16 @@ cout << "testing proxy close" << endl;
 
         waitForComplete(&cl, tr3);
 
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->responseLength(), strlen(BODY1));
-        COMPARE(tr->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
 
-        COMPARE(tr2->responseCode(), -1);
+        SG_CHECK_EQUAL(tr2->responseCode(), -1);
 
-        COMPARE(tr3->responseLength(), strlen(BODY1));
-        COMPARE(tr3->responseBytesReceived(), strlen(BODY1));
-        COMPARE(tr3->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr3->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr3->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr3->bodyData, string(BODY1));
     }
 
     {
@@ -774,12 +764,12 @@ cout << "testing proxy close" << endl;
         cl.makeRequest(tr2);
 
         waitForComplete(&cl, tr2);
-        COMPARE(tr->responseCode(), 200);
-        COMPARE(tr->bodyData, string(BODY3));
-        COMPARE(tr->responseBytesReceived(), strlen(BODY3));
-        COMPARE(tr2->responseCode(), 200);
-        COMPARE(tr2->bodyData, string(BODY1));
-        COMPARE(tr2->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY3));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY3));
+        SG_CHECK_EQUAL(tr2->responseCode(), 200);
+        SG_CHECK_EQUAL(tr2->bodyData, string(BODY1));
+        SG_CHECK_EQUAL(tr2->responseBytesReceived(), strlen(BODY1));
     }
 
     cout << "all tests passed ok" << endl;

simgear/io/untar.cxx

@@ -0,0 +1,418 @@
+// Copyright (C) 2016  James Turner - <zakalawe@mac.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "untar.hxx"
+
+#include <cstdlib>
+#include <cassert>
+#include <stdint.h>
+#include <cstring>
+#include <cstddef>
+#include <algorithm>
+
+#include <zlib.h>
+
+#include <simgear/io/sg_file.hxx>
+#include <simgear/misc/sg_dir.hxx>
+
+#include <simgear/debug/logstream.hxx>
+
+namespace simgear
+{
+
+const int ZLIB_DECOMPRESS_BUFFER_SIZE = 32 * 1024;
+const int ZLIB_INFLATE_WINDOW_BITS = MAX_WBITS;
+const int ZLIB_DECODE_GZIP_HEADER = 16;
+
+/* tar Header Block, from POSIX 1003.1-1990.  */
+
+typedef struct
+{
+    char fileName[100];
+    char mode[8];                 /* 100 */
+    char uid[8];                  /* 108 */
+    char gid[8];                  /* 116 */
+    char size[12];                /* 124 */
+    char mtime[12];               /* 136 */
+    char chksum[8];               /* 148 */
+    char typeflag;                /* 156 */
+    char linkname[100];           /* 157 */
+    char magic[6];                /* 257 */
+    char version[2];              /* 263 */
+    char uname[32];               /* 265 */
+    char gname[32];               /* 297 */
+    char devmajor[8];             /* 329 */
+    char devminor[8];             /* 337 */
+    char prefix[155];             /* 345 */
+} UstarHeaderBlock;
+
+    const size_t TAR_HEADER_BLOCK_SIZE = 512;
+
+#define TMAGIC   "ustar"        /* ustar and a null */
+#define TMAGLEN  5              // 5, not 6, becuase some files use 'ustar '
+#define TVERSION "00"           /* 00 and no null */
+#define TVERSLEN 2
+
+    /* Values used in typeflag field.  */
+#define REGTYPE  '0'            /* regular file */
+#define AREGTYPE '\0'           /* regular file */
+#define LNKTYPE  '1'            /* link */
+#define SYMTYPE  '2'            /* reserved */
+#define CHRTYPE  '3'            /* character special */
+#define BLKTYPE  '4'            /* block special */
+#define DIRTYPE  '5'            /* directory */
+#define FIFOTYPE '6'            /* FIFO special */
+#define CONTTYPE '7'            /* reserved */
+
+class TarExtractorPrivate
+{
+public:
+    typedef enum {
+        INVALID = 0,
+        READING_HEADER,
+        READING_FILE,
+        READING_PADDING,
+        PRE_END_OF_ARCHVE,
+        END_OF_ARCHIVE,
+        ERROR_STATE, ///< states above this are error conditions
+        BAD_ARCHIVE,
+        BAD_DATA
+    } State;
+
+    SGPath path;
+    State state;
+    union {
+        UstarHeaderBlock header;
+        uint8_t headerBytes[TAR_HEADER_BLOCK_SIZE];
+    };
+
+    size_t bytesRemaining;
+    std::unique_ptr<SGFile> currentFile;
+    size_t currentFileSize;
+    z_stream zlibStream;
+    uint8_t* zlibOutput;
+    bool haveInitedZLib;
+    bool uncompressedData; // set if reading a plain .tar (not tar.gz)
+    uint8_t* headerPtr;
+
+    TarExtractorPrivate() :
+        haveInitedZLib(false),
+        uncompressedData(false)
+    {
+    }
+
+    ~TarExtractorPrivate()
+    {
+        free(zlibOutput);
+    }
+
+    void checkEndOfState()
+    {
+        if (bytesRemaining > 0) {
+            return;
+        }
+
+        if (state == READING_FILE) {
+            currentFile->close();
+            size_t pad = currentFileSize % TAR_HEADER_BLOCK_SIZE;
+            if (pad) {
+                bytesRemaining = TAR_HEADER_BLOCK_SIZE - pad;
+                setState(READING_PADDING);
+            } else {
+                setState(READING_HEADER);
+            }
+        } else if (state == READING_HEADER) {
+            processHeader();
+        } else if (state == PRE_END_OF_ARCHVE) {
+            if (headerIsAllZeros()) {
+                setState(END_OF_ARCHIVE);
+            } else {
+                // what does the spec say here?
+            }
+        } else if (state == READING_PADDING) {
+            setState(READING_HEADER);
+        }
+    }
+
+    void setState(State newState)
+    {
+        if ((newState == READING_HEADER) || (newState == PRE_END_OF_ARCHVE)) {
+            bytesRemaining = TAR_HEADER_BLOCK_SIZE;
+            headerPtr = headerBytes;
+        }
+
+        state = newState;
+    }
+
+    void processHeader()
+    {
+        if (headerIsAllZeros()) {
+            if (state == PRE_END_OF_ARCHVE) {
+                setState(END_OF_ARCHIVE);
+            } else {
+                setState(PRE_END_OF_ARCHVE);
+            }
+            return;
+        }
+
+        if (strncmp(header.magic, TMAGIC, TMAGLEN) != 0) {
+            SG_LOG(SG_IO, SG_WARN, "magic is wrong");
+            state = BAD_ARCHIVE;
+            return;
+        }
+
+        std::string tarPath = std::string(header.prefix) + std::string(header.fileName);
+
+        if (!isSafePath(tarPath)) {
+            //state = BAD_ARCHIVE;
+            SG_LOG(SG_IO, SG_WARN, "bad tar path:" << tarPath);
+            //return;
+        }
+
+        SGPath p = path;
+        p.append(tarPath);
+
+        if (header.typeflag == DIRTYPE) {
+            Dir dir(p);
+            dir.create(0755);
+            setState(READING_HEADER);
+        } else if ((header.typeflag == REGTYPE) || (header.typeflag == AREGTYPE)) {
+            currentFileSize = ::strtol(header.size, NULL, 8);
+            bytesRemaining = currentFileSize;
+            currentFile.reset(new SGBinaryFile(p));
+            currentFile->open(SG_IO_OUT);
+            setState(READING_FILE);
+        } else {
+            SG_LOG(SG_IO, SG_WARN, "Unsupported tar file type:" << header.typeflag);
+            state = BAD_ARCHIVE;
+        }
+    }
+
+    void processBytes(const char* bytes, size_t count)
+    {
+        if ((state >= ERROR_STATE) || (state == END_OF_ARCHIVE)) {
+            return;
+        }
+
+        size_t curBytes = std::min(bytesRemaining, count);
+        if (state == READING_FILE) {
+            currentFile->write(bytes, curBytes);
+            bytesRemaining -= curBytes;
+        } else if ((state == READING_HEADER) || (state == PRE_END_OF_ARCHVE) || (state == END_OF_ARCHIVE)) {
+            memcpy(headerPtr, bytes, curBytes);
+            bytesRemaining -= curBytes;
+            headerPtr += curBytes;
+        } else if (state == READING_PADDING) {
+            bytesRemaining -= curBytes;
+        }
+
+        checkEndOfState();
+        if (count > curBytes) {
+            // recurse with unprocessed bytes
+            processBytes(bytes + curBytes, count - curBytes);
+        }
+    }
+
+    bool headerIsAllZeros() const
+    {
+        char* headerAsChar = (char*) &header;
+        for (size_t i=0; i < offsetof(UstarHeaderBlock, magic); ++i) {
+            if (*headerAsChar++ != 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    bool isSafePath(const std::string& p) const
+    {
+        if (p.empty()) {
+            return false;
+        }
+
+        // reject absolute paths
+        if (p.at(0) == '/') {
+            return false;
+        }
+
+        // reject paths containing '..'
+        size_t doubleDot = p.find("..");
+        if (doubleDot != std::string::npos) {
+            return false;
+        }
+
+        // on POSIX could use realpath to sanity check
+        return true;
+    }
+};
+
+TarExtractor::TarExtractor(const SGPath& rootPath) :
+    d(new TarExtractorPrivate)
+{
+
+    d->path = rootPath;
+    d->state = TarExtractorPrivate::INVALID;
+
+    memset(&d->zlibStream, 0, sizeof(z_stream));
+    d->zlibOutput = (unsigned char*) malloc(ZLIB_DECOMPRESS_BUFFER_SIZE);
+    d->zlibStream.zalloc = Z_NULL;
+    d->zlibStream.zfree = Z_NULL;
+
+    d->zlibStream.avail_out = ZLIB_DECOMPRESS_BUFFER_SIZE;
+    d->zlibStream.next_out = d->zlibOutput;
+}
+
+TarExtractor::~TarExtractor()
+{
+
+}
+
+void TarExtractor::extractBytes(const char* bytes, size_t count)
+{
+    if (d->state >= TarExtractorPrivate::ERROR_STATE) {
+        return;
+    }
+
+    d->zlibStream.next_in = (uint8_t*) bytes;
+    d->zlibStream.avail_in = count;
+
+    if (!d->haveInitedZLib) {
+        // now we have data, see if we're dealing with GZ-compressed data or not
+        uint8_t* ubytes = (uint8_t*) bytes;
+        if ((ubytes[0] == 0x1f) && (ubytes[1] == 0x8b)) {
+            // GZIP identification bytes
+            if (inflateInit2(&d->zlibStream, ZLIB_INFLATE_WINDOW_BITS | ZLIB_DECODE_GZIP_HEADER) != Z_OK) {
+                SG_LOG(SG_IO, SG_WARN, "inflateInit2 failed");
+                d->state = TarExtractorPrivate::BAD_DATA;
+                return;
+            }
+        } else {
+            UstarHeaderBlock* header = (UstarHeaderBlock*) bytes;
+            if (strncmp(header->magic, TMAGIC, TMAGLEN) != 0) {
+                SG_LOG(SG_IO, SG_WARN, "didn't find tar magic in header");
+                d->state = TarExtractorPrivate::BAD_DATA;
+                return;
+            }
+
+            d->uncompressedData = true;
+        }
+
+        d->haveInitedZLib = true;
+        d->setState(TarExtractorPrivate::READING_HEADER);
+    } // of init on first-bytes case
+
+    if (d->uncompressedData) {
+        d->processBytes(bytes, count);
+    } else {
+        size_t writtenSize;
+        // loop, running zlib() inflate and sending output bytes to
+        // our request body handler. Keep calling inflate until no bytes are
+        // written, and ZLIB has consumed all available input
+        do {
+            d->zlibStream.next_out = d->zlibOutput;
+            d->zlibStream.avail_out = ZLIB_DECOMPRESS_BUFFER_SIZE;
+            int result = inflate(&d->zlibStream, Z_NO_FLUSH);
+            if (result == Z_OK || result == Z_STREAM_END) {
+                // nothing to do
+
+            } else if (result == Z_BUF_ERROR) {
+                // transient error, fall through
+            } else {
+                //  _error = result;
+                SG_LOG(SG_IO, SG_WARN, "Permanent ZLib error:" << d->zlibStream.msg);
+                d->state = TarExtractorPrivate::BAD_DATA;
+                return;
+            }
+
+            writtenSize = ZLIB_DECOMPRESS_BUFFER_SIZE - d->zlibStream.avail_out;
+            if (writtenSize > 0) {
+                d->processBytes((const char*) d->zlibOutput, writtenSize);
+            }
+
+            if (result == Z_STREAM_END) {
+                break;
+            }
+        } while ((d->zlibStream.avail_in > 0) || (writtenSize > 0));
+    } // of Zlib-compressed data
+}
+
+bool TarExtractor::isAtEndOfArchive() const
+{
+    return (d->state == TarExtractorPrivate::END_OF_ARCHIVE);
+}
+
+bool TarExtractor::hasError() const
+{
+    return (d->state >= TarExtractorPrivate::ERROR_STATE);
+}
+
+bool TarExtractor::isTarData(const uint8_t* bytes, size_t count)
+{
+    if (count < 2) {
+        return false;
+    }
+
+    UstarHeaderBlock* header = 0;
+    if ((bytes[0] == 0x1f) && (bytes[1] == 0x8b)) {
+        // GZIP identification bytes
+        z_stream z;
+        uint8_t* zlibOutput = static_cast<uint8_t*>(alloca(4096));
+        memset(&z, 0, sizeof(z_stream));
+        z.zalloc = Z_NULL;
+        z.zfree = Z_NULL;
+        z.avail_out = 4096;
+        z.next_out = zlibOutput;
+        z.next_in = (uint8_t*) bytes;
+        z.avail_in = count;
+
+        if (inflateInit2(&z, ZLIB_INFLATE_WINDOW_BITS | ZLIB_DECODE_GZIP_HEADER) != Z_OK) {
+            return false;
+        }
+
+        int result = inflate(&z, Z_SYNC_FLUSH);
+        if (result != Z_OK) {
+            SG_LOG(SG_IO, SG_WARN, "inflate failed:" << result);
+            return false; // not tar data
+        }
+
+        size_t written = 4096 - z.avail_out;
+        if (written < TAR_HEADER_BLOCK_SIZE) {
+            SG_LOG(SG_IO, SG_WARN, "insufficient data for header");
+            return false;
+        }
+        
+        header = reinterpret_cast<UstarHeaderBlock*>(zlibOutput);
+    } else {
+        // uncompressed tar
+        if (count < TAR_HEADER_BLOCK_SIZE) {
+            SG_LOG(SG_IO, SG_WARN, "insufficient data for header");
+            return false;
+        }
+
+        header = (UstarHeaderBlock*) bytes;
+    }
+
+    if (strncmp(header->magic, TMAGIC, TMAGLEN) != 0) {
+        SG_LOG(SG_IO, SG_WARN, "not a tar file");
+        return false;
+    }
+
+    return true;
+}
+
+} // of simgear

simgear/io/untar.hxx

@@ -0,0 +1,52 @@
+// Copyright (C) 2016  James Turner - <zakalawe@mac.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef SG_IO_UNTAR_HXX
+#define SG_IO_UNTAR_HXX
+
+#include <memory>
+
+#include <cstdlib>
+#include <stdint.h> // for uint8_t
+#include <simgear/misc/sg_path.hxx>
+
+namespace simgear
+{
+
+class TarExtractorPrivate;
+
+class TarExtractor
+{
+public:
+    TarExtractor(const SGPath& rootPath);
+	~TarExtractor();
+
+    static bool isTarData(const uint8_t* bytes, size_t count);
+
+    void extractBytes(const char* bytes, size_t count);
+
+    bool isAtEndOfArchive() const;
+
+    bool hasError() const;
+
+private:
+    std::unique_ptr<TarExtractorPrivate> d;
+};
+
+} // of namespace simgear
+
+#endif // of SG_IO_UNTAR_HXX

simgear/math/CMakeLists.txt

@@ -32,6 +32,8 @@ set(HEADERS
     sg_geodesy.hxx
     sg_types.hxx
     sg_random.h
+    simd.hxx
+    simd4x4.hxx
     )
 
 set(SOURCES 
@@ -45,6 +47,10 @@ simgear_component(math math "${SOURCES}" "${HEADERS}")
 
 if(ENABLE_TESTS)
 
+add_executable(sgvec4_test test_sgvec4.cxx)
+target_link_libraries(sgvec4_test ${TEST_LIBS})
+add_test(sgvec4 ${EXECUTABLE_OUTPUT_PATH}/sgvec4_test)
+
 add_executable(math_test SGMathTest.cxx)
 target_link_libraries(math_test ${TEST_LIBS})
 add_test(math ${EXECUTABLE_OUTPUT_PATH}/math_test)

simgear/math/SGGeod.hxx

@@ -19,6 +19,7 @@
 #define SGGeod_H
 
 #include <simgear/constants.h>
+#include <simgear/math/SGVec3.hxx>
 
 // #define SG_GEOD_NATIVE_DEGREE
 

simgear/math/SGMathTest.cxx

@@ -28,6 +28,9 @@
 #include "SGRect.hxx"
 #include "sg_random.h"
 
+int lineno = 0;
+
+
 template<typename T>
 bool
 Vec3Test(void)
@@ -38,45 +41,45 @@ Vec3Test(void)
   v1 = SGVec3<T>(1, 2, 3);
   v2 = SGVec3<T>(3, 2, 1);
   if (equivalent(v1, v2))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check the unary minus operator
   v3 = SGVec3<T>(-1, -2, -3);
   if (!equivalent(-v1, v3))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check the unary plus operator
   v3 = SGVec3<T>(1, 2, 3);
   if (!equivalent(+v1, v3))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check the addition operator
   v3 = SGVec3<T>(4, 4, 4);
   if (!equivalent(v1 + v2, v3))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check the subtraction operator
   v3 = SGVec3<T>(-2, 0, 2);
   if (!equivalent(v1 - v2, v3))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check the scaler multiplication operator
   v3 = SGVec3<T>(2, 4, 6);
   if (!equivalent(2*v1, v3))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check the dot product
   if (fabs(dot(v1, v2) - 10) > 10*SGLimits<T>::epsilon())
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check the cross product
   v3 = SGVec3<T>(-4, 8, -4);
   if (!equivalent(cross(v1, v2), v3))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check the euclidean length
   if (fabs(14 - length(v1)*length(v1)) > 14*SGLimits<T>::epsilon())
-    return false;
+    { lineno = __LINE__; return false; }
 
   return true;
 }
@@ -89,11 +92,11 @@ isSameRotation(const SGQuat<T>& q1, const SGQuat<T>& q2)
   const SGVec3<T> e2(0, 1, 0);
   const SGVec3<T> e3(0, 0, 1);
   if (!equivalent(q1.transform(e1), q2.transform(e1)))
-    return false;
+    { lineno = __LINE__; return false; }
   if (!equivalent(q1.transform(e2), q2.transform(e2)))
-    return false;
+    { lineno = __LINE__; return false; }
   if (!equivalent(q1.transform(e3), q2.transform(e3)))
-    return false;
+    { lineno = __LINE__; return false; }
   return true;
 }
 
@@ -111,37 +114,37 @@ QuatTest(void)
   v1 = SGVec3<T>(1, 2, 3);
   v2 = SGVec3<T>(1, -2, -3);
   if (!equivalent(q1.transform(v1), v2))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check a rotation around the x axis
   q1 = SGQuat<T>::fromAngleAxis(0.5*SGMisc<T>::pi(), e1);
   v2 = SGVec3<T>(1, 3, -2);
   if (!equivalent(q1.transform(v1), v2))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check a rotation around the y axis
   q1 = SGQuat<T>::fromAngleAxis(SGMisc<T>::pi(), e2);
   v2 = SGVec3<T>(-1, 2, -3);
   if (!equivalent(q1.transform(v1), v2))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check a rotation around the y axis
   q1 = SGQuat<T>::fromAngleAxis(0.5*SGMisc<T>::pi(), e2);
   v2 = SGVec3<T>(-3, 2, 1);
   if (!equivalent(q1.transform(v1), v2))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check a rotation around the z axis
   q1 = SGQuat<T>::fromAngleAxis(SGMisc<T>::pi(), e3);
   v2 = SGVec3<T>(-1, -2, 3);
   if (!equivalent(q1.transform(v1), v2))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check a rotation around the z axis
   q1 = SGQuat<T>::fromAngleAxis(0.5*SGMisc<T>::pi(), e3);
   v2 = SGVec3<T>(2, -1, 3);
   if (!equivalent(q1.transform(v1), v2))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Now check some successive transforms
   // We can reuse the prevously tested stuff
@@ -150,7 +153,7 @@ QuatTest(void)
   q3 = q1*q2;
   v2 = q2.transform(q1.transform(v1));
   if (!equivalent(q3.transform(v1), v2))
-    return false;
+    { lineno = __LINE__; return false; }
 
   /// Test from Euler angles
   float x = 0.2*SGMisc<T>::pi();
@@ -162,7 +165,7 @@ QuatTest(void)
   v2 = q3.transform(q2.transform(q1.transform(v1)));
   q4 = SGQuat<T>::fromEulerRad(z, y, x);
   if (!equivalent(q4.transform(v1), v2))
-    return false;
+    { lineno = __LINE__; return false; }
 
   /// Test angle axis forward and back transform
   q1 = SGQuat<T>::fromAngleAxis(0.2*SGMisc<T>::pi(), e1);
@@ -172,15 +175,15 @@ QuatTest(void)
   q1.getAngleAxis(angleAxis);
   q4 = SGQuat<T>::fromAngleAxis(angleAxis);
   if (!isSameRotation(q1, q4))
-    return false;
+    { lineno = __LINE__; return false; }
   q2.getAngleAxis(angleAxis);
   q4 = SGQuat<T>::fromAngleAxis(angleAxis);
   if (!isSameRotation(q2, q4))
-    return false;
+    { lineno = __LINE__; return false; }
   q3.getAngleAxis(angleAxis);
   q4 = SGQuat<T>::fromAngleAxis(angleAxis);
   if (!isSameRotation(q3, q4))
-    return false;
+    { lineno = __LINE__; return false; }
 
   /// Test angle axis forward and back transform
   q1 = SGQuat<T>::fromAngleAxis(0.2*SGMisc<T>::pi(), e1);
@@ -189,15 +192,15 @@ QuatTest(void)
   SGVec3<T> positiveAngleAxis = q1.getPositiveRealImag();
   q4 = SGQuat<T>::fromPositiveRealImag(positiveAngleAxis);
   if (!isSameRotation(q1, q4))
-    return false;
+    { lineno = __LINE__; return false; }
   positiveAngleAxis = q2.getPositiveRealImag();
   q4 = SGQuat<T>::fromPositiveRealImag(positiveAngleAxis);
   if (!isSameRotation(q2, q4))
-    return false;
+    { lineno = __LINE__; return false; }
   positiveAngleAxis = q3.getPositiveRealImag();
   q4 = SGQuat<T>::fromPositiveRealImag(positiveAngleAxis);
   if (!isSameRotation(q3, q4))
-    return false;
+    { lineno = __LINE__; return false; }
 
   return true;
 }
@@ -219,13 +222,13 @@ QuatDerivativeTest(void)
     // Check if we can restore the angular velocity
     SGVec3<T> av2 = SGQuat<T>::forwardDifferenceVelocity(o0, o1, dt);
     if (!equivalent(av, av2))
-      return false;
+      { lineno = __LINE__; return false; }
 
     // Test with the equivalent orientation
     o1 = -o1;
     av2 = SGQuat<T>::forwardDifferenceVelocity(o0, o1, dt);
     if (!equivalent(av, av2))
-      return false;
+      { lineno = __LINE__; return false; }
   }
   return true;
 }
@@ -250,23 +253,23 @@ MatrixTest(void)
   invert(m2, m0);
   m3 = transNeg(m0);
   if (!equivalent(m1, m2))
-    return false;
+    { lineno = __LINE__; return false; }
   if (!equivalent(m2, m3))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Check matrix multiplication and inversion
   if (!equivalent(m0*m1, SGMatrix<T>::unit()))
-    return false;
+    { lineno = __LINE__; return false; }
   if (!equivalent(m1*m0, SGMatrix<T>::unit()))
-    return false;
+    { lineno = __LINE__; return false; }
   if (!equivalent(m0*m2, SGMatrix<T>::unit()))
-    return false;
+    { lineno = __LINE__; return false; }
   if (!equivalent(m2*m0, SGMatrix<T>::unit()))
-    return false;
+    { lineno = __LINE__; return false; }
   if (!equivalent(m0*m3, SGMatrix<T>::unit()))
-    return false;
+    { lineno = __LINE__; return false; }
   if (!equivalent(m3*m0, SGMatrix<T>::unit()))
-    return false;
+    { lineno = __LINE__; return false; }
 
   return true;
 }
@@ -276,26 +279,26 @@ void doRectTest()
 {
   SGRect<T> rect(10, 15, 20, 25);
 
-  COMPARE(rect.x(), 10)
-  COMPARE(rect.y(), 15)
-  COMPARE(rect.width(), 20)
-  COMPARE(rect.height(), 25)
+  SG_CHECK_EQUAL(rect.x(), 10)
+  SG_CHECK_EQUAL(rect.y(), 15)
+  SG_CHECK_EQUAL(rect.width(), 20)
+  SG_CHECK_EQUAL(rect.height(), 25)
 
-  COMPARE(rect.pos(), SGVec2<T>(10, 15))
-  COMPARE(rect.size(), SGVec2<T>(20, 25))
+  SG_CHECK_EQUAL(rect.pos(), SGVec2<T>(10, 15))
+  SG_CHECK_EQUAL(rect.size(), SGVec2<T>(20, 25))
 
-  COMPARE(rect.l(), 10)
-  COMPARE(rect.t(), 15)
-  COMPARE(rect.r(), 30)
-  COMPARE(rect.b(), 40)
+  SG_CHECK_EQUAL(rect.l(), 10)
+  SG_CHECK_EQUAL(rect.t(), 15)
+  SG_CHECK_EQUAL(rect.r(), 30)
+  SG_CHECK_EQUAL(rect.b(), 40)
 
-  VERIFY(rect == rect)
-  VERIFY(rect == SGRect<T>(10, 15, 20, 25))
-  VERIFY(rect != SGRect<T>(11, 15, 20, 25))
+  SG_VERIFY(rect == rect)
+  SG_VERIFY(rect == SGRect<T>(10, 15, 20, 25))
+  SG_VERIFY(rect != SGRect<T>(11, 15, 20, 25))
 
-  VERIFY(rect.contains(10, 15))
-  VERIFY(!rect.contains(9, 15))
-  VERIFY(rect.contains(9, 15, 1))
+  SG_VERIFY(rect.contains(10, 15))
+  SG_VERIFY(!rect.contains(9, 15))
+  SG_VERIFY(rect.contains(9, 15, 1))
 }
 
 bool
@@ -320,13 +323,13 @@ GeodesyTest(void)
   if (epsDeg < fabs(geod0.getLongitudeDeg() - geod1.getLongitudeDeg()) ||
       epsDeg < fabs(geod0.getLatitudeDeg() - geod1.getLatitudeDeg()) ||
       epsM < fabs(geod0.getElevationM() - geod1.getElevationM()))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // Test the conversion routines to radial coordinates
   geoc0 = SGGeoc::fromCart(cart0);
   cart1 = SGVec3<double>::fromGeoc(geoc0);
   if (!equivalent(cart0, cart1))
-    return false;
+    { lineno = __LINE__; return false; }
 
   // test course / advance routines
   // uses examples from Williams aviation formulary
@@ -336,12 +339,12 @@ GeodesyTest(void)
   double distNm = SGGeodesy::distanceRad(lax, jfk) * SG_RAD_TO_NM;
   std::cout << "distance is " << distNm << std::endl;
   if (0.5 < fabs(distNm - 2144)) // 2144 nm
-	return false;
+	{ lineno = __LINE__; return false; }
 
   double crsDeg = SGGeodesy::courseRad(lax, jfk) * SG_RADIANS_TO_DEGREES;
   std::cout << "course is " << crsDeg << std::endl;
   if (0.5 < fabs(crsDeg - 66)) // 66 degrees
-	return false;
+	{ lineno = __LINE__; return false; }
 
   SGGeoc adv;
   SGGeodesy::advanceRadM(lax, crsDeg * SG_DEGREES_TO_RADIANS, 100 * SG_NM_TO_METER, adv);
@@ -349,7 +352,7 @@ GeodesyTest(void)
 
   if (0.01 < fabs(adv.getLongitudeRad() - (-2.034206)) ||
 	  0.01 < fabs(adv.getLatitudeRad() - 0.604180))
-	return false;
+	{ lineno = __LINE__; return false; }
 
   return true;
 }
@@ -361,25 +364,25 @@ main(void)
 
   // Do vector tests
   if (!Vec3Test<float>())
-    return EXIT_FAILURE;
+    { fprintf(stderr, "Error at line: %i called from line: %i\n", lineno, __LINE__); return EXIT_FAILURE; }
   if (!Vec3Test<double>())
-    return EXIT_FAILURE;
+    { fprintf(stderr, "Error at line: %i called from line: %i\n", lineno, __LINE__); return EXIT_FAILURE; }
 
   // Do quaternion tests
   if (!QuatTest<float>())
-    return EXIT_FAILURE;
+    { fprintf(stderr, "Error at line: %i called from line: %i\n", lineno, __LINE__); return EXIT_FAILURE; }
   if (!QuatTest<double>())
-    return EXIT_FAILURE;
+    { fprintf(stderr, "Error at line: %i called from line: %i\n", lineno, __LINE__); return EXIT_FAILURE; }
   if (!QuatDerivativeTest<float>())
-    return EXIT_FAILURE;
+    { fprintf(stderr, "Error at line: %i called from line: %i\n", lineno, __LINE__); return EXIT_FAILURE; }
   if (!QuatDerivativeTest<double>())
-    return EXIT_FAILURE;
+    { fprintf(stderr, "Error at line: %i called from line: %i\n", lineno, __LINE__); return EXIT_FAILURE; }
 
   // Do matrix tests
   if (!MatrixTest<float>())
-    return EXIT_FAILURE;
+    { fprintf(stderr, "Error at line: %i called from line: %i\n", lineno, __LINE__); return EXIT_FAILURE; }
   if (!MatrixTest<double>())
-    return EXIT_FAILURE;
+    { fprintf(stderr, "Error at line: %i called from line: %i\n", lineno, __LINE__); return EXIT_FAILURE; }
 
   // Do rect tests
   doRectTest<int>();
@@ -387,7 +390,7 @@ main(void)
 
   // Check geodetic/geocentric/cartesian conversions
   if (!GeodesyTest())
-    return EXIT_FAILURE;
+    { fprintf(stderr, "Error at line: %i called from line: %i\n", lineno, __LINE__); return EXIT_FAILURE; }
 
   std::cout << "Successfully passed all tests!" << std::endl;
   return EXIT_SUCCESS;

simgear/math/SGMatrix.hxx

@@ -18,6 +18,8 @@
 #ifndef SGMatrix_H
 #define SGMatrix_H
 
+#include <simgear/math/simd4x4.hxx>
+
 /// Expression templates for poor programmers ... :)
 template<typename T>
 struct TransNegRef;
@@ -38,13 +40,13 @@ public:
     /// uninitialized values in the debug build very fast ...
 #ifndef NDEBUG
     for (unsigned i = 0; i < nEnts; ++i)
-      _data.flat[i] = SGLimits<T>::quiet_NaN();
+      _data[i] = SGLimits<T>::quiet_NaN();
 #endif
   }
   /// Constructor. Initialize by the content of a plain array,
   /// make sure it has at least 16 elements
   explicit SGMatrix(const T* data)
-  { for (unsigned i = 0; i < nEnts; ++i) _data.flat[i] = data[i]; }
+  { _data = simd4x4_t<T,4>(data); }
 
   /// Constructor, build up a SGMatrix from given elements
   SGMatrix(T m00, T m01, T m02, T m03,
@@ -52,14 +54,8 @@ public:
            T m20, T m21, T m22, T m23,
            T m30, T m31, T m32, T m33)
   {
-    _data.flat[0] = m00; _data.flat[1] = m10;
-    _data.flat[2] = m20; _data.flat[3] = m30;
-    _data.flat[4] = m01; _data.flat[5] = m11;
-    _data.flat[6] = m21; _data.flat[7] = m31;
-    _data.flat[8] = m02; _data.flat[9] = m12;
-    _data.flat[10] = m22; _data.flat[11] = m32;
-    _data.flat[12] = m03; _data.flat[13] = m13;
-    _data.flat[14] = m23; _data.flat[15] = m33;
+    _data = simd4x4_t<T,4>(m00,m01,m02,m03,m10,m11,m12,m13,
+                           m20,m21,m22,m23,m30,m31,m32,m33);
   }
 
   /// Constructor, build up a SGMatrix from a translation
@@ -80,14 +76,8 @@ public:
   template<typename S>
   void set(const SGVec3<S>& trans)
   {
-    _data.flat[0] = 1; _data.flat[4] = 0;
-    _data.flat[8] = 0; _data.flat[12] = T(trans(0));
-    _data.flat[1] = 0; _data.flat[5] = 1;
-    _data.flat[9] = 0; _data.flat[13] = T(trans(1));
-    _data.flat[2] = 0; _data.flat[6] = 0;
-    _data.flat[10] = 1; _data.flat[14] = T(trans(2));
-    _data.flat[3] = 0; _data.flat[7] = 0;
-    _data.flat[11] = 0; _data.flat[15] = 1;
+    simd4x4::unit(_data);
+    simd4x4::translate(_data, trans.simd3());
   }
 
   /// Set from a scale/rotation and tranlation
@@ -98,82 +88,77 @@ public:
     T xx = x*x; T yy = y*y; T zz = z*z;
     T wx = w*x; T wy = w*y; T wz = w*z;
     T xy = x*y; T xz = x*z; T yz = y*z;
-    _data.flat[0] = 1-2*(yy+zz); _data.flat[1] = 2*(xy-wz);
-    _data.flat[2] = 2*(xz+wy); _data.flat[3] = 0;
-    _data.flat[4] = 2*(xy+wz); _data.flat[5] = 1-2*(xx+zz);
-    _data.flat[6] = 2*(yz-wx); _data.flat[7] = 0;
-    _data.flat[8] = 2*(xz-wy); _data.flat[9] = 2*(yz+wx);
-    _data.flat[10] = 1-2*(xx+yy); _data.flat[11] = 0;
-    _data.flat[12] = 0; _data.flat[13] = 0;
-    _data.flat[14] = 0; _data.flat[15] = 1;
+    _data[0] = 1-2*(yy+zz); _data[1] = 2*(xy-wz);
+    _data[2] = 2*(xz+wy); _data[3] = 0;
+    _data[4] = 2*(xy+wz); _data[5] = 1-2*(xx+zz);
+    _data[6] = 2*(yz-wx); _data[7] = 0;
+    _data[8] = 2*(xz-wy); _data[9] = 2*(yz+wx);
+    _data[10] = 1-2*(xx+yy); _data[11] = 0;
+    _data[12] = 0; _data[13] = 0;
+    _data[14] = 0; _data[15] = 1;
   }
 
   /// set from a transposed negated matrix
   void set(const TransNegRef<T>& tm)
   {
     const SGMatrix& m = tm.m;
-    _data.flat[0] = m(0,0);
-    _data.flat[1] = m(0,1);
-    _data.flat[2] = m(0,2);
-    _data.flat[3] = m(3,0);
-
-    _data.flat[4] = m(1,0);
-    _data.flat[5] = m(1,1);
-    _data.flat[6] = m(1,2);
-    _data.flat[7] = m(3,1);
-
-    _data.flat[8] = m(2,0);
-    _data.flat[9] = m(2,1);
-    _data.flat[10] = m(2,2);
-    _data.flat[11] = m(3,2);
+    _data = simd4x4::transpose(m.simd4x4());
+    _data[3] = m(3,0);
+    _data[7] = m(3,1);
+    _data[11] = m(3,2);
 
     // Well, this one is ugly here, as that xform method on the current
     // object needs the above data to be already set ...
     SGVec3<T> t = xformVec(SGVec3<T>(m(0,3), m(1,3), m(2,3)));
-    _data.flat[12] = -t(0);
-    _data.flat[13] = -t(1);
-    _data.flat[14] = -t(2);
-    _data.flat[15] = m(3,3);
+    _data.set(3, -t.simd3());
+    _data[15] = m(3,3);
   }
 
   /// Access by index, the index is unchecked
   const T& operator()(unsigned i, unsigned j) const
-  { return _data.flat[i + 4*j]; }
+  { return _data[i + 4*j]; }
   /// Access by index, the index is unchecked
   T& operator()(unsigned i, unsigned j)
-  { return _data.flat[i + 4*j]; }
+  { return _data[i + 4*j]; }
 
   /// Access raw data by index, the index is unchecked
   const T& operator[](unsigned i) const
-  { return _data.flat[i]; }
+  { return _data[i]; }
   /// Access by index, the index is unchecked
   T& operator[](unsigned i)
-  { return _data.flat[i]; }
+  { return _data[i]; }
 
   /// Get the data pointer
   const T* data(void) const
-  { return _data.flat; }
+  { return _data; }
   /// Get the data pointer
   T* data(void)
-  { return _data.flat; }
+  { return _data; }
 
   /// Readonly interface function to ssg's sgMat4/sgdMat4
   const T (&sg(void) const)[4][4]
-  { return _data.carray; }
+  { return _data.ptr(); }
   /// Interface function to ssg's sgMat4/sgdMat4
   T (&sg(void))[4][4]
-  { return _data.carray; }
+  { return _data.ptr(); }
+  /// Readonly raw storage interface
+  const simd4x4_t<T,4> (&simd4x4(void) const)
+  { return _data; }
+  /// Readonly raw storage interface
+  simd4x4_t<T,4> (&simd4x4(void))
+  { return _data; }
+
 
   /// Inplace addition
   SGMatrix& operator+=(const SGMatrix& m)
-  { for (unsigned i = 0; i < nEnts; ++i) _data.flat[i] += m._data.flat[i]; return *this; }
+  { _data += m.simd4x4(); return *this; }
   /// Inplace subtraction
   SGMatrix& operator-=(const SGMatrix& m)
-  { for (unsigned i = 0; i < nEnts; ++i) _data.flat[i] -= m._data.flat[i]; return *this; }
+  { _data -= m.simd4x4(); return *this; }
   /// Inplace scalar multiplication
   template<typename S>
   SGMatrix& operator*=(S s)
-  { for (unsigned i = 0; i < nEnts; ++i) _data.flat[i] *= s; return *this; }
+  { _data *= s; return *this; }
   /// Inplace scalar multiplication by 1/s
   template<typename S>
   SGMatrix& operator/=(S s)
@@ -184,27 +169,13 @@ public:
   template<typename S>
   SGMatrix& preMultTranslate(const SGVec3<S>& t)
   {
-    for (unsigned i = 0; i < 3; ++i) {
-      T tmp = T(t(i));
-      if (tmp == 0)
-        continue;
-      (*this)(i,0) += tmp*(*this)(3,0);
-      (*this)(i,1) += tmp*(*this)(3,1);
-      (*this)(i,2) += tmp*(*this)(3,2);
-      (*this)(i,3) += tmp*(*this)(3,3);
-    }
+    simd4x4::pre_translate(_data,t.simd3());
     return *this;
   }
   template<typename S>
   SGMatrix& postMultTranslate(const SGVec3<S>& t)
   {
-    SGVec4<T> col3((*this)(0,3), (*this)(1,3), (*this)(2,3), (*this)(3,3));
-    for (unsigned i = 0; i < SGMatrix<T>::nCols-1; ++i) {
-      SGVec4<T> tmp((*this)(0,i), (*this)(1,i), (*this)(2,i), (*this)(3,i));
-      col3 += T(t(i))*tmp;
-    }
-    (*this)(0,3) = col3(0); (*this)(1,3) = col3(1);
-    (*this)(2,3) = col3(2); (*this)(3,3) = col3(3);
+    simd4x4::post_translate(_data,t.simd3());
     return *this;
   }
 
@@ -230,51 +201,27 @@ public:
   SGVec3<T> xformPt(const SGVec3<T>& pt) const
   {
     SGVec3<T> tpt;
-    tpt(0) = (*this)(0,3);
-    tpt(1) = (*this)(1,3);
-    tpt(2) = (*this)(2,3);
-    for (unsigned i = 0; i < SGMatrix<T>::nCols-1; ++i) {
-      T tmp = pt(i);
-      tpt(0) += tmp*(*this)(0,i);
-      tpt(1) += tmp*(*this)(1,i);
-      tpt(2) += tmp*(*this)(2,i);
-    }
+    tpt.simd3() = simd4x4::transform(_data,pt.simd3());
     return tpt;
   }
   SGVec3<T> xformVec(const SGVec3<T>& v) const
   {
     SGVec3<T> tv;
-    T tmp = v(0);
-    tv(0) = tmp*(*this)(0,0);
-    tv(1) = tmp*(*this)(1,0);
-    tv(2) = tmp*(*this)(2,0);
-    for (unsigned i = 1; i < SGMatrix<T>::nCols-1; ++i) {
-      T tmp = v(i);
-      tv(0) += tmp*(*this)(0,i);
-      tv(1) += tmp*(*this)(1,i);
-      tv(2) += tmp*(*this)(2,i);
-    }
+    tv.simd3() = _data * v.simd3();
     return tv;
   }
 
   /// Return an all zero matrix
   static SGMatrix zeros(void)
-  { return SGMatrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); }
+  { SGMatrix r; simd4x4::zeros(r.simd4x4()); return r; }
 
   /// Return a unit matrix
   static SGMatrix unit(void)
-  { return SGMatrix(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); }
+  { SGMatrix r; simd4x4::unit(r.simd4x4()); return r; }
 
 private:
-  /// Required to make that alias safe.
-  union Data {
-    T flat[16];
-    T carray[4][4];
-  };
 
-  /// The actual data, the matrix is stored in column major order,
-  /// that matches the storage format of OpenGL
-  Data _data;
+  simd4x4_t<T,4> _data;
 };
 
 /// Class to distinguish between a matrix and the matrix with a transposed
@@ -296,61 +243,45 @@ operator+(const SGMatrix<T>& m)
 template<typename T>
 inline
 SGMatrix<T>
-operator-(const SGMatrix<T>& m)
+operator-(SGMatrix<T> m)
 {
-  SGMatrix<T> ret;
-  for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
-    ret[i] = -m[i];
-  return ret;
+  m.simd4x4() = -m.simd4x4();
+  return m;
 }
 
 /// Binary +
 template<typename T>
 inline
 SGMatrix<T>
-operator+(const SGMatrix<T>& m1, const SGMatrix<T>& m2)
+operator+(SGMatrix<T> m1, const SGMatrix<T>& m2)
 {
-  SGMatrix<T> ret;
-  for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
-    ret[i] = m1[i] + m2[i];
-  return ret;
+  m1.simd4x4() += m2.simd4x4();
+  return m1;
 }
 
 /// Binary -
 template<typename T>
 inline
 SGMatrix<T>
-operator-(const SGMatrix<T>& m1, const SGMatrix<T>& m2)
+operator-(SGMatrix<T> m1, const SGMatrix<T>& m2)
 {
-  SGMatrix<T> ret;
-  for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
-    ret[i] = m1[i] - m2[i];
-  return ret;
+  m1.simd4x4() -= m2.simd4x4();
+  return m1;
 }
 
 /// Scalar multiplication
 template<typename S, typename T>
 inline
 SGMatrix<T>
-operator*(S s, const SGMatrix<T>& m)
-{
-  SGMatrix<T> ret;
-  for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
-    ret[i] = s*m[i];
-  return ret;
-}
+operator*(S s, SGMatrix<T> m)
+{ m.simd4x4() *= s; return m; }
 
 /// Scalar multiplication
 template<typename S, typename T>
 inline
 SGMatrix<T>
-operator*(const SGMatrix<T>& m, S s)
-{
-  SGMatrix<T> ret;
-  for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
-    ret[i] = s*m[i];
-  return ret;
-}
+operator*(SGMatrix<T> m, S s)
+{ m.simd4x4() *= s; return m; }
 
 /// Vector multiplication
 template<typename T>
@@ -359,18 +290,7 @@ SGVec4<T>
 operator*(const SGMatrix<T>& m, const SGVec4<T>& v)
 {
   SGVec4<T> mv;
-  T tmp = v(0);
-  mv(0) = tmp*m(0,0);
-  mv(1) = tmp*m(1,0);
-  mv(2) = tmp*m(2,0);
-  mv(3) = tmp*m(3,0);
-  for (unsigned i = 1; i < SGMatrix<T>::nCols; ++i) {
-    T tmp = v(i);
-    mv(0) += tmp*m(0,i);
-    mv(1) += tmp*m(1,i);
-    mv(2) += tmp*m(2,i);
-    mv(3) += tmp*m(3,i);
-  }
+  mv.simd4() = m.simd4x4() * v.simd4();
   return mv;
 }
 
@@ -405,20 +325,7 @@ SGMatrix<T>
 operator*(const SGMatrix<T>& m1, const SGMatrix<T>& m2)
 {
   SGMatrix<T> m;
-  for (unsigned j = 0; j < SGMatrix<T>::nCols; ++j) {
-    T tmp = m2(0,j);
-    m(0,j) = tmp*m1(0,0);
-    m(1,j) = tmp*m1(1,0);
-    m(2,j) = tmp*m1(2,0);
-    m(3,j) = tmp*m1(3,0);
-    for (unsigned i = 1; i < SGMatrix<T>::nCols; ++i) {
-      T tmp = m2(i,j);
-      m(0,j) += tmp*m1(0,i);
-      m(1,j) += tmp*m1(1,i);
-      m(2,j) += tmp*m1(2,i);
-      m(3,j) += tmp*m1(3,i);
-    }
-  }
+  m.simd4x4() = m1.simd4x4() * m2.simd4x4();
   return m;
 }
 

simgear/math/SGMisc.hxx

@@ -153,17 +153,7 @@ public:
   /// Use with care: allways code that you do not need to use that!
   static bool isNaN(const T& v)
   {
-#ifdef HAVE_ISNAN
-    return (isnan(v) != 0);
-#elif defined HAVE_STD_ISNAN
     return std::isnan(v);
-#else
-    // Use that every compare involving a NaN returns false
-    // But be careful, some usual compiler switches like for example
-    // -fast-math from gcc might optimize that expression to v != v which
-    // behaves exactly like the opposite ...
-    return !(v == v);
-#endif
   }
 };
 

simgear/math/SGVec2.hxx

@@ -20,6 +20,11 @@
 
 #include <iosfwd>
 
+#include <simgear/math/SGLimits.hxx>
+#include <simgear/math/SGMisc.hxx>
+#include <simgear/math/SGMathFwd.hxx>
+#include <simgear/math/simd.hxx>
+
 /// 2D Vector Class
 template<typename T>
 class SGVec2 {
@@ -40,11 +45,11 @@ public:
   }
   /// Constructor. Initialize by the given values
   SGVec2(T x, T y)
-  { data()[0] = x; data()[1] = y; }
+  { _data = simd4_t<T,2>(x, y); }
   /// Constructor. Initialize by the content of a plain array,
   /// make sure it has at least 2 elements
   explicit SGVec2(const T* d)
-  { data()[0] = d[0]; data()[1] = d[1]; }
+  { _data = d ? simd4_t<T,2>(d) : simd4_t<T,2>(T(0)); }
   template<typename S>
   explicit SGVec2(const SGVec2<S>& d)
   { data()[0] = d[0]; data()[1] = d[1]; }
@@ -78,25 +83,30 @@ public:
 
   /// Access raw data
   const T (&data(void) const)[2]
-  { return _data; }
+  { return _data.ptr(); }
   /// Access raw data
   T (&data(void))[2]
+  { return _data.ptr(); }
+  const simd4_t<T,2> (&simd2(void) const)
+  { return _data; }
+  /// Readonly raw storage interface
+  simd4_t<T,2> (&simd2(void))
   { return _data; }
 
   /// Inplace addition
   SGVec2& operator+=(const SGVec2& v)
-  { data()[0] += v(0); data()[1] += v(1); return *this; }
+  { _data += v.simd2(); return *this; }
   /// Inplace subtraction
   SGVec2& operator-=(const SGVec2& v)
-  { data()[0] -= v(0); data()[1] -= v(1); return *this; }
+  { _data -= v.simd2(); return *this; }
   /// Inplace scalar multiplication
   template<typename S>
   SGVec2& operator*=(S s)
-  { data()[0] *= s; data()[1] *= s; return *this; }
+  { _data *= s; return *this; }
   /// Inplace scalar multiplication by 1/s
   template<typename S>
   SGVec2& operator/=(S s)
-  { return operator*=(1/T(s)); }
+  { _data*=(1/T(s)); return *this; }
 
   /// Return an all zero vector
   static SGVec2 zeros(void)
@@ -108,7 +118,7 @@ public:
   { return SGVec2(0, 1); }
 
 private:
-  T _data[2];
+  simd4_t<T,2> _data;
 };
 
 /// Unary +, do nothing ...
@@ -122,36 +132,36 @@ operator+(const SGVec2<T>& v)
 template<typename T>
 inline
 SGVec2<T>
-operator-(const SGVec2<T>& v)
-{ return SGVec2<T>(-v(0), -v(1)); }
+operator-(SGVec2<T> v)
+{ v *= -1; return v; }
 
 /// Binary +
 template<typename T>
 inline
 SGVec2<T>
-operator+(const SGVec2<T>& v1, const SGVec2<T>& v2)
-{ return SGVec2<T>(v1(0)+v2(0), v1(1)+v2(1)); }
+operator+(SGVec2<T> v1, const SGVec2<T>& v2)
+{ v1.simd2() += v2.simd2(); return v1; }
 
 /// Binary -
 template<typename T>
 inline
 SGVec2<T>
-operator-(const SGVec2<T>& v1, const SGVec2<T>& v2)
-{ return SGVec2<T>(v1(0)-v2(0), v1(1)-v2(1)); }
+operator-(SGVec2<T> v1, const SGVec2<T>& v2)
+{ v1.simd2() -= v2.simd2(); return v1; }
 
 /// Scalar multiplication
 template<typename S, typename T>
 inline
 SGVec2<T>
-operator*(S s, const SGVec2<T>& v)
-{ return SGVec2<T>(s*v(0), s*v(1)); }
+operator*(S s, SGVec2<T> v)
+{ v.simd2() *= s; return v; }
 
 /// Scalar multiplication
 template<typename S, typename T>
 inline
 SGVec2<T>
-operator*(const SGVec2<T>& v, S s)
-{ return SGVec2<T>(s*v(0), s*v(1)); }
+operator*(SGVec2<T> v, S s)
+{ v.simd2() *= s; return v; }
 
 /// multiplication as a multiplicator, that is assume that the first vector
 /// represents a 2x2 diagonal matrix with the diagonal elements in the vector.
@@ -159,42 +169,42 @@ operator*(const SGVec2<T>& v, S s)
 template<typename T>
 inline
 SGVec2<T>
-mult(const SGVec2<T>& v1, const SGVec2<T>& v2)
-{ return SGVec2<T>(v1(0)*v2(0), v1(1)*v2(1)); }
+mult(SGVec2<T> v1, const SGVec2<T>& v2)
+{ v1.simd2() *= v2.simd2(); return v1; }
 
 /// component wise min
 template<typename T>
 inline
 SGVec2<T>
-min(const SGVec2<T>& v1, const SGVec2<T>& v2)
-{return SGVec2<T>(SGMisc<T>::min(v1(0), v2(0)), SGMisc<T>::min(v1(1), v2(1)));}
+min(SGVec2<T> v1, const SGVec2<T>& v2)
+{ v1.simd2() = simd4::min(v1.simd2(), v2.simd2()); return v1; }
 template<typename S, typename T>
 inline
 SGVec2<T>
-min(const SGVec2<T>& v, S s)
-{ return SGVec2<T>(SGMisc<T>::min(s, v(0)), SGMisc<T>::min(s, v(1))); }
+min(SGVec2<T> v, S s)
+{ v.simd2() = simd4::min(v.simd2(), simd4_t<T,2>(s)); return v; }
 template<typename S, typename T>
 inline
 SGVec2<T>
-min(S s, const SGVec2<T>& v)
-{ return SGVec2<T>(SGMisc<T>::min(s, v(0)), SGMisc<T>::min(s, v(1))); }
+min(S s, SGVec2<T> v)
+{ v.sim2() = simd4::min(v.simd2(), simd4_t<T,2>(s)); return v; }
 
 /// component wise max
 template<typename T>
 inline
 SGVec2<T>
 max(const SGVec2<T>& v1, const SGVec2<T>& v2)
-{return SGVec2<T>(SGMisc<T>::max(v1(0), v2(0)), SGMisc<T>::max(v1(1), v2(1)));}
+{ v1 = simd4::max(v1.simd2(), v2.simd2()); return v1; }
 template<typename S, typename T>
 inline
 SGVec2<T>
 max(const SGVec2<T>& v, S s)
-{ return SGVec2<T>(SGMisc<T>::max(s, v(0)), SGMisc<T>::max(s, v(1))); }
+{ v = simd4::max(v.simd2(), simd4_t<T,2>(s)); return v; }
 template<typename S, typename T>
 inline
 SGVec2<T>
 max(S s, const SGVec2<T>& v)
-{ return SGVec2<T>(SGMisc<T>::max(s, v(0)), SGMisc<T>::max(s, v(1))); }
+{ v = simd4::max(v.simd2(), simd4_t<T,2>(s)); return v; }
 
 /// Add two vectors taking care of (integer) overflows. The values are limited
 /// to the respective minimum and maximum values.
@@ -212,36 +222,39 @@ template<typename T>
 inline
 T
 dot(const SGVec2<T>& v1, const SGVec2<T>& v2)
-{ return v1(0)*v2(0) + v1(1)*v2(1); }
+{ return simd4::dot(v1.simd2(), v2.simd2()); }
 
 /// The euclidean norm of the vector, that is what most people call length
 template<typename T>
 inline
 T
 norm(const SGVec2<T>& v)
-{ return sqrt(dot(v, v)); }
+{ return simd4::magnitude(v.simd2()); }
 
 /// The euclidean norm of the vector, that is what most people call length
 template<typename T>
 inline
 T
 length(const SGVec2<T>& v)
-{ return sqrt(dot(v, v)); }
+{ return simd4::magnitude(v.simd2()); }
 
 /// The 1-norm of the vector, this one is the fastest length function we
 /// can implement on modern cpu's
 template<typename T>
 inline
 T
-norm1(const SGVec2<T>& v)
-{ return fabs(v(0)) + fabs(v(1)); }
+norm1(SGVec2<T> v)
+{ v.simd2() = simd4::abs(v.simd2()); return (v(0)+v(1)); }
 
 /// The inf-norm of the vector
 template<typename T>
 inline
 T
-normI(const SGVec2<T>& v)
-{ return SGMisc<T>::max(fabs(v(0)), fabs(v(1))); }
+normI(SGVec2<T> v)
+{
+  v.simd2() = simd4::abs(v.simd2());
+  return SGMisc<T>::max(v(0), v(1));
+}
 
 /// The euclidean norm of the vector, that is what most people call length
 template<typename T>
@@ -331,14 +344,14 @@ template<typename T>
 inline
 T
 dist(const SGVec2<T>& v1, const SGVec2<T>& v2)
-{ return norm(v1 - v2); }
+{ return simd4::magnitude(v1.simd2() - v2.simd2()); }
 
 /// The squared euclidean distance of the two vectors
 template<typename T>
 inline
 T
-distSqr(const SGVec2<T>& v1, const SGVec2<T>& v2)
-{ SGVec2<T> tmp = v1 - v2; return dot(tmp, tmp); }
+distSqr(SGVec2<T> v1, const SGVec2<T>& v2)
+{ return simd4::magnitude2(v1.simd2() - v2.simd2()); }
 
 // calculate the projection of u along the direction of d.
 template<typename T>
@@ -346,12 +359,22 @@ inline
 SGVec2<T>
 projection(const SGVec2<T>& u, const SGVec2<T>& d)
 {
-  T denom = dot(d, d);
+  T denom = simd4::magnitude2(d.simd2());
   T ud = dot(u, d);
   if (SGLimits<T>::min() < denom) return u;
   else return d * (dot(u, d) / denom);
 }
 
+template<typename T>
+inline
+SGVec2<T>
+interpolate(T tau, const SGVec2<T>& v1, const SGVec2<T>& v2)
+{
+  SGVec2<T> r;
+  r.simd2() = simd4::interpolate(tau, v1.simd2(), v2.simd2());
+  return r;
+}
+
 #ifndef NDEBUG
 template<typename T>
 inline
@@ -372,11 +395,11 @@ operator<<(std::basic_ostream<char_type, traits_type>& s, const SGVec2<T>& v)
 inline
 SGVec2f
 toVec2f(const SGVec2d& v)
-{ return SGVec2f((float)v(0), (float)v(1)); }
+{ SGVec2f f(v); return f; }
 
 inline
 SGVec2d
 toVec2d(const SGVec2f& v)
-{ return SGVec2d(v(0), v(1)); }
+{ SGVec2d d(v); return d; }
 
 #endif

simgear/math/SGVec3.hxx

@@ -20,6 +20,10 @@
 
 #include <iosfwd>
 
+#include <simgear/math/SGVec2.hxx>
+#include <simgear/math/SGGeodesy.hxx>
+#include <simgear/math/simd.hxx>
+
 /// 3D Vector Class
 template<typename T>
 class SGVec3 {
@@ -51,16 +55,16 @@ public:
 
   /// Constructor. Initialize by the given values
   SGVec3(T x, T y, T z)
-  { data()[0] = x; data()[1] = y; data()[2] = z; }
+  { _data = simd4_t<T,3>(x, y, z); }
   /// Constructor. Initialize by the content of a plain array,
   /// make sure it has at least 3 elements
   explicit SGVec3(const T* d)
-  { data()[0] = d[0]; data()[1] = d[1]; data()[2] = d[2]; }
+  { _data = d ? simd4_t<T,3>(d) : simd4_t<T,3>(T(0)); }
   template<typename S>
   explicit SGVec3(const SGVec3<S>& d)
   { data()[0] = d[0]; data()[1] = d[1]; data()[2] = d[2]; }
   explicit SGVec3(const SGVec2<T>& v2, const T& v3 = 0)
-  { data()[0] = v2[0]; data()[1] = v2[1]; data()[2] = v3; }
+  { _data = v2.simd2(); data()[2] = v3; }
 
   /// Access by index, the index is unchecked
   const T& operator()(unsigned i) const
@@ -97,25 +101,31 @@ public:
 
   /// Readonly raw storage interface
   const T (&data(void) const)[3]
-  { return _data; }
+  { return _data.ptr(); }
   /// Readonly raw storage interface
   T (&data(void))[3]
+  { return _data.ptr(); }
+  /// Readonly raw storage interface
+  const simd4_t<T,3> (&simd3(void) const)
+  { return _data; }
+  /// Readonly raw storage interface
+  simd4_t<T,3> (&simd3(void))
   { return _data; }
 
   /// Inplace addition
   SGVec3& operator+=(const SGVec3& v)
-  { data()[0] += v(0); data()[1] += v(1); data()[2] += v(2); return *this; }
+  { _data += v.simd3(); return *this; }
   /// Inplace subtraction
   SGVec3& operator-=(const SGVec3& v)
-  { data()[0] -= v(0); data()[1] -= v(1); data()[2] -= v(2); return *this; }
+  { _data -= v.simd3(); return *this; }
   /// Inplace scalar multiplication
   template<typename S>
   SGVec3& operator*=(S s)
-  { data()[0] *= s; data()[1] *= s; data()[2] *= s; return *this; }
+  { _data *= s; return *this; }
   /// Inplace scalar multiplication by 1/s
   template<typename S>
   SGVec3& operator/=(S s)
-  { return operator*=(1/T(s)); }
+  { _data*=(1/T(s)); return *this; }
 
   /// Return an all zero vector
   static SGVec3 zeros(void)
@@ -136,7 +146,8 @@ public:
   static SGVec3 fromGeoc(const SGGeoc& geoc);
 
 private:
-  T _data[3];
+  simd4_t<T,3> _data;
+  
 };
 
 template<>
@@ -190,36 +201,36 @@ operator+(const SGVec3<T>& v)
 template<typename T>
 inline
 SGVec3<T>
-operator-(const SGVec3<T>& v)
-{ return SGVec3<T>(-v(0), -v(1), -v(2)); }
+operator-(SGVec3<T> v)
+{ v *= -1; return v; }
 
 /// Binary +
 template<typename T>
 inline
 SGVec3<T>
-operator+(const SGVec3<T>& v1, const SGVec3<T>& v2)
-{ return SGVec3<T>(v1(0)+v2(0), v1(1)+v2(1), v1(2)+v2(2)); }
+operator+(SGVec3<T> v1, const SGVec3<T>& v2)
+{ v1.simd3() += v2.simd3(); return v1; }
 
 /// Binary -
 template<typename T>
 inline
 SGVec3<T>
-operator-(const SGVec3<T>& v1, const SGVec3<T>& v2)
-{ return SGVec3<T>(v1(0)-v2(0), v1(1)-v2(1), v1(2)-v2(2)); }
+operator-(SGVec3<T> v1, const SGVec3<T>& v2)
+{ v1.simd3() -= v2.simd3(); return v1; }
 
 /// Scalar multiplication
 template<typename S, typename T>
 inline
 SGVec3<T>
-operator*(S s, const SGVec3<T>& v)
-{ return SGVec3<T>(s*v(0), s*v(1), s*v(2)); }
+operator*(S s, SGVec3<T> v)
+{ v.simd3() *= s; return v; }
 
 /// Scalar multiplication
 template<typename S, typename T>
 inline
 SGVec3<T>
-operator*(const SGVec3<T>& v, S s)
-{ return SGVec3<T>(s*v(0), s*v(1), s*v(2)); }
+operator*(SGVec3<T> v, S s)
+{ v.simd3() *= s; return v; }
 
 /// multiplication as a multiplicator, that is assume that the first vector
 /// represents a 3x3 diagonal matrix with the diagonal elements in the vector.
@@ -227,66 +238,42 @@ operator*(const SGVec3<T>& v, S s)
 template<typename T>
 inline
 SGVec3<T>
-mult(const SGVec3<T>& v1, const SGVec3<T>& v2)
-{ return SGVec3<T>(v1(0)*v2(0), v1(1)*v2(1), v1(2)*v2(2)); }
+mult(SGVec3<T> v1, const SGVec3<T>& v2)
+{ v1.simd3() *= v2.simd3(); return v1; }
 
 /// component wise min
 template<typename T>
 inline
 SGVec3<T>
-min(const SGVec3<T>& v1, const SGVec3<T>& v2)
-{
-  return SGVec3<T>(SGMisc<T>::min(v1(0), v2(0)),
-                   SGMisc<T>::min(v1(1), v2(1)),
-                   SGMisc<T>::min(v1(2), v2(2)));
-}
+min(SGVec3<T> v1, const SGVec3<T>& v2)
+{ v1.simd3() = simd4::min(v1.simd3(), v2.simd3()); return v1; }
 template<typename S, typename T>
 inline
 SGVec3<T>
-min(const SGVec3<T>& v, S s)
-{
-  return SGVec3<T>(SGMisc<T>::min(s, v(0)),
-                   SGMisc<T>::min(s, v(1)),
-                   SGMisc<T>::min(s, v(2)));
-}
+min(SGVec3<T> v, S s)
+{ v.simd3() = simd4::min(v.simd3(), simd4_t<T,3>(s)); return v; }
 template<typename S, typename T>
 inline
 SGVec3<T>
-min(S s, const SGVec3<T>& v)
-{
-  return SGVec3<T>(SGMisc<T>::min(s, v(0)),
-                   SGMisc<T>::min(s, v(1)),
-                   SGMisc<T>::min(s, v(2)));
-}
+min(S s, SGVec3<T> v)
+{ v.simd3() = simd4::min(v.simd3(), simd4_t<T,3>(s)); return v; }
 
 /// component wise max
 template<typename T>
 inline
 SGVec3<T>
-max(const SGVec3<T>& v1, const SGVec3<T>& v2)
-{
-  return SGVec3<T>(SGMisc<T>::max(v1(0), v2(0)),
-                   SGMisc<T>::max(v1(1), v2(1)),
-                   SGMisc<T>::max(v1(2), v2(2)));
-}
+max(SGVec3<T> v1, const SGVec3<T>& v2)
+{ v1.simd3() = simd4::max(v1.simd3(), v2.simd3()); return v1; }
 template<typename S, typename T>
 inline
 SGVec3<T>
-max(const SGVec3<T>& v, S s)
-{
-  return SGVec3<T>(SGMisc<T>::max(s, v(0)),
-                   SGMisc<T>::max(s, v(1)),
-                   SGMisc<T>::max(s, v(2)));
-}
+max(SGVec3<T> v, S s)
+{ v.simd3() = simd4::max(v.simd3(), simd4_t<T,3>(s)); return v; }
 template<typename S, typename T>
 inline
 SGVec3<T>
-max(S s, const SGVec3<T>& v)
-{
-  return SGVec3<T>(SGMisc<T>::max(s, v(0)),
-                   SGMisc<T>::max(s, v(1)),
-                   SGMisc<T>::max(s, v(2)));
-}
+max(S s, SGVec3<T> v)
+{ v.simd3() = simd4::max(v.simd3(), simd4_t<T,3>(s)); return v; }
 
 /// Add two vectors taking care of (integer) overflows. The values are limited
 /// to the respective minimum and maximum values.
@@ -305,47 +292,46 @@ template<typename T>
 inline
 T
 dot(const SGVec3<T>& v1, const SGVec3<T>& v2)
-{ return v1(0)*v2(0) + v1(1)*v2(1) + v1(2)*v2(2); }
+{ return simd4::dot(v1.simd3(), v2.simd3()); }
 
 /// The euclidean norm of the vector, that is what most people call length
 template<typename T>
 inline
 T
 norm(const SGVec3<T>& v)
-{ return sqrt(dot(v, v)); }
+{ return simd4::magnitude(v.simd3()); }
 
 /// The euclidean norm of the vector, that is what most people call length
 template<typename T>
 inline
 T
 length(const SGVec3<T>& v)
-{ return sqrt(dot(v, v)); }
+{ return simd4::magnitude(v.simd3()); }
 
 /// The 1-norm of the vector, this one is the fastest length function we
 /// can implement on modern cpu's
 template<typename T>
 inline
 T
-norm1(const SGVec3<T>& v)
-{ return fabs(v(0)) + fabs(v(1)) + fabs(v(2)); }
+norm1(SGVec3<T> v)
+{ v.simd3() = simd4::abs(v.simd3()); return (v(0)+v(1)+v(2)); }
 
 /// The inf-norm of the vector
 template<typename T>
 inline
 T
-normI(const SGVec3<T>& v)
-{ return SGMisc<T>::max(fabs(v(0)), fabs(v(1)), fabs(v(2))); }
+normI(SGVec3<T> v)
+{
+  v.simd3() = simd4::abs(v.simd3());
+  return SGMisc<T>::max(v(0), v(1), v(2));
+}
 
 /// Vector cross product
 template<typename T>
 inline
 SGVec3<T>
-cross(const SGVec3<T>& v1, const SGVec3<T>& v2)
-{
-  return SGVec3<T>(v1(1)*v2(2) - v1(2)*v2(1),
-                   v1(2)*v2(0) - v1(0)*v2(2),
-                   v1(0)*v2(1) - v1(1)*v2(0));
-}
+cross(SGVec3<T> v1, const SGVec3<T>& v2)
+{ v1.simd3() = simd4::cross(v1.simd3(), v2.simd3()); return v1; }
 
 /// return any normalized vector perpendicular to v
 template<typename T>
@@ -465,14 +451,14 @@ template<typename T>
 inline
 T
 dist(const SGVec3<T>& v1, const SGVec3<T>& v2)
-{ return norm(v1 - v2); }
+{ return simd4::magnitude(v1.simd3() - v2.simd3()); }
 
 /// The squared euclidean distance of the two vectors
 template<typename T>
 inline
 T
-distSqr(const SGVec3<T>& v1, const SGVec3<T>& v2)
-{ SGVec3<T> tmp = v1 - v2; return dot(tmp, tmp); }
+distSqr(SGVec3<T> v1, const SGVec3<T>& v2)
+{ return simd4::magnitude2(v1.simd3() - v2.simd3()); }
 
 // calculate the projection of u along the direction of d.
 template<typename T>
@@ -480,12 +466,22 @@ inline
 SGVec3<T>
 projection(const SGVec3<T>& u, const SGVec3<T>& d)
 {
-  T denom = dot(d, d);
+  T denom = simd4::magnitude2(d.simd3());
   T ud = dot(u, d);
   if (SGLimits<T>::min() < denom) return u;
   else return d * (dot(u, d) / denom);
 }
 
+template<typename T>
+inline
+SGVec3<T>
+interpolate(T tau, const SGVec3<T>& v1, const SGVec3<T>& v2)
+{
+  SGVec3<T> r;
+  r.simd3() = simd4::interpolate(tau, v1.simd3(), v2.simd3());
+  return r;
+}
+
 #ifndef NDEBUG
 template<typename T>
 inline
@@ -507,11 +503,11 @@ operator<<(std::basic_ostream<char_type, traits_type>& s, const SGVec3<T>& v)
 inline
 SGVec3f
 toVec3f(const SGVec3d& v)
-{ return SGVec3f((float)v(0), (float)v(1), (float)v(2)); }
+{ SGVec3f f(v); return f; }
 
 inline
 SGVec3d
 toVec3d(const SGVec3f& v)
-{ return SGVec3d(v(0), v(1), v(2)); }
+{ SGVec3d d(v); return d; }
 
 #endif

simgear/math/SGVec4.hxx

@@ -20,6 +20,8 @@
 
 #include <iosfwd>
 
+#include <simgear/math/simd.hxx>
+
 /// 4D Vector Class
 template<typename T>
 class SGVec4 {
@@ -40,16 +42,16 @@ public:
   }
   /// Constructor. Initialize by the given values
   SGVec4(T x, T y, T z, T w)
-  { data()[0] = x; data()[1] = y; data()[2] = z; data()[3] = w; }
+  { _data = simd4_t<T,4>(x, y, z, w); }
   /// Constructor. Initialize by the content of a plain array,
   /// make sure it has at least 3 elements
   explicit SGVec4(const T* d)
-  { data()[0] = d[0]; data()[1] = d[1]; data()[2] = d[2]; data()[3] = d[3]; }
+  { _data = d ? simd4_t<T,4>(d) : simd4_t<T,4>(T(0)); }
   template<typename S>
   explicit SGVec4(const SGVec4<S>& d)
   { data()[0] = d[0]; data()[1] = d[1]; data()[2] = d[2]; data()[3] = d[3]; }
   explicit SGVec4(const SGVec3<T>& v3, const T& v4 = 0)
-  { data()[0] = v3[0]; data()[1] = v3[1]; data()[2] = v3[2]; data()[3] = v4; }
+  { _data = v3.simd3(); data()[3] = v4; }
 
   /// Access by index, the index is unchecked
   const T& operator()(unsigned i) const
@@ -92,25 +94,31 @@ public:
 
   /// Readonly raw storage interface
   const T (&data(void) const)[4]
-  { return _data; }
+  { return _data.ptr(); }
   /// Readonly raw storage interface
   T (&data(void))[4]
+  { return _data.ptr(); }
+  /// Readonly raw storage interface
+  const simd4_t<T,4> (&simd4(void) const)
+  { return _data; }
+  /// Readonly raw storage interface
+  simd4_t<T,4> (&simd4(void))
   { return _data; }
 
   /// Inplace addition
   SGVec4& operator+=(const SGVec4& v)
-  { data()[0]+=v(0);data()[1]+=v(1);data()[2]+=v(2);data()[3]+=v(3);return *this; }
+  { _data += v.simd4(); return *this; }
   /// Inplace subtraction
   SGVec4& operator-=(const SGVec4& v)
-  { data()[0]-=v(0);data()[1]-=v(1);data()[2]-=v(2);data()[3]-=v(3);return *this; }
+  { _data -= v.simd4(); return *this; }
   /// Inplace scalar multiplication
   template<typename S>
   SGVec4& operator*=(S s)
-  { data()[0] *= s; data()[1] *= s; data()[2] *= s; data()[3] *= s; return *this; }
+  { _data *= s; return *this; }
   /// Inplace scalar multiplication by 1/s
   template<typename S>
   SGVec4& operator/=(S s)
-  { return operator*=(1/T(s)); }
+  { _data*=(1/T(s)); return *this; }
 
   /// Return an all zero vector
   static SGVec4 zeros(void)
@@ -126,7 +134,7 @@ public:
   { return SGVec4(0, 0, 0, 1); }
 
 private:
-  T _data[4];
+  simd4_t<T,4> _data;
 };
 
 /// Unary +, do nothing ...
@@ -140,36 +148,36 @@ operator+(const SGVec4<T>& v)
 template<typename T>
 inline
 SGVec4<T>
-operator-(const SGVec4<T>& v)
-{ return SGVec4<T>(-v(0), -v(1), -v(2), -v(3)); }
+operator-(SGVec4<T> v)
+{ v *= -1; return v; }
 
 /// Binary +
 template<typename T>
 inline
 SGVec4<T>
-operator+(const SGVec4<T>& v1, const SGVec4<T>& v2)
-{ return SGVec4<T>(v1(0)+v2(0), v1(1)+v2(1), v1(2)+v2(2), v1(3)+v2(3)); }
+operator+(SGVec4<T> v1, const SGVec4<T>& v2)
+{ v1.simd4() += v2.simd4(); return v1; }
 
 /// Binary -
 template<typename T>
 inline
 SGVec4<T>
-operator-(const SGVec4<T>& v1, const SGVec4<T>& v2)
-{ return SGVec4<T>(v1(0)-v2(0), v1(1)-v2(1), v1(2)-v2(2), v1(3)-v2(3)); }
+operator-(SGVec4<T> v1, const SGVec4<T>& v2)
+{ v1.simd4() -= v2.simd4(); return v1; }
 
 /// Scalar multiplication
 template<typename S, typename T>
 inline
 SGVec4<T>
-operator*(S s, const SGVec4<T>& v)
-{ return SGVec4<T>(s*v(0), s*v(1), s*v(2), s*v(3)); }
+operator*(S s, SGVec4<T> v)
+{ v.simd4() *= s; return v; }
 
 /// Scalar multiplication
 template<typename S, typename T>
 inline
 SGVec4<T>
-operator*(const SGVec4<T>& v, S s)
-{ return SGVec4<T>(s*v(0), s*v(1), s*v(2), s*v(3)); }
+operator*(SGVec4<T> v, S s)
+{ v.simd4() *= s; return v; }
 
 /// multiplication as a multiplicator, that is assume that the first vector
 /// represents a 4x4 diagonal matrix with the diagonal elements in the vector.
@@ -177,72 +185,42 @@ operator*(const SGVec4<T>& v, S s)
 template<typename T>
 inline
 SGVec4<T>
-mult(const SGVec4<T>& v1, const SGVec4<T>& v2)
-{ return SGVec4<T>(v1(0)*v2(0), v1(1)*v2(1), v1(2)*v2(2), v1(3)*v2(3)); }
+mult(SGVec4<T> v1, const SGVec4<T>& v2)
+{ v1.simd4() *= v2.simd4(); return v1; }
 
 /// component wise min
 template<typename T>
 inline
 SGVec4<T>
-min(const SGVec4<T>& v1, const SGVec4<T>& v2)
-{
-  return SGVec4<T>(SGMisc<T>::min(v1(0), v2(0)),
-                   SGMisc<T>::min(v1(1), v2(1)),
-                   SGMisc<T>::min(v1(2), v2(2)),
-                   SGMisc<T>::min(v1(3), v2(3)));
-}
+min(SGVec4<T> v1, const SGVec4<T>& v2)
+{ v1.simd4() = simd4::min(v1.simd4(), v2.simd4()); return v1; }
 template<typename S, typename T>
 inline
 SGVec4<T>
-min(const SGVec4<T>& v, S s)
-{
-  return SGVec4<T>(SGMisc<T>::min(s, v(0)),
-                   SGMisc<T>::min(s, v(1)),
-                   SGMisc<T>::min(s, v(2)),
-                   SGMisc<T>::min(s, v(3)));
-}
+min(SGVec4<T> v, S s)
+{ v.simd4() = simd4::min(v.simd4(), simd4_t<T,4>(s)); return v; }
 template<typename S, typename T>
 inline
 SGVec4<T>
-min(S s, const SGVec4<T>& v)
-{
-  return SGVec4<T>(SGMisc<T>::min(s, v(0)),
-                   SGMisc<T>::min(s, v(1)),
-                   SGMisc<T>::min(s, v(2)),
-                   SGMisc<T>::min(s, v(3)));
-}
+min(S s, SGVec4<T> v)
+{ v.simd4() = simd4::min(v.simd4(), simd4_t<T,4>(s)); return v; }
 
 /// component wise max
 template<typename T>
 inline
 SGVec4<T>
-max(const SGVec4<T>& v1, const SGVec4<T>& v2)
-{
-  return SGVec4<T>(SGMisc<T>::max(v1(0), v2(0)),
-                   SGMisc<T>::max(v1(1), v2(1)),
-                   SGMisc<T>::max(v1(2), v2(2)),
-                   SGMisc<T>::max(v1(3), v2(3)));
-}
+max(SGVec4<T> v1, const SGVec4<T>& v2)
+{ v1.simd4() = simd4::max(v1.simd4(), v2.simd4()); return v1; }
 template<typename S, typename T>
 inline
 SGVec4<T>
-max(const SGVec4<T>& v, S s)
-{
-  return SGVec4<T>(SGMisc<T>::max(s, v(0)),
-                   SGMisc<T>::max(s, v(1)),
-                   SGMisc<T>::max(s, v(2)),
-                   SGMisc<T>::max(s, v(3)));
-}
+max(SGVec4<T> v, S s)
+{ v.simd4() = simd4::max(v.simd4(), simd4_t<T,4>(s)); return v; }
 template<typename S, typename T>
 inline
 SGVec4<T>
-max(S s, const SGVec4<T>& v)
-{
-  return SGVec4<T>(SGMisc<T>::max(s, v(0)),
-                   SGMisc<T>::max(s, v(1)),
-                   SGMisc<T>::max(s, v(2)),
-                   SGMisc<T>::max(s, v(3)));
-}
+max(S s, SGVec4<T> v)
+{ v.simd4() = simd4::max(v.simd4(), simd4_t<T,4>(s)); return v; }
 
 /// Add two vectors taking care of (integer) overflows. The values are limited
 /// to the respective minimum and maximum values.
@@ -262,36 +240,39 @@ template<typename T>
 inline
 T
 dot(const SGVec4<T>& v1, const SGVec4<T>& v2)
-{ return v1(0)*v2(0) + v1(1)*v2(1) + v1(2)*v2(2) + v1(3)*v2(3); }
+{ return simd4::dot(v1.simd4(), v2.simd4()); }
 
 /// The euclidean norm of the vector, that is what most people call length
 template<typename T>
 inline
 T
 norm(const SGVec4<T>& v)
-{ return sqrt(dot(v, v)); }
+{ return simd4::magnitude(v.simd4()); }
 
 /// The euclidean norm of the vector, that is what most people call length
 template<typename T>
 inline
 T
 length(const SGVec4<T>& v)
-{ return sqrt(dot(v, v)); }
+{ return simd4::magnitude(v.simd4()); }
 
 /// The 1-norm of the vector, this one is the fastest length function we
 /// can implement on modern cpu's
 template<typename T>
 inline
 T
-norm1(const SGVec4<T>& v)
-{ return fabs(v(0)) + fabs(v(1)) + fabs(v(2)) + fabs(v(3)); }
+norm1(SGVec4<T> v)
+{ v.simd4() = simd4::abs(v.simd4()); return (v(0)+v(1)+v(2)+v(3)); }
 
 /// The inf-norm of the vector
 template<typename T>
 inline
 T
-normI(const SGVec4<T>& v)
-{ return SGMisc<T>::max(fabs(v(0)), fabs(v(1)), fabs(v(2)), fabs(v(2))); }
+normI(SGVec4<T> v)
+{
+  v.simd4() = simd4::abs(v.simd4());
+  return SGMisc<T>::max(v(0), v(1), v(2), v(3));
+}
 
 /// The euclidean norm of the vector, that is what most people call length
 template<typename T>
@@ -389,14 +370,14 @@ template<typename T>
 inline
 T
 dist(const SGVec4<T>& v1, const SGVec4<T>& v2)
-{ return norm(v1 - v2); }
+{ return simd4::magnitude(v1.simd4() - v2.simd4()); }
 
 /// The squared euclidean distance of the two vectors
 template<typename T>
 inline
 T
-distSqr(const SGVec4<T>& v1, const SGVec4<T>& v2)
-{ SGVec4<T> tmp = v1 - v2; return dot(tmp, tmp); }
+distSqr(SGVec4<T> v1, const SGVec4<T>& v2)
+{ return simd4::magnitude2(v1.simd4() - v2.simd4()); }
 
 // calculate the projection of u along the direction of d.
 template<typename T>
@@ -404,12 +385,22 @@ inline
 SGVec4<T>
 projection(const SGVec4<T>& u, const SGVec4<T>& d)
 {
-  T denom = dot(d, d);
+  T denom = simd4::magnitude2(d.simd4());
   T ud = dot(u, d);
   if (SGLimits<T>::min() < denom) return u;
   else return d * (dot(u, d) / denom);
 }
 
+template<typename T>
+inline
+SGVec4<T>
+interpolate(T tau, const SGVec4<T>& v1, const SGVec4<T>& v2)
+{
+  SGVec4<T> r;
+  r.simd4() = simd4::interpolate(tau, v1.simd4(), v2.simd4());
+  return r;
+}
+
 #ifndef NDEBUG
 template<typename T>
 inline
@@ -431,11 +422,11 @@ operator<<(std::basic_ostream<char_type, traits_type>& s, const SGVec4<T>& v)
 inline
 SGVec4f
 toVec4f(const SGVec4d& v)
-{ return SGVec4f((float)v(0), (float)v(1), (float)v(2), (float)v(3)); }
+{ SGVec4f f(v); return f; }
 
 inline
 SGVec4d
 toVec4d(const SGVec4f& v)
-{ return SGVec4d(v(0), v(1), v(2), v(3)); }
+{ SGVec4d d(v); return d; }
 
 #endif

simgear/math/interpolater.cxx

@@ -31,7 +31,8 @@
 #include <string>
 
 #include <simgear/debug/logstream.hxx>
-#include <simgear/misc/sgstream.hxx>
+#include <simgear/io/iostreams/sgstream.hxx>
+#include <simgear/misc/sg_path.hxx>
 #include <simgear/props/props.hxx>
 
 #include "interpolater.hxx"
@@ -57,6 +58,28 @@ SGInterpTable::SGInterpTable( const std::string& file )
 {
     SG_LOG( SG_MATH, SG_INFO, "Initializing Interpolator for " << file );
 
+    sg_gzifstream in( SGPath::fromUtf8(file) );
+    if ( !in.is_open() ) {
+        SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << file );
+        return;
+    }
+
+    in >> skipcomment;
+    while ( in ) {
+        double ind, dep;
+        in >> ind >> dep;
+        in >> std::skipws;
+        _table[ind] = dep;
+    }
+}
+
+
+// Constructor -- loads the interpolation table from the specified
+// file
+SGInterpTable::SGInterpTable( const SGPath& file )
+{
+    SG_LOG( SG_MATH, SG_INFO, "Initializing Interpolator for " << file );
+
     sg_gzifstream in( file );
     if ( !in.is_open() ) {
         SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << file );

simgear/math/interpolater.hxx

@@ -41,6 +41,7 @@
 #include <string>
 
 class SGPropertyNode;
+class SGPath;
 
 /**
  * A class that provids a simple linear 2d interpolation lookup table.
@@ -69,7 +70,12 @@ public:
      */
     SGInterpTable( const std::string& file );
 
-
+    /**
+     * Constructor. Loads the interpolation table from the specified file.
+     * @param file name of interpolation file
+     */
+    SGInterpTable( const SGPath& path );
+    
     /**
      * Add an entry to the table, extending the table's length.
      *