new version: 2017.1.2

Fix issues with package upgrades on Windows.
2017-03-01 20:40:03 +01:00 · 2017-02-23 13:27:02 +00:00
695 changed files with 24879 additions and 110685 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -14,7 +14,3 @@ CTestTestfile.cmake
 install_manifest.txt
 build*
 Build
-CMakeLists.txt.user
-3rdparty/expat_2.2.6/
-nbproject
-compile_commands.json
--- a/3rdparty/CMakeLists.txt
+++ b/3rdparty/CMakeLists.txt
@@ -2,8 +2,8 @@ if (NOT SYSTEM_EXPAT)
 	add_subdirectory(expat)
 endif()

-if (NOT SYSTEM_UDNS)
+add_subdirectory(utf8)
+
+if (ENABLE_DNS AND NOT SYSTEM_UDNS)
 	add_subdirectory(udns)
 endif()
-
-add_subdirectory(tiny_gltf)
--- a/3rdparty/expat/CMakeLists.txt
+++ b/3rdparty/expat/CMakeLists.txt
@@ -1,24 +1,7 @@
-if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    check_cxx_source_compiles(
-        "#include <sys/random.h>
-        int main(void) {
-            return 0;
-        }
-        "
-        HAVE_GETRANDOM)
-
-    if (NOT HAVE_GETRANDOM)
-        # on older (GLibC < 2.25) fall back to /dev/urandom
-        set(XML_DEV_URANDOM 1)
-    else()
-        message(STATUS "Found <sys/random.h>")
-    endif()
-endif()
-

 configure_file (
    "${PROJECT_SOURCE_DIR}/3rdparty/expat/expat_config_cmake.in"
-    "${PROJECT_BINARY_DIR}/3rdparty/expat/simgear_expat_config.h"
+    "${PROJECT_BINARY_DIR}/3rdparty/expat/expat_config.h"
 )

 set(expat_sources 
@@ -43,24 +26,8 @@ set(expat_sources
        sg_expat_external.h 
 	)

-add_library(FGExpat STATIC ${expat_sources})
-
-target_include_directories(FGExpat BEFORE PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-    $<INSTALL_INTERFACE:include>)
-
-# for the config file above
-target_include_directories(FGExpat PRIVATE ${PROJECT_BINARY_DIR}/3rdparty/expat)
-
-target_compile_definitions(FGExpat PUBLIC HAVE_SIMGEAR_EXPAT_CONFIG_H XML_STATIC)
-
-# look like Expat found by find()
-add_library(EXPAT::EXPAT ALIAS FGExpat)
-
-# in the non-shared case, we need to export these as well
-if (NOT SIMGEAR_SHARED)
-    install(TARGETS FGExpat
-        EXPORT SimGearTargets
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-endif()
+foreach(s ${expat_sources})
+	set_property(GLOBAL
+		APPEND PROPERTY LOCAL_EXPAT_SOURCES 
+        "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+endforeach()
--- a/3rdparty/expat/ascii.h
+++ b/3rdparty/expat/ascii.h
@@ -1,36 +1,5 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1999-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2007      Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
-
-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
-
-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
 */

 #define ASCII_A 0x41
--- a/3rdparty/expat/asciitab.h
+++ b/3rdparty/expat/asciitab.h
@@ -1,66 +1,62 @@
 /*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/

-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.

-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
+The Original Code is expat.

-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.

-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
 */

 /* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
-    /* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
-    /* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
-    /* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
-    /* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
-    /* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
-    /* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-    /* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-    /* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
-    /* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
-    /* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-    /* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-    /* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
-    /* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
-    /* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-    /* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-    /* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-    /* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+/* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
+/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
--- a/3rdparty/expat/expat_config_cmake.in
+++ b/3rdparty/expat/expat_config_cmake.in
@@ -10,14 +10,6 @@
    #undef WIN32_LEAN_AND_MEAN
 #endif

-#cmakedefine HAVE_GETRANDOM
-#cmakedefine XML_DEV_URANDOM
-
-// we can assume > 10.7 macOS so always set this
-#ifdef __APPLE__
-    #define HAVE_ARC4RANDOM_BUF
-#endif
-
 /* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
 #define BYTEORDER  1234

--- a/3rdparty/expat/iasciitab.h
+++ b/3rdparty/expat/iasciitab.h
@@ -1,67 +1,63 @@
 /*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/

-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.

-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
+The Original Code is expat.

-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.

-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
 */

 /* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
 /* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
-    /* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
-    /* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
-    /* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
-    /* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
-    /* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
-    /* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-    /* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-    /* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
-    /* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
-    /* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-    /* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-    /* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
-    /* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
-    /* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-    /* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-    /* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-    /* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+/* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
+/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
--- a/3rdparty/expat/internal.h
+++ b/3rdparty/expat/internal.h
@@ -18,42 +18,9 @@

   Note: Use of these macros is based on judgement, not hard rules,
         and therefore subject to change.
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 2002-2003 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2003      Greg Stein <gstein@users.sourceforge.net>
-   Copyright (c) 2016-2021 Sebastian Pipping <sebastian@pipping.org>
-   Copyright (c) 2018      Yury Gribov <tetra2005@gmail.com>
-   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
-
-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
-
-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

-#if defined(__GNUC__) && defined(__i386__) && ! defined(__MINGW32__)
+#if defined(__GNUC__) && defined(__i386__) && !defined(__MINGW32__)
 /* We'll use this version by default only where we know it helps.

   regparm() generates warnings on Solaris boxes.   See SF bug #692878.
@@ -63,8 +30,8 @@
   #define FASTCALL __attribute__((stdcall, regparm(3)))
   and let's try this:
 */
-#  define FASTCALL __attribute__((regparm(3)))
-#  define PTRFASTCALL __attribute__((regparm(3)))
+#define FASTCALL __attribute__((regparm(3)))
+#define PTRFASTCALL __attribute__((regparm(3)))
 #endif

 /* Using __fastcall seems to have an unexpected negative effect under
@@ -78,86 +45,29 @@
 /* Make sure all of these are defined if they aren't already. */

 #ifndef FASTCALL
-#  define FASTCALL
+#define FASTCALL
 #endif

 #ifndef PTRCALL
-#  define PTRCALL
+#define PTRCALL
 #endif

 #ifndef PTRFASTCALL
-#  define PTRFASTCALL
+#define PTRFASTCALL
 #endif

 #ifndef XML_MIN_SIZE
-#  if ! defined(__cplusplus) && ! defined(inline)
-#    ifdef __GNUC__
-#      define inline __inline
-#    endif /* __GNUC__ */
-#  endif
+#if !defined(__cplusplus) && !defined(inline)
+#ifdef __GNUC__
+#define inline __inline
+#endif /* __GNUC__ */
+#endif
 #endif /* XML_MIN_SIZE */

 #ifdef __cplusplus
-#  define inline inline
+#define inline inline
 #else
-#  ifndef inline
-#    define inline
-#  endif
+#ifndef inline
+#define inline
 #endif
-
-#include <limits.h> // ULONG_MAX
-
-#if defined(_WIN32) && ! defined(__USE_MINGW_ANSI_STDIO)
-#  define EXPAT_FMT_ULL(midpart) "%" midpart "I64u"
-#  if defined(_WIN64) // Note: modifiers "td" and "zu" do not work for MinGW
-#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "I64d"
-#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "I64u"
-#  else
-#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "d"
-#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "u"
-#  endif
-#else
-#  define EXPAT_FMT_ULL(midpart) "%" midpart "llu"
-#  if ! defined(ULONG_MAX)
-#    error Compiler did not define ULONG_MAX for us
-#  elif ULONG_MAX == 18446744073709551615u // 2^64-1
-#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "ld"
-#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "lu"
-#  else
-#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "d"
-#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "u"
-#  endif
-#endif
-
-#ifndef UNUSED_P
-#  define UNUSED_P(p) (void)p
-#endif
-
-/* NOTE BEGIN If you ever patch these defaults to greater values
-              for non-attack XML payload in your environment,
-              please file a bug report with libexpat.  Thank you!
-*/
-#define EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT   \
-  100.0f
-#define EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT    \
-  8388608 // 8 MiB, 2^23
-/* NOTE END */
-
-#include "sg_expat.h" // so we can use type XML_Parser below
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void _INTERNAL_trim_to_complete_utf8_characters(const char *from,
-                                                const char **fromLimRef);
-
-#if defined(XML_DTD)
-unsigned long long testingAccountingGetCountBytesDirect(XML_Parser parser);
-unsigned long long testingAccountingGetCountBytesIndirect(XML_Parser parser);
-const char *unsignedCharToPrintable(unsigned char c);
-#endif
-
-#ifdef __cplusplus
-}
 #endif
--- a/3rdparty/expat/latin1tab.h
+++ b/3rdparty/expat/latin1tab.h
@@ -1,66 +1,62 @@
 /*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/

-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.

-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
+The Original Code is expat.

-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.

-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
 */

 /* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
-    /* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
-    /* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
-    /* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-    /* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-    /* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+/* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
+/* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+/* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
--- a/3rdparty/expat/nametab.h
+++ b/3rdparty/expat/nametab.h
@@ -1,136 +1,150 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 2000 Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2017 Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
-
-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
-
-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
 static const unsigned namingBitmap[] = {
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x04000000,
-    0x87FFFFFE, 0x07FFFFFE, 0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
-    0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-    0xFFFFE00F, 0xFC31FFFF, 0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
-    0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
-    0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF, 0xFFFF0003, 0xFFFFFFFF,
-    0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
-    0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF, 0x00000000, 0x07FFFFFE,
-    0x000007FE, 0xFFFE0000, 0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
-    0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003, 0xFFF99FE0, 0x03C5FDFF,
-    0xB0000000, 0x00030003, 0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
-    0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001, 0xFFF99FE0, 0x23CDFDFF,
-    0xB0000000, 0x00000003, 0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
-    0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003, 0xFFFDDFE0, 0x03EFFDFF,
-    0x40000000, 0x00000003, 0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFE, 0x000D7FFF,
-    0x0000003F, 0x00000000, 0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
-    0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-    0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF, 0x0007DAED, 0x50000000,
-    0x82315001, 0x002C62AB, 0x40000000, 0xF580C900, 0x00000007, 0x02010800,
-    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0FFFFFFF, 0xFFFFFFFF,
-    0xFFFFFFFF, 0x03FFFFFF, 0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
-    0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF, 0x00000000, 0x00004C40,
-    0x00000000, 0x00000000, 0x00000007, 0x00000000, 0x00000000, 0x00000000,
-    0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF, 0x001FFFFF, 0xFFFFFFFE,
-    0xFFFFFFFF, 0x07FFFFFF, 0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF,
-    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
-    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000000F,
-    0x00000000, 0x00000000, 0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
-    0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF, 0x00FFFFFF, 0x00000000,
-    0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
-    0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003, 0xFFFFD7C0, 0xFFFFFFFB,
-    0x547F7FFF, 0x000FFFFD, 0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
-    0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000,
-    0x027FFFFF, 0xFFFFFFFE, 0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
-    0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF, 0xFFFFFFFF, 0x7CFFFFFF,
-    0xFFEF7FFF, 0x03FF3DFF, 0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
-    0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF, 0xFFF987E4, 0xD36DFDFF,
-    0x5E003987, 0x001FFFC0, 0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
-    0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3, 0xD63DC7EC, 0xC3BFC718,
-    0x00803DC7, 0x0000FF80, 0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
-    0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3, 0xFFFDDFEC, 0xC3FFFDFF,
-    0x00803DCF, 0x0000FFC3, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-    0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000, 0xFEF02596, 0x3BFF6CAE,
-    0x03FF3F5F, 0x00000000, 0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
-    0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
-    0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF, 0x661FFFFF, 0xFFFFFFFE,
-    0xFFFFFFFF, 0x77FFFFFF,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0x00000000, 0x04000000, 0x87FFFFFE, 0x07FFFFFE,
+0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
+0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFE00F, 0xFC31FFFF,
+0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
+0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
+0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
+0xFFFF0003, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
+0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
+0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF,
+0x00000000, 0x07FFFFFE, 0x000007FE, 0xFFFE0000,
+0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
+0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003,
+0xFFF99FE0, 0x03C5FDFF, 0xB0000000, 0x00030003,
+0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
+0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001,
+0xFFF99FE0, 0x23CDFDFF, 0xB0000000, 0x00000003,
+0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
+0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003,
+0xFFFDDFE0, 0x03EFFDFF, 0x40000000, 0x00000003,
+0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFE, 0x000D7FFF, 0x0000003F, 0x00000000,
+0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
+0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF,
+0x0007DAED, 0x50000000, 0x82315001, 0x002C62AB,
+0x40000000, 0xF580C900, 0x00000007, 0x02010800,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0x0FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x03FFFFFF,
+0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
+0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF,
+0x00000000, 0x00004C40, 0x00000000, 0x00000000,
+0x00000007, 0x00000000, 0x00000000, 0x00000000,
+0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF,
+0x001FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x07FFFFFF,
+0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0xFFFFFFFF, 0x0000000F, 0x00000000, 0x00000000,
+0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
+0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF,
+0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
+0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003,
+0xFFFFD7C0, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
+0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
+0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
+0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
+0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
+0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF,
+0xFFFFFFFF, 0x7CFFFFFF, 0xFFEF7FFF, 0x03FF3DFF,
+0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
+0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF,
+0xFFF987E4, 0xD36DFDFF, 0x5E003987, 0x001FFFC0,
+0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
+0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3,
+0xD63DC7EC, 0xC3BFC718, 0x00803DC7, 0x0000FF80,
+0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
+0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3,
+0xFFFDDFEC, 0xC3FFFDFF, 0x00803DCF, 0x0000FFC3,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000,
+0xFEF02596, 0x3BFF6CAE, 0x03FF3F5F, 0x00000000,
+0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
+0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
+0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF,
+0x661FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x77FFFFFF,
 };
 static const unsigned char nmstrtPages[] = {
-    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x09, 0x0A, 0x0B,
-    0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x00, 0x14, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
+0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00,
+0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
+0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 static const unsigned char namePages[] = {
-    0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00, 0x00, 0x1F, 0x20, 0x21,
-    0x22, 0x23, 0x24, 0x25, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x26, 0x14, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
+0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00,
+0x00, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
+0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
+0x26, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
--- a/3rdparty/expat/sg_expat.h
+++ b/3rdparty/expat/sg_expat.h
@@ -1,45 +1,19 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2000-2005 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
-   Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2016-2022 Sebastian Pipping <sebastian@pipping.org>
-   Copyright (c) 2016      Cristian Rodríguez <crrodriguez@opensuse.org>
-   Copyright (c) 2016      Thomas Beutlich <tc@tbeu.de>
-   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
-
-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
-
-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
 */

 #ifndef Expat_INCLUDED
 #define Expat_INCLUDED 1

+#ifdef __VMS
+/*      0        1         2         3      0        1         2         3
+        1234567890123456789012345678901     1234567890123456789012345678901 */
+#define XML_SetProcessingInstructionHandler XML_SetProcessingInstrHandler
+#define XML_SetUnparsedEntityDeclHandler    XML_SetUnparsedEntDeclHandler
+#define XML_SetStartNamespaceDeclHandler    XML_SetStartNamespcDeclHandler
+#define XML_SetExternalEntityRefHandlerArg  XML_SetExternalEntRefHandlerArg
+#endif
+
 #include <stdlib.h>
 #include "sg_expat_external.h"

@@ -50,9 +24,10 @@ extern "C" {
 struct XML_ParserStruct;
 typedef struct XML_ParserStruct *XML_Parser;

+/* Should this be defined using stdbool.h when C99 is available? */
 typedef unsigned char XML_Bool;
-#define XML_TRUE ((XML_Bool)1)
-#define XML_FALSE ((XML_Bool)0)
+#define XML_TRUE   ((XML_Bool) 1)
+#define XML_FALSE  ((XML_Bool) 0)

 /* The XML_Status enum gives the possible return values for several
   API functions.  The preprocessor #defines are included so this
@@ -120,13 +95,7 @@ enum XML_Error {
  /* Added in 2.0. */
  XML_ERROR_RESERVED_PREFIX_XML,
  XML_ERROR_RESERVED_PREFIX_XMLNS,
-  XML_ERROR_RESERVED_NAMESPACE_URI,
-  /* Added in 2.2.1. */
-  XML_ERROR_INVALID_ARGUMENT,
-  /* Added in 2.3.0. */
-  XML_ERROR_NO_BUFFER,
-  /* Added in 2.4.0. */
-  XML_ERROR_AMPLIFICATION_LIMIT_BREACH
+  XML_ERROR_RESERVED_NAMESPACE_URI
 };

 enum XML_Content_Type {
@@ -166,23 +135,25 @@ enum XML_Content_Quant {
 typedef struct XML_cp XML_Content;

 struct XML_cp {
-  enum XML_Content_Type type;
-  enum XML_Content_Quant quant;
-  XML_Char *name;
-  unsigned int numchildren;
-  XML_Content *children;
+  enum XML_Content_Type         type;
+  enum XML_Content_Quant        quant;
+  XML_Char *                    name;
+  unsigned int                  numchildren;
+  XML_Content *                 children;
 };

+
 /* This is called for an element declaration. See above for
   description of the model argument. It's the caller's responsibility
   to free model when finished with it.
 */
-typedef void(XMLCALL *XML_ElementDeclHandler)(void *userData,
-                                              const XML_Char *name,
-                                              XML_Content *model);
+typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData,
+                                                const XML_Char *name,
+                                                XML_Content *model);

 XMLPARSEAPI(void)
-XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl);
+XML_SetElementDeclHandler(XML_Parser parser,
+                          XML_ElementDeclHandler eldecl);

 /* The Attlist declaration handler is called for *each* attribute. So
   a single Attlist declaration with multiple attributes declared will
@@ -192,12 +163,17 @@ XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl);
   value will be NULL in the case of "#REQUIRED". If "isrequired" is
   true and default is non-NULL, then this is a "#FIXED" default.
 */
-typedef void(XMLCALL *XML_AttlistDeclHandler)(
-    void *userData, const XML_Char *elname, const XML_Char *attname,
-    const XML_Char *att_type, const XML_Char *dflt, int isrequired);
+typedef void (XMLCALL *XML_AttlistDeclHandler) (
+                                    void            *userData,
+                                    const XML_Char  *elname,
+                                    const XML_Char  *attname,
+                                    const XML_Char  *att_type,
+                                    const XML_Char  *dflt,
+                                    int              isrequired);

 XMLPARSEAPI(void)
-XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl);
+XML_SetAttlistDeclHandler(XML_Parser parser,
+                          XML_AttlistDeclHandler attdecl);

 /* The XML declaration handler is called for *both* XML declarations
   and text declarations. The way to distinguish is that the version
@@ -207,13 +183,15 @@ XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl);
   was no standalone parameter in the declaration, that it was given
   as no, or that it was given as yes.
 */
-typedef void(XMLCALL *XML_XmlDeclHandler)(void *userData,
-                                          const XML_Char *version,
-                                          const XML_Char *encoding,
-                                          int standalone);
+typedef void (XMLCALL *XML_XmlDeclHandler) (void           *userData,
+                                            const XML_Char *version,
+                                            const XML_Char *encoding,
+                                            int             standalone);

 XMLPARSEAPI(void)
-XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler xmldecl);
+XML_SetXmlDeclHandler(XML_Parser parser,
+                      XML_XmlDeclHandler xmldecl);
+

 typedef struct {
  void *(*malloc_fcn)(size_t size);
@@ -241,6 +219,7 @@ XML_ParserCreate(const XML_Char *encoding);
 XMLPARSEAPI(XML_Parser)
 XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);

+
 /* Constructs a new parser using the memory management suite referred to
   by memsuite. If memsuite is NULL, then use the standard library memory
   suite. If namespaceSeparator is non-NULL it creates a parser with
@@ -256,7 +235,7 @@ XML_ParserCreate_MM(const XML_Char *encoding,
                    const XML_Char *namespaceSeparator);

 /* Prepare a parser object to be re-used.  This is particularly
-   valuable when memory allocation overhead is disproportionately high,
+   valuable when memory allocation overhead is disproportionatly high,
   such as when a large number of small documnents need to be parsed.
   All handlers are cleared from the parser, except for the
   unknownEncodingHandler. The parser's external state is re-initialized
@@ -270,27 +249,31 @@ XML_ParserReset(XML_Parser parser, const XML_Char *encoding);
 /* atts is array of name/value pairs, terminated by 0;
   names and values are 0 terminated.
 */
-typedef void(XMLCALL *XML_StartElementHandler)(void *userData,
-                                               const XML_Char *name,
-                                               const XML_Char **atts);
+typedef void (XMLCALL *XML_StartElementHandler) (void *userData,
+                                                 const XML_Char *name,
+                                                 const XML_Char **atts);
+
+typedef void (XMLCALL *XML_EndElementHandler) (void *userData,
+                                               const XML_Char *name);

-typedef void(XMLCALL *XML_EndElementHandler)(void *userData,
-                                             const XML_Char *name);

 /* s is not 0 terminated. */
-typedef void(XMLCALL *XML_CharacterDataHandler)(void *userData,
-                                                const XML_Char *s, int len);
+typedef void (XMLCALL *XML_CharacterDataHandler) (void *userData,
+                                                  const XML_Char *s,
+                                                  int len);

 /* target and data are 0 terminated */
-typedef void(XMLCALL *XML_ProcessingInstructionHandler)(void *userData,
-                                                        const XML_Char *target,
-                                                        const XML_Char *data);
+typedef void (XMLCALL *XML_ProcessingInstructionHandler) (
+                                                void *userData,
+                                                const XML_Char *target,
+                                                const XML_Char *data);

 /* data is 0 terminated */
-typedef void(XMLCALL *XML_CommentHandler)(void *userData, const XML_Char *data);
+typedef void (XMLCALL *XML_CommentHandler) (void *userData,
+                                            const XML_Char *data);

-typedef void(XMLCALL *XML_StartCdataSectionHandler)(void *userData);
-typedef void(XMLCALL *XML_EndCdataSectionHandler)(void *userData);
+typedef void (XMLCALL *XML_StartCdataSectionHandler) (void *userData);
+typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData);

 /* This is called for any characters in the XML document for which
   there is no applicable handler.  This includes both characters that
@@ -305,23 +288,25 @@ typedef void(XMLCALL *XML_EndCdataSectionHandler)(void *userData);
   default handler: for example, a comment might be split between
   multiple calls.
 */
-typedef void(XMLCALL *XML_DefaultHandler)(void *userData, const XML_Char *s,
-                                          int len);
+typedef void (XMLCALL *XML_DefaultHandler) (void *userData,
+                                            const XML_Char *s,
+                                            int len);

 /* This is called for the start of the DOCTYPE declaration, before
   any DTD or internal subset is parsed.
 */
-typedef void(XMLCALL *XML_StartDoctypeDeclHandler)(void *userData,
-                                                   const XML_Char *doctypeName,
-                                                   const XML_Char *sysid,
-                                                   const XML_Char *pubid,
-                                                   int has_internal_subset);
+typedef void (XMLCALL *XML_StartDoctypeDeclHandler) (
+                                            void *userData,
+                                            const XML_Char *doctypeName,
+                                            const XML_Char *sysid,
+                                            const XML_Char *pubid,
+                                            int has_internal_subset);

 /* This is called for the start of the DOCTYPE declaration when the
   closing > is encountered, but after processing any external
   subset.
 */
-typedef void(XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
+typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);

 /* This is called for entity declarations. The is_parameter_entity
   argument will be non-zero if the entity is a parameter entity, zero
@@ -329,7 +314,7 @@ typedef void(XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);

   For internal entities (<!ENTITY foo "bar">), value will
   be non-NULL and systemId, publicID, and notationName will be NULL.
-   The value string is NOT null-terminated; the length is provided in
+   The value string is NOT nul-terminated; the length is provided in
   the value_length argument. Since it is legal to have zero-length
   values, do not use this argument to test for internal entities.

@@ -341,17 +326,23 @@ typedef void(XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
   Note that is_parameter_entity can't be changed to XML_Bool, since
   that would break binary compatibility.
 */
-typedef void(XMLCALL *XML_EntityDeclHandler)(
-    void *userData, const XML_Char *entityName, int is_parameter_entity,
-    const XML_Char *value, int value_length, const XML_Char *base,
-    const XML_Char *systemId, const XML_Char *publicId,
-    const XML_Char *notationName);
+typedef void (XMLCALL *XML_EntityDeclHandler) (
+                              void *userData,
+                              const XML_Char *entityName,
+                              int is_parameter_entity,
+                              const XML_Char *value,
+                              int value_length,
+                              const XML_Char *base,
+                              const XML_Char *systemId,
+                              const XML_Char *publicId,
+                              const XML_Char *notationName);

 XMLPARSEAPI(void)
-XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler);
+XML_SetEntityDeclHandler(XML_Parser parser,
+                         XML_EntityDeclHandler handler);

 /* OBSOLETE -- OBSOLETE -- OBSOLETE
-   This handler has been superseded by the EntityDeclHandler above.
+   This handler has been superceded by the EntityDeclHandler above.
   It is provided here for backward compatibility.

   This is called for a declaration of an unparsed (NDATA) entity.
@@ -359,20 +350,24 @@ XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler);
   entityName, systemId and notationName arguments will never be
   NULL. The other arguments may be.
 */
-typedef void(XMLCALL *XML_UnparsedEntityDeclHandler)(
-    void *userData, const XML_Char *entityName, const XML_Char *base,
-    const XML_Char *systemId, const XML_Char *publicId,
-    const XML_Char *notationName);
+typedef void (XMLCALL *XML_UnparsedEntityDeclHandler) (
+                                    void *userData,
+                                    const XML_Char *entityName,
+                                    const XML_Char *base,
+                                    const XML_Char *systemId,
+                                    const XML_Char *publicId,
+                                    const XML_Char *notationName);

 /* This is called for a declaration of notation.  The base argument is
   whatever was set by XML_SetBase. The notationName will never be
   NULL.  The other arguments can be.
 */
-typedef void(XMLCALL *XML_NotationDeclHandler)(void *userData,
-                                               const XML_Char *notationName,
-                                               const XML_Char *base,
-                                               const XML_Char *systemId,
-                                               const XML_Char *publicId);
+typedef void (XMLCALL *XML_NotationDeclHandler) (
+                                    void *userData,
+                                    const XML_Char *notationName,
+                                    const XML_Char *base,
+                                    const XML_Char *systemId,
+                                    const XML_Char *publicId);

 /* When namespace processing is enabled, these are called once for
   each namespace declaration. The call to the start and end element
@@ -380,12 +375,14 @@ typedef void(XMLCALL *XML_NotationDeclHandler)(void *userData,
   declaration handlers. For an xmlns attribute, prefix will be
   NULL.  For an xmlns="" attribute, uri will be NULL.
 */
-typedef void(XMLCALL *XML_StartNamespaceDeclHandler)(void *userData,
-                                                     const XML_Char *prefix,
-                                                     const XML_Char *uri);
+typedef void (XMLCALL *XML_StartNamespaceDeclHandler) (
+                                    void *userData,
+                                    const XML_Char *prefix,
+                                    const XML_Char *uri);

-typedef void(XMLCALL *XML_EndNamespaceDeclHandler)(void *userData,
-                                                   const XML_Char *prefix);
+typedef void (XMLCALL *XML_EndNamespaceDeclHandler) (
+                                    void *userData,
+                                    const XML_Char *prefix);

 /* This is called if the document is not standalone, that is, it has an
   external subset or a reference to a parameter entity, but does not
@@ -396,7 +393,7 @@ typedef void(XMLCALL *XML_EndNamespaceDeclHandler)(void *userData,
   conditions above this handler will only be called if the referenced
   entity was actually read.
 */
-typedef int(XMLCALL *XML_NotStandaloneHandler)(void *userData);
+typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData);

 /* This is called for a reference to an external parsed general
   entity.  The referenced entity is not automatically parsed.  The
@@ -432,11 +429,12 @@ typedef int(XMLCALL *XML_NotStandaloneHandler)(void *userData);
   Note that unlike other handlers the first argument is the parser,
   not userData.
 */
-typedef int(XMLCALL *XML_ExternalEntityRefHandler)(XML_Parser parser,
-                                                   const XML_Char *context,
-                                                   const XML_Char *base,
-                                                   const XML_Char *systemId,
-                                                   const XML_Char *publicId);
+typedef int (XMLCALL *XML_ExternalEntityRefHandler) (
+                                    XML_Parser parser,
+                                    const XML_Char *context,
+                                    const XML_Char *base,
+                                    const XML_Char *systemId,
+                                    const XML_Char *publicId);

 /* This is called in two situations:
   1) An entity reference is encountered for which no declaration
@@ -448,9 +446,10 @@ typedef int(XMLCALL *XML_ExternalEntityRefHandler)(XML_Parser parser,
         the event would be out of sync with the reporting of the
         declarations or attribute values
 */
-typedef void(XMLCALL *XML_SkippedEntityHandler)(void *userData,
-                                                const XML_Char *entityName,
-                                                int is_parameter_entity);
+typedef void (XMLCALL *XML_SkippedEntityHandler) (
+                                    void *userData,
+                                    const XML_Char *entityName,
+                                    int is_parameter_entity);

 /* This structure is filled in by the XML_UnknownEncodingHandler to
   provide information to the parser about encodings that are unknown
@@ -507,8 +506,8 @@ typedef void(XMLCALL *XML_SkippedEntityHandler)(void *userData,
 typedef struct {
  int map[256];
  void *data;
-  int(XMLCALL *convert)(void *data, const char *s);
-  void(XMLCALL *release)(void *data);
+  int (XMLCALL *convert)(void *data, const char *s);
+  void (XMLCALL *release)(void *data);
 } XML_Encoding;

 /* This is called for an encoding that is unknown to the parser.
@@ -524,21 +523,25 @@ typedef struct {
   Otherwise it must return XML_STATUS_ERROR.

   If info does not describe a suitable encoding, then the parser will
-   return an XML_ERROR_UNKNOWN_ENCODING error.
+   return an XML_UNKNOWN_ENCODING error.
 */
-typedef int(XMLCALL *XML_UnknownEncodingHandler)(void *encodingHandlerData,
-                                                 const XML_Char *name,
-                                                 XML_Encoding *info);
+typedef int (XMLCALL *XML_UnknownEncodingHandler) (
+                                    void *encodingHandlerData,
+                                    const XML_Char *name,
+                                    XML_Encoding *info);

 XMLPARSEAPI(void)
-XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
+XML_SetElementHandler(XML_Parser parser,
+                      XML_StartElementHandler start,
                      XML_EndElementHandler end);

 XMLPARSEAPI(void)
-XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler handler);
+XML_SetStartElementHandler(XML_Parser parser,
+                           XML_StartElementHandler handler);

 XMLPARSEAPI(void)
-XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler handler);
+XML_SetEndElementHandler(XML_Parser parser,
+                         XML_EndElementHandler handler);

 XMLPARSEAPI(void)
 XML_SetCharacterDataHandler(XML_Parser parser,
@@ -548,7 +551,8 @@ XMLPARSEAPI(void)
 XML_SetProcessingInstructionHandler(XML_Parser parser,
                                    XML_ProcessingInstructionHandler handler);
 XMLPARSEAPI(void)
-XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler);
+XML_SetCommentHandler(XML_Parser parser,
+                      XML_CommentHandler handler);

 XMLPARSEAPI(void)
 XML_SetCdataSectionHandler(XML_Parser parser,
@@ -568,17 +572,20 @@ XML_SetEndCdataSectionHandler(XML_Parser parser,
   default handler, or to the skipped entity handler, if one is set.
 */
 XMLPARSEAPI(void)
-XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler);
+XML_SetDefaultHandler(XML_Parser parser,
+                      XML_DefaultHandler handler);

 /* This sets the default handler but does not inhibit expansion of
   internal entities.  The entity reference will not be passed to the
   default handler.
 */
 XMLPARSEAPI(void)
-XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler);
+XML_SetDefaultHandlerExpand(XML_Parser parser,
+                            XML_DefaultHandler handler);

 XMLPARSEAPI(void)
-XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
+XML_SetDoctypeDeclHandler(XML_Parser parser,
+                          XML_StartDoctypeDeclHandler start,
                          XML_EndDoctypeDeclHandler end);

 XMLPARSEAPI(void)
@@ -586,14 +593,16 @@ XML_SetStartDoctypeDeclHandler(XML_Parser parser,
                               XML_StartDoctypeDeclHandler start);

 XMLPARSEAPI(void)
-XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end);
+XML_SetEndDoctypeDeclHandler(XML_Parser parser,
+                             XML_EndDoctypeDeclHandler end);

 XMLPARSEAPI(void)
 XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
                                 XML_UnparsedEntityDeclHandler handler);

 XMLPARSEAPI(void)
-XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler);
+XML_SetNotationDeclHandler(XML_Parser parser,
+                           XML_NotationDeclHandler handler);

 XMLPARSEAPI(void)
 XML_SetNamespaceDeclHandler(XML_Parser parser,
@@ -621,7 +630,8 @@ XML_SetExternalEntityRefHandler(XML_Parser parser,
   instead of the parser object.
 */
 XMLPARSEAPI(void)
-XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg);
+XML_SetExternalEntityRefHandlerArg(XML_Parser parser,
+                                   void *arg);

 XMLPARSEAPI(void)
 XML_SetSkippedEntityHandler(XML_Parser parser,
@@ -696,11 +706,11 @@ XML_UseParserAsHandlerArg(XML_Parser parser);
     be called, despite an external subset being parsed.
   Note: If XML_DTD is not defined when Expat is compiled, returns
     XML_ERROR_FEATURE_REQUIRES_XML_DTD.
-   Note: If parser == NULL, returns XML_ERROR_INVALID_ARGUMENT.
 */
 XMLPARSEAPI(enum XML_Error)
 XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);

+
 /* Sets the base to be used for resolving relative URIs in system
   identifiers in declarations.  Resolving relative identifiers is
   left to the application: this value will be passed through as the
@@ -718,17 +728,16 @@ XML_GetBase(XML_Parser parser);
 /* Returns the number of the attribute/value pairs passed in last call
   to the XML_StartElementHandler that were specified in the start-tag
   rather than defaulted. Each attribute/value pair counts as 2; thus
-   this corresponds to an index into the atts array passed to the
-   XML_StartElementHandler.  Returns -1 if parser == NULL.
+   this correspondds to an index into the atts array passed to the
+   XML_StartElementHandler.
 */
 XMLPARSEAPI(int)
 XML_GetSpecifiedAttributeCount(XML_Parser parser);

 /* Returns the index of the ID attribute passed in the last call to
-   XML_StartElementHandler, or -1 if there is no ID attribute or
-   parser == NULL.  Each attribute/value pair counts as 2; thus this
-   corresponds to an index into the atts array passed to the
-   XML_StartElementHandler.
+   XML_StartElementHandler, or -1 if there is no ID attribute.  Each
+   attribute/value pair counts as 2; thus this correspondds to an
+   index into the atts array passed to the XML_StartElementHandler.
 */
 XMLPARSEAPI(int)
 XML_GetIdAttributeIndex(XML_Parser parser);
@@ -740,10 +749,10 @@ XML_GetIdAttributeIndex(XML_Parser parser);
   info->valueEnd - info->valueStart = 4 bytes.
 */
 typedef struct {
-  XML_Index nameStart;  /* Offset to beginning of the attribute name. */
-  XML_Index nameEnd;    /* Offset after the attribute name's last byte. */
-  XML_Index valueStart; /* Offset to beginning of the attribute value. */
-  XML_Index valueEnd;   /* Offset after the attribute value's last byte. */
+  XML_Index  nameStart;  /* Offset to beginning of the attribute name. */
+  XML_Index  nameEnd;    /* Offset after the attribute name's last byte. */
+  XML_Index  valueStart; /* Offset to beginning of the attribute value. */
+  XML_Index  valueEnd;   /* Offset after the attribute value's last byte. */
 } XML_AttrInfo;

 /* Returns an array of XML_AttrInfo structures for the attribute/value pairs
@@ -779,20 +788,20 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
   (resumable = 0) an already suspended parser. Some call-backs may
   still follow because they would otherwise get lost. Examples:
   - endElementHandler() for empty elements when stopped in
-     startElementHandler(),
-   - endNameSpaceDeclHandler() when stopped in endElementHandler(),
+     startElementHandler(), 
+   - endNameSpaceDeclHandler() when stopped in endElementHandler(), 
   and possibly others.

   Can be called from most handlers, including DTD related call-backs,
   except when parsing an external parameter entity and resumable != 0.
   Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.
-   Possible error codes:
+   Possible error codes: 
   - XML_ERROR_SUSPENDED: when suspending an already suspended parser.
   - XML_ERROR_FINISHED: when the parser has already finished.
   - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.

-   When resumable != 0 (true) then parsing is suspended, that is,
-   XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.
+   When resumable != 0 (true) then parsing is suspended, that is, 
+   XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED. 
   Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()
   return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.

@@ -803,7 +812,7 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
   the externalEntityRefHandler() to call XML_StopParser() on the parent
   parser (recursively), if one wants to stop parsing altogether.

-   When suspended, parsing can be resumed by calling XML_ResumeParser().
+   When suspended, parsing can be resumed by calling XML_ResumeParser(). 
 */
 XMLPARSEAPI(enum XML_Status)
 XML_StopParser(XML_Parser parser, XML_Bool resumable);
@@ -811,7 +820,7 @@ XML_StopParser(XML_Parser parser, XML_Bool resumable);
 /* Resumes parsing after it has been suspended with XML_StopParser().
   Must not be called from within a handler call-back. Returns same
   status codes as XML_Parse() or XML_ParseBuffer().
-   Additional error code XML_ERROR_NOT_SUSPENDED possible.
+   Additional error code XML_ERROR_NOT_SUSPENDED possible.   

   *Note*:
   This must be called on the most deeply nested child parser instance
@@ -823,7 +832,12 @@ XML_StopParser(XML_Parser parser, XML_Bool resumable);
 XMLPARSEAPI(enum XML_Status)
 XML_ResumeParser(XML_Parser parser);

-enum XML_Parsing { XML_INITIALIZED, XML_PARSING, XML_FINISHED, XML_SUSPENDED };
+enum XML_Parsing {
+  XML_INITIALIZED,
+  XML_PARSING,
+  XML_FINISHED,
+  XML_SUSPENDED
+};

 typedef struct {
  enum XML_Parsing parsing;
@@ -855,7 +869,8 @@ XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
   Otherwise returns a new XML_Parser object.
 */
 XMLPARSEAPI(XML_Parser)
-XML_ExternalEntityParserCreate(XML_Parser parser, const XML_Char *context,
+XML_ExternalEntityParserCreate(XML_Parser parser,
+                               const XML_Char *context,
                               const XML_Char *encoding);

 enum XML_ParamEntityParsing {
@@ -886,7 +901,6 @@ enum XML_ParamEntityParsing {
   entities is requested; otherwise it will return non-zero.
   Note: If XML_SetParamEntityParsing is called after XML_Parse or
      XML_ParseBuffer, then it has no effect and will always return 0.
-   Note: If parser == NULL, the function will do nothing and return 0.
 */
 XMLPARSEAPI(int)
 XML_SetParamEntityParsing(XML_Parser parser,
@@ -896,10 +910,10 @@ XML_SetParamEntityParsing(XML_Parser parser,
   Helps in preventing DoS attacks based on predicting hash
   function behavior. This must be called before parsing is started.
   Returns 1 if successful, 0 when called after parsing has started.
-   Note: If parser == NULL, the function will do nothing and return 0.
 */
 XMLPARSEAPI(int)
-XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt);
+XML_SetHashSalt(XML_Parser parser,
+                unsigned long hash_salt);

 /* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
   XML_GetErrorCode returns information about the error.
@@ -916,16 +930,12 @@ XML_GetErrorCode(XML_Parser parser);
   be within the relevant markup.  When called outside of the callback
   functions, the position indicated will be just past the last parse
   event (regardless of whether there was an associated callback).
-
+   
   They may also be called after returning from a call to XML_Parse
   or XML_ParseBuffer.  If the return value is XML_STATUS_ERROR then
   the location is the location of the character at which the error
   was detected; otherwise the location is the location of the last
   parse event, as described above.
-
-   Note: XML_GetCurrentLineNumber and XML_GetCurrentColumnNumber
-   return 0 to indicate an error.
-   Note: XML_GetCurrentByteIndex returns -1 to indicate an error.
 */
 XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);
 XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);
@@ -948,12 +958,14 @@ XML_GetCurrentByteCount(XML_Parser parser);
   the handler that makes the call.
 */
 XMLPARSEAPI(const char *)
-XML_GetInputContext(XML_Parser parser, int *offset, int *size);
+XML_GetInputContext(XML_Parser parser,
+                    int *offset,
+                    int *size);

 /* For backwards compatibility with previous versions. */
-#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
+#define XML_GetErrorLineNumber   XML_GetCurrentLineNumber
 #define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
-#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
+#define XML_GetErrorByteIndex    XML_GetCurrentByteIndex

 /* Frees the content model passed to the element declaration handler */
 XMLPARSEAPI(void)
@@ -961,12 +973,9 @@ XML_FreeContentModel(XML_Parser parser, XML_Content *model);

 /* Exposing the memory handling functions used in Expat */
 XMLPARSEAPI(void *)
-XML_ATTR_MALLOC
-XML_ATTR_ALLOC_SIZE(2)
 XML_MemMalloc(XML_Parser parser, size_t size);

 XMLPARSEAPI(void *)
-XML_ATTR_ALLOC_SIZE(3)
 XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);

 XMLPARSEAPI(void)
@@ -1008,40 +1017,28 @@ enum XML_FeatureEnum {
  XML_FEATURE_SIZEOF_XML_LCHAR,
  XML_FEATURE_NS,
  XML_FEATURE_LARGE_SIZE,
-  XML_FEATURE_ATTR_INFO,
-  /* Added in Expat 2.4.0. */
-  XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,
-  XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT
+  XML_FEATURE_ATTR_INFO
  /* Additional features must be added to the end of this enum. */
 };

 typedef struct {
-  enum XML_FeatureEnum feature;
-  const XML_LChar *name;
-  long int value;
+  enum XML_FeatureEnum  feature;
+  const XML_LChar       *name;
+  long int              value;
 } XML_Feature;

 XMLPARSEAPI(const XML_Feature *)
 XML_GetFeatureList(void);

-#ifdef XML_DTD
-/* Added in Expat 2.4.0. */
-XMLPARSEAPI(XML_Bool)
-XML_SetBillionLaughsAttackProtectionMaximumAmplification(
-    XML_Parser parser, float maximumAmplificationFactor);

-/* Added in Expat 2.4.0. */
-XMLPARSEAPI(XML_Bool)
-XML_SetBillionLaughsAttackProtectionActivationThreshold(
-    XML_Parser parser, unsigned long long activationThresholdBytes);
-#endif
-
-/* Expat follows the semantic versioning convention.
-   See http://semver.org.
+/* Expat follows the GNU/Linux convention of odd number minor version for
+   beta/development releases and even number minor version for stable
+   releases. Micro is bumped with each release, and set to 0 with each
+   change to major or minor version.
 */
 #define XML_MAJOR_VERSION 2
-#define XML_MINOR_VERSION 4
-#define XML_MICRO_VERSION 4
+#define XML_MINOR_VERSION 1
+#define XML_MICRO_VERSION 0

 #ifdef __cplusplus
 }
--- a/3rdparty/expat/sg_expat_external.h
+++ b/3rdparty/expat/sg_expat_external.h
@@ -1,40 +1,5 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2000-2004 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
-   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2016      Cristian Rodríguez <crrodriguez@opensuse.org>
-   Copyright (c) 2016-2019 Sebastian Pipping <sebastian@pipping.org>
-   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
-   Copyright (c) 2018      Yury Gribov <tetra2005@gmail.com>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
-
-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
-
-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
 */

 #ifndef Expat_External_INCLUDED
@@ -42,6 +7,10 @@

 /* External API definitions */

+#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)
+#define XML_USE_MSC_EXTENSIONS 1
+#endif
+
 /* Expat tries very hard to make the API boundary very specifically
   defined.  There are two macros defined to control this boundary;
   each of these can be defined before including this header to
@@ -65,11 +34,11 @@
   system headers may assume the cdecl convention.
 */
 #ifndef XMLCALL
-#  if defined(_MSC_VER)
-#    define XMLCALL __cdecl
-#  elif defined(__GNUC__) && defined(__i386) && ! defined(__INTEL_COMPILER)
-#    define XMLCALL __attribute__((cdecl))
-#  else
+#if defined(_MSC_VER)
+#define XMLCALL __cdecl
+#elif defined(__GNUC__) && defined(__i386) && !defined(__INTEL_COMPILER)
+#define XMLCALL __attribute__((cdecl))
+#else
 /* For any platform which uses this definition and supports more than
   one calling convention, we need to extend this definition to
   declare the convention used on that platform, if it's possible to
@@ -80,47 +49,28 @@
   pre-processor and how to specify the same calling convention as the
   platform's malloc() implementation.
 */
-#    define XMLCALL
-#  endif
-#endif /* not defined XMLCALL */
+#define XMLCALL
+#endif
+#endif  /* not defined XMLCALL */

-#if ! defined(XML_STATIC) && ! defined(XMLIMPORT)
-#  ifndef XML_BUILDING_EXPAT
+
+#if !defined(XML_STATIC) && !defined(XMLIMPORT)
+#ifndef XML_BUILDING_EXPAT
 /* using Expat from an application */

-#    if defined(_MSC_EXTENSIONS) && ! defined(__BEOS__) && ! defined(__CYGWIN__)
-#      define XMLIMPORT __declspec(dllimport)
-#    endif
-
-#  endif
-#endif /* not defined XML_STATIC */
-
-#ifndef XML_ENABLE_VISIBILITY
-#  define XML_ENABLE_VISIBILITY 0
+#ifdef XML_USE_MSC_EXTENSIONS
+#define XMLIMPORT __declspec(dllimport)
 #endif

-#if ! defined(XMLIMPORT) && XML_ENABLE_VISIBILITY
-#  define XMLIMPORT __attribute__((visibility("default")))
 #endif
+#endif  /* not defined XML_STATIC */
+

 /* If we didn't define it above, define it away: */
 #ifndef XMLIMPORT
-#  define XMLIMPORT
+#define XMLIMPORT
 #endif

-#if defined(__GNUC__)                                                          \
-    && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96))
-#  define XML_ATTR_MALLOC __attribute__((__malloc__))
-#else
-#  define XML_ATTR_MALLOC
-#endif
-
-#if defined(__GNUC__)                                                          \
-    && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-#  define XML_ATTR_ALLOC_SIZE(x) __attribute__((__alloc_size__(x)))
-#else
-#  define XML_ATTR_ALLOC_SIZE(x)
-#endif

 #define XMLPARSEAPI(type) XMLIMPORT type XMLCALL

@@ -129,30 +79,30 @@ extern "C" {
 #endif

 #ifdef XML_UNICODE_WCHAR_T
-#  ifndef XML_UNICODE
-#    define XML_UNICODE
-#  endif
-#  if defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ != 2)
-#    error "sizeof(wchar_t) != 2; Need -fshort-wchar for both Expat and libc"
-#  endif
+#define XML_UNICODE
 #endif

-#ifdef XML_UNICODE /* Information is UTF-16 encoded. */
-#  ifdef XML_UNICODE_WCHAR_T
+#ifdef XML_UNICODE     /* Information is UTF-16 encoded. */
+#ifdef XML_UNICODE_WCHAR_T
 typedef wchar_t XML_Char;
 typedef wchar_t XML_LChar;
-#  else
+#else
 typedef unsigned short XML_Char;
 typedef char XML_LChar;
-#  endif /* XML_UNICODE_WCHAR_T */
-#else    /* Information is UTF-8 encoded. */
+#endif /* XML_UNICODE_WCHAR_T */
+#else                  /* Information is UTF-8 encoded. */
 typedef char XML_Char;
 typedef char XML_LChar;
-#endif   /* XML_UNICODE */
+#endif /* XML_UNICODE */

-#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */
+#ifdef XML_LARGE_SIZE  /* Use large integers for file/stream positions. */
+#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
+typedef __int64 XML_Index; 
+typedef unsigned __int64 XML_Size;
+#else
 typedef long long XML_Index;
 typedef unsigned long long XML_Size;
+#endif
 #else
 typedef long XML_Index;
 typedef unsigned long XML_Size;
--- a/3rdparty/expat/siphash.h
+++ b/3rdparty/expat/siphash.h
@@ -1,393 +0,0 @@
-/* ==========================================================================
- * siphash.h - SipHash-2-4 in a single header file
- * --------------------------------------------------------------------------
- * Derived by William Ahern from the reference implementation[1] published[2]
- * by Jean-Philippe Aumasson and Daniel J. Berstein.
- * Minimal changes by Sebastian Pipping and Victor Stinner on top, see below.
- * Licensed under the CC0 Public Domain Dedication license.
- *
- * 1. https://www.131002.net/siphash/siphash24.c
- * 2. https://www.131002.net/siphash/
- * --------------------------------------------------------------------------
- * HISTORY:
- *
- * 2020-10-03  (Sebastian Pipping)
- *   - Drop support for Visual Studio 9.0/2008 and earlier
- *
- * 2019-08-03  (Sebastian Pipping)
- *   - Mark part of sip24_valid as to be excluded from clang-format
- *   - Re-format code using clang-format 9
- *
- * 2018-07-08  (Anton Maklakov)
- *   - Add "fall through" markers for GCC's -Wimplicit-fallthrough
- *
- * 2017-11-03  (Sebastian Pipping)
- *   - Hide sip_tobin and sip_binof unless SIPHASH_TOBIN macro is defined
- *
- * 2017-07-25  (Vadim Zeitlin)
- *   - Fix use of SIPHASH_MAIN macro
- *
- * 2017-07-05  (Sebastian Pipping)
- *   - Use _SIP_ULL macro to not require a C++11 compiler if compiled as C++
- *   - Add const qualifiers at two places
- *   - Ensure <=80 characters line length (assuming tab width 4)
- *
- * 2017-06-23  (Victor Stinner)
- *   - Address Win64 compile warnings
- *
- * 2017-06-18  (Sebastian Pipping)
- *   - Clarify license note in the header
- *   - Address C89 issues:
- *     - Stop using inline keyword (and let compiler decide)
- *     - Replace _Bool by int
- *     - Turn macro siphash24 into a function
- *     - Address invalid conversion (void pointer) by explicit cast
- *   - Address lack of stdint.h for Visual Studio 2003 to 2008
- *   - Always expose sip24_valid (for self-tests)
- *
- * 2012-11-04 - Born.  (William Ahern)
- * --------------------------------------------------------------------------
- * USAGE:
- *
- * SipHash-2-4 takes as input two 64-bit words as the key, some number of
- * message bytes, and outputs a 64-bit word as the message digest. This
- * implementation employs two data structures: a struct sipkey for
- * representing the key, and a struct siphash for representing the hash
- * state.
- *
- * For converting a 16-byte unsigned char array to a key, use either the
- * macro sip_keyof or the routine sip_tokey. The former instantiates a
- * compound literal key, while the latter requires a key object as a
- * parameter.
- *
- * 	unsigned char secret[16];
- * 	arc4random_buf(secret, sizeof secret);
- * 	struct sipkey *key = sip_keyof(secret);
- *
- * For hashing a message, use either the convenience macro siphash24 or the
- * routines sip24_init, sip24_update, and sip24_final.
- *
- * 	struct siphash state;
- * 	void *msg;
- * 	size_t len;
- * 	uint64_t hash;
- *
- * 	sip24_init(&state, key);
- * 	sip24_update(&state, msg, len);
- * 	hash = sip24_final(&state);
- *
- * or
- *
- * 	hash = siphash24(msg, len, key);
- *
- * To convert the 64-bit hash value to a canonical 8-byte little-endian
- * binary representation, use either the macro sip_binof or the routine
- * sip_tobin. The former instantiates and returns a compound literal array,
- * while the latter requires an array object as a parameter.
- * --------------------------------------------------------------------------
- * NOTES:
- *
- * o Neither sip_keyof, sip_binof, nor siphash24 will work with compilers
- *   lacking compound literal support. Instead, you must use the lower-level
- *   interfaces which take as parameters the temporary state objects.
- *
- * o Uppercase macros may evaluate parameters more than once. Lowercase
- *   macros should not exhibit any such side effects.
- * ==========================================================================
- */
-#ifndef SIPHASH_H
-#define SIPHASH_H
-
-#include <stddef.h> /* size_t */
-#include <stdint.h> /* uint64_t uint32_t uint8_t */
-
-/*
- * Workaround to not require a C++11 compiler for using ULL suffix
- * if this code is included and compiled as C++; related GCC warning is:
- * warning: use of C++11 long long integer constant [-Wlong-long]
- */
-#define _SIP_ULL(high, low) (((uint64_t)high << 32) | low)
-
-#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
-
-#define SIP_U32TO8_LE(p, v)                                                    \
-  (p)[0] = (uint8_t)((v) >> 0);                                                \
-  (p)[1] = (uint8_t)((v) >> 8);                                                \
-  (p)[2] = (uint8_t)((v) >> 16);                                               \
-  (p)[3] = (uint8_t)((v) >> 24);
-
-#define SIP_U64TO8_LE(p, v)                                                    \
-  SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0));                                \
-  SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
-
-#define SIP_U8TO64_LE(p)                                                       \
-  (((uint64_t)((p)[0]) << 0) | ((uint64_t)((p)[1]) << 8)                       \
-   | ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24)                   \
-   | ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40)                   \
-   | ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
-
-#define SIPHASH_INITIALIZER                                                    \
-  { 0, 0, 0, 0, {0}, 0, 0 }
-
-struct siphash {
-  uint64_t v0, v1, v2, v3;
-
-  unsigned char buf[8], *p;
-  uint64_t c;
-}; /* struct siphash */
-
-#define SIP_KEYLEN 16
-
-struct sipkey {
-  uint64_t k[2];
-}; /* struct sipkey */
-
-#define sip_keyof(k) sip_tokey(&(struct sipkey){{0}}, (k))
-
-static struct sipkey *
-sip_tokey(struct sipkey *key, const void *src) {
-  key->k[0] = SIP_U8TO64_LE((const unsigned char *)src);
-  key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8);
-  return key;
-} /* sip_tokey() */
-
-#ifdef SIPHASH_TOBIN
-
-#  define sip_binof(v) sip_tobin((unsigned char[8]){0}, (v))
-
-static void *
-sip_tobin(void *dst, uint64_t u64) {
-  SIP_U64TO8_LE((unsigned char *)dst, u64);
-  return dst;
-} /* sip_tobin() */
-
-#endif /* SIPHASH_TOBIN */
-
-static void
-sip_round(struct siphash *H, const int rounds) {
-  int i;
-
-  for (i = 0; i < rounds; i++) {
-    H->v0 += H->v1;
-    H->v1 = SIP_ROTL(H->v1, 13);
-    H->v1 ^= H->v0;
-    H->v0 = SIP_ROTL(H->v0, 32);
-
-    H->v2 += H->v3;
-    H->v3 = SIP_ROTL(H->v3, 16);
-    H->v3 ^= H->v2;
-
-    H->v0 += H->v3;
-    H->v3 = SIP_ROTL(H->v3, 21);
-    H->v3 ^= H->v0;
-
-    H->v2 += H->v1;
-    H->v1 = SIP_ROTL(H->v1, 17);
-    H->v1 ^= H->v2;
-    H->v2 = SIP_ROTL(H->v2, 32);
-  }
-} /* sip_round() */
-
-static struct siphash *
-sip24_init(struct siphash *H, const struct sipkey *key) {
-  H->v0 = _SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0];
-  H->v1 = _SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1];
-  H->v2 = _SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0];
-  H->v3 = _SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1];
-
-  H->p = H->buf;
-  H->c = 0;
-
-  return H;
-} /* sip24_init() */
-
-#define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)])
-
-static struct siphash *
-sip24_update(struct siphash *H, const void *src, size_t len) {
-  const unsigned char *p = (const unsigned char *)src, *pe = p + len;
-  uint64_t m;
-
-  do {
-    while (p < pe && H->p < sip_endof(H->buf))
-      *H->p++ = *p++;
-
-    if (H->p < sip_endof(H->buf))
-      break;
-
-    m = SIP_U8TO64_LE(H->buf);
-    H->v3 ^= m;
-    sip_round(H, 2);
-    H->v0 ^= m;
-
-    H->p = H->buf;
-    H->c += 8;
-  } while (p < pe);
-
-  return H;
-} /* sip24_update() */
-
-static uint64_t
-sip24_final(struct siphash *H) {
-  const char left = (char)(H->p - H->buf);
-  uint64_t b = (H->c + left) << 56;
-
-  switch (left) {
-  case 7:
-    b |= (uint64_t)H->buf[6] << 48;
-    /* fall through */
-  case 6:
-    b |= (uint64_t)H->buf[5] << 40;
-    /* fall through */
-  case 5:
-    b |= (uint64_t)H->buf[4] << 32;
-    /* fall through */
-  case 4:
-    b |= (uint64_t)H->buf[3] << 24;
-    /* fall through */
-  case 3:
-    b |= (uint64_t)H->buf[2] << 16;
-    /* fall through */
-  case 2:
-    b |= (uint64_t)H->buf[1] << 8;
-    /* fall through */
-  case 1:
-    b |= (uint64_t)H->buf[0] << 0;
-    /* fall through */
-  case 0:
-    break;
-  }
-
-  H->v3 ^= b;
-  sip_round(H, 2);
-  H->v0 ^= b;
-  H->v2 ^= 0xff;
-  sip_round(H, 4);
-
-  return H->v0 ^ H->v1 ^ H->v2 ^ H->v3;
-} /* sip24_final() */
-
-static uint64_t
-siphash24(const void *src, size_t len, const struct sipkey *key) {
-  struct siphash state = SIPHASH_INITIALIZER;
-  return sip24_final(sip24_update(sip24_init(&state, key), src, len));
-} /* siphash24() */
-
-/*
- * SipHash-2-4 output with
- * k = 00 01 02 ...
- * and
- * in = (empty string)
- * in = 00 (1 byte)
- * in = 00 01 (2 bytes)
- * in = 00 01 02 (3 bytes)
- * ...
- * in = 00 01 02 ... 3e (63 bytes)
- */
-static int
-sip24_valid(void) {
-  /* clang-format off */
-  static const unsigned char vectors[64][8] = {
-    { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
-    { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
-    { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
-    { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
-    { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
-    { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
-    { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
-    { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
-    { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
-    { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
-    { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
-    { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
-    { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
-    { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
-    { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
-    { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
-    { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
-    { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
-    { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
-    { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
-    { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
-    { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
-    { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
-    { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
-    { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
-    { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
-    { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
-    { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
-    { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
-    { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
-    { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
-    { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
-    { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
-    { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
-    { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
-    { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
-    { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
-    { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
-    { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
-    { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
-    { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
-    { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
-    { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
-    { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
-    { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
-    { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
-    { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
-    { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
-    { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
-    { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
-    { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
-    { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
-    { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
-    { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
-    { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
-    { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
-    { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
-    { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
-    { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
-    { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
-    { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
-    { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
-    { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
-    { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, }
-  };
-  /* clang-format on */
-
-  unsigned char in[64];
-  struct sipkey k;
-  size_t i;
-
-  sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011"
-                "\012\013\014\015\016\017");
-
-  for (i = 0; i < sizeof in; ++i) {
-    in[i] = (unsigned char)i;
-
-    if (siphash24(in, i, &k) != SIP_U8TO64_LE(vectors[i]))
-      return 0;
-  }
-
-  return 1;
-} /* sip24_valid() */
-
-#ifdef SIPHASH_MAIN
-
-#  include <stdio.h>
-
-int
-main(void) {
-  const int ok = sip24_valid();
-
-  if (ok)
-    puts("OK");
-  else
-    puts("FAIL");
-
-  return ! ok;
-} /* main() */
-
-#endif /* SIPHASH_MAIN */
-
-#endif /* SIPHASH_H */
--- a/3rdparty/expat/utf8tab.h
+++ b/3rdparty/expat/utf8tab.h
@@ -1,66 +1,63 @@
 /*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/

-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.

-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
+The Original Code is expat.

-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.

-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
 */

+
 /* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-    /* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-    /* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-    /* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-    /* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
-    /* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,
+/* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
+/* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,
--- a/3rdparty/expat/winconfig.h
+++ b/3rdparty/expat/winconfig.h
@@ -1,45 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
-   Copyright (c) 2005      Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2017-2021 Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
-
-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
-
-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WINCONFIG_H
-#define WINCONFIG_H
-
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
-
-#include <memory.h>
-#include <string.h>
-
-#endif /* ndef WINCONFIG_H */
--- a/3rdparty/expat/xmlparse.c
+++ b/3rdparty/expat/xmlparse.c
--- a/3rdparty/expat/xmlrole.c
+++ b/3rdparty/expat/xmlrole.c
--- a/3rdparty/expat/xmlrole.h
+++ b/3rdparty/expat/xmlrole.h
@@ -1,36 +1,5 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
-
-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
-
-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
 */

 #ifndef XmlRole_INCLUDED
@@ -39,7 +8,7 @@
 #ifdef __VMS
 /*      0        1         2         3      0        1         2         3
        1234567890123456789012345678901     1234567890123456789012345678901 */
-#  define XmlPrologStateInitExternalEntity XmlPrologStateInitExternalEnt
+#define XmlPrologStateInitExternalEntity    XmlPrologStateInitExternalEnt
 #endif

 #include "xmltok.h"
@@ -116,8 +85,11 @@ enum {
 };

 typedef struct prolog_state {
-  int(PTRCALL *handler)(struct prolog_state *state, int tok, const char *ptr,
-                        const char *end, const ENCODING *enc);
+  int (PTRCALL *handler) (struct prolog_state *state,
+                          int tok,
+                          const char *ptr,
+                          const char *end,
+                          const ENCODING *enc);
  unsigned level;
  int role_none;
 #ifdef XML_DTD
@@ -132,8 +104,8 @@ void XmlPrologStateInit(PROLOG_STATE *);
 void XmlPrologStateInitExternalEntity(PROLOG_STATE *);
 #endif /* XML_DTD */

-#define XmlTokenRole(state, tok, ptr, end, enc)                                \
-  (((state)->handler)(state, tok, ptr, end, enc))
+#define XmlTokenRole(state, tok, ptr, end, enc) \
+ (((state)->handler)(state, tok, ptr, end, enc))

 #ifdef __cplusplus
 }
--- a/3rdparty/expat/xmltok.c
+++ b/3rdparty/expat/xmltok.c
--- a/3rdparty/expat/xmltok.h
+++ b/3rdparty/expat/xmltok.h
@@ -1,37 +1,5 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2002-2005 Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2016-2017 Sebastian Pipping <sebastian@pipping.org>
-   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
-
-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
-
-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
 */

 #ifndef XmlTok_INCLUDED
@@ -42,18 +10,16 @@ extern "C" {
 #endif

 /* The following token may be returned by XmlContentTok */
-#define XML_TOK_TRAILING_RSQB                                                  \
-  -5 /* ] or ]] at the end of the scan; might be                               \
-        start of illegal ]]> sequence */
+#define XML_TOK_TRAILING_RSQB -5 /* ] or ]] at the end of the scan; might be
+                                    start of illegal ]]> sequence */
 /* The following tokens may be returned by both XmlPrologTok and
   XmlContentTok.
 */
-#define XML_TOK_NONE -4 /* The string to be scanned is empty */
-#define XML_TOK_TRAILING_CR                                                    \
-  -3                            /* A CR at the end of the scan;                \
-                                   might be part of CRLF sequence */
-#define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */
-#define XML_TOK_PARTIAL -1      /* only part of a token */
+#define XML_TOK_NONE -4          /* The string to be scanned is empty */
+#define XML_TOK_TRAILING_CR -3   /* A CR at the end of the scan;
+                                    might be part of CRLF sequence */
+#define XML_TOK_PARTIAL_CHAR -2  /* only part of a multibyte sequence */
+#define XML_TOK_PARTIAL -1       /* only part of a token */
 #define XML_TOK_INVALID 0

 /* The following tokens are returned by XmlContentTok; some are also
@@ -68,24 +34,24 @@ extern "C" {
 #define XML_TOK_DATA_NEWLINE 7
 #define XML_TOK_CDATA_SECT_OPEN 8
 #define XML_TOK_ENTITY_REF 9
-#define XML_TOK_CHAR_REF 10 /* numeric character reference */
+#define XML_TOK_CHAR_REF 10               /* numeric character reference */

 /* The following tokens may be returned by both XmlPrologTok and
   XmlContentTok.
 */
-#define XML_TOK_PI 11       /* processing instruction */
-#define XML_TOK_XML_DECL 12 /* XML decl or text decl */
+#define XML_TOK_PI 11                     /* processing instruction */
+#define XML_TOK_XML_DECL 12               /* XML decl or text decl */
 #define XML_TOK_COMMENT 13
-#define XML_TOK_BOM 14 /* Byte order mark */
+#define XML_TOK_BOM 14                    /* Byte order mark */

 /* The following tokens are returned only by XmlPrologTok */
 #define XML_TOK_PROLOG_S 15
-#define XML_TOK_DECL_OPEN 16  /* <!foo */
-#define XML_TOK_DECL_CLOSE 17 /* > */
+#define XML_TOK_DECL_OPEN 16              /* <!foo */
+#define XML_TOK_DECL_CLOSE 17             /* > */
 #define XML_TOK_NAME 18
 #define XML_TOK_NMTOKEN 19
-#define XML_TOK_POUND_NAME 20 /* #name */
-#define XML_TOK_OR 21         /* | */
+#define XML_TOK_POUND_NAME 20             /* #name */
+#define XML_TOK_OR 21                     /* | */
 #define XML_TOK_PERCENT 22
 #define XML_TOK_OPEN_PAREN 23
 #define XML_TOK_CLOSE_PAREN 24
@@ -96,14 +62,14 @@ extern "C" {
 #define XML_TOK_INSTANCE_START 29

 /* The following occur only in element type declarations */
-#define XML_TOK_NAME_QUESTION 30        /* name? */
-#define XML_TOK_NAME_ASTERISK 31        /* name* */
-#define XML_TOK_NAME_PLUS 32            /* name+ */
-#define XML_TOK_COND_SECT_OPEN 33       /* <![ */
-#define XML_TOK_COND_SECT_CLOSE 34      /* ]]> */
-#define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */
-#define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */
-#define XML_TOK_CLOSE_PAREN_PLUS 37     /* )+ */
+#define XML_TOK_NAME_QUESTION 30          /* name? */
+#define XML_TOK_NAME_ASTERISK 31          /* name* */
+#define XML_TOK_NAME_PLUS 32              /* name+ */
+#define XML_TOK_COND_SECT_OPEN 33         /* <![ */
+#define XML_TOK_COND_SECT_CLOSE 34        /* ]]> */
+#define XML_TOK_CLOSE_PAREN_QUESTION 35   /* )? */
+#define XML_TOK_CLOSE_PAREN_ASTERISK 36   /* )* */
+#define XML_TOK_CLOSE_PAREN_PLUS 37       /* )+ */
 #define XML_TOK_COMMA 38

 /* The following token is returned only by XmlAttributeValueTok */
@@ -118,20 +84,20 @@ extern "C" {
 #define XML_TOK_PREFIXED_NAME 41

 #ifdef XML_DTD
-#  define XML_TOK_IGNORE_SECT 42
+#define XML_TOK_IGNORE_SECT 42
 #endif /* XML_DTD */

 #ifdef XML_DTD
-#  define XML_N_STATES 4
+#define XML_N_STATES 4
 #else /* not XML_DTD */
-#  define XML_N_STATES 3
+#define XML_N_STATES 3
 #endif /* not XML_DTD */

 #define XML_PROLOG_STATE 0
 #define XML_CONTENT_STATE 1
 #define XML_CDATA_SECTION_STATE 2
 #ifdef XML_DTD
-#  define XML_IGNORE_SECTION_STATE 3
+#define XML_IGNORE_SECTION_STATE 3
 #endif /* XML_DTD */

 #define XML_N_LITERAL_TYPES 2
@@ -159,41 +125,49 @@ typedef struct {
 struct encoding;
 typedef struct encoding ENCODING;

-typedef int(PTRCALL *SCANNER)(const ENCODING *, const char *, const char *,
-                              const char **);
-
-enum XML_Convert_Result {
-  XML_CONVERT_COMPLETED = 0,
-  XML_CONVERT_INPUT_INCOMPLETE = 1,
-  XML_CONVERT_OUTPUT_EXHAUSTED
-  = 2 /* and therefore potentially input remaining as well */
-};
+typedef int (PTRCALL *SCANNER)(const ENCODING *,
+                               const char *,
+                               const char *,
+                               const char **);

 struct encoding {
  SCANNER scanners[XML_N_STATES];
  SCANNER literalScanners[XML_N_LITERAL_TYPES];
-  int(PTRCALL *nameMatchesAscii)(const ENCODING *, const char *, const char *,
-                                 const char *);
-  int(PTRFASTCALL *nameLength)(const ENCODING *, const char *);
+  int (PTRCALL *sameName)(const ENCODING *,
+                          const char *,
+                          const char *);
+  int (PTRCALL *nameMatchesAscii)(const ENCODING *,
+                                  const char *,
+                                  const char *,
+                                  const char *);
+  int (PTRFASTCALL *nameLength)(const ENCODING *, const char *);
  const char *(PTRFASTCALL *skipS)(const ENCODING *, const char *);
-  int(PTRCALL *getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
-                        ATTRIBUTE *atts);
-  int(PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
-  int(PTRCALL *predefinedEntityName)(const ENCODING *, const char *,
-                                     const char *);
-  void(PTRCALL *updatePosition)(const ENCODING *, const char *ptr,
-                                const char *end, POSITION *);
-  int(PTRCALL *isPublicId)(const ENCODING *enc, const char *ptr,
-                           const char *end, const char **badPtr);
-  enum XML_Convert_Result(PTRCALL *utf8Convert)(const ENCODING *enc,
-                                                const char **fromP,
-                                                const char *fromLim, char **toP,
-                                                const char *toLim);
-  enum XML_Convert_Result(PTRCALL *utf16Convert)(const ENCODING *enc,
-                                                 const char **fromP,
-                                                 const char *fromLim,
-                                                 unsigned short **toP,
-                                                 const unsigned short *toLim);
+  int (PTRCALL *getAtts)(const ENCODING *enc,
+                         const char *ptr,
+                         int attsMax,
+                         ATTRIBUTE *atts);
+  int (PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
+  int (PTRCALL *predefinedEntityName)(const ENCODING *,
+                                      const char *,
+                                      const char *);
+  void (PTRCALL *updatePosition)(const ENCODING *,
+                                 const char *ptr,
+                                 const char *end,
+                                 POSITION *);
+  int (PTRCALL *isPublicId)(const ENCODING *enc,
+                            const char *ptr,
+                            const char *end,
+                            const char **badPtr);
+  void (PTRCALL *utf8Convert)(const ENCODING *enc,
+                              const char **fromP,
+                              const char *fromLim,
+                              char **toP,
+                              const char *toLim);
+  void (PTRCALL *utf16Convert)(const ENCODING *enc,
+                               const char **fromP,
+                               const char *fromLim,
+                               unsigned short **toP,
+                               const unsigned short *toLim);
  int minBytesPerChar;
  char isUtf8;
  char isUtf16;
@@ -220,62 +194,68 @@ struct encoding {
   the prolog outside literals, comments and processing instructions.
 */

-#define XmlTok(enc, state, ptr, end, nextTokPtr)                               \
+
+#define XmlTok(enc, state, ptr, end, nextTokPtr) \
  (((enc)->scanners[state])(enc, ptr, end, nextTokPtr))

-#define XmlPrologTok(enc, ptr, end, nextTokPtr)                                \
-  XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
+#define XmlPrologTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)

-#define XmlContentTok(enc, ptr, end, nextTokPtr)                               \
-  XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
+#define XmlContentTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)

-#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr)                          \
-  XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
+#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)

 #ifdef XML_DTD

-#  define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr)                       \
-    XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
+#define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)

 #endif /* XML_DTD */

 /* This is used for performing a 2nd-level tokenization on the content
   of a literal that has already been returned by XmlTok.
 */
-#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr)                  \
+#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr) \
  (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr))

-#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr)                        \
-  XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
+#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr) \
+   XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)

-#define XmlEntityValueTok(enc, ptr, end, nextTokPtr)                           \
-  XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
+#define XmlEntityValueTok(enc, ptr, end, nextTokPtr) \
+   XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)

-#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)                             \
+#define XmlSameName(enc, ptr1, ptr2) (((enc)->sameName)(enc, ptr1, ptr2))
+
+#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \
  (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))

-#define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr))
+#define XmlNameLength(enc, ptr) \
+  (((enc)->nameLength)(enc, ptr))

-#define XmlSkipS(enc, ptr) (((enc)->skipS)(enc, ptr))
+#define XmlSkipS(enc, ptr) \
+  (((enc)->skipS)(enc, ptr))

-#define XmlGetAttributes(enc, ptr, attsMax, atts)                              \
+#define XmlGetAttributes(enc, ptr, attsMax, atts) \
  (((enc)->getAtts)(enc, ptr, attsMax, atts))

-#define XmlCharRefNumber(enc, ptr) (((enc)->charRefNumber)(enc, ptr))
+#define XmlCharRefNumber(enc, ptr) \
+  (((enc)->charRefNumber)(enc, ptr))

-#define XmlPredefinedEntityName(enc, ptr, end)                                 \
+#define XmlPredefinedEntityName(enc, ptr, end) \
  (((enc)->predefinedEntityName)(enc, ptr, end))

-#define XmlUpdatePosition(enc, ptr, end, pos)                                  \
+#define XmlUpdatePosition(enc, ptr, end, pos) \
  (((enc)->updatePosition)(enc, ptr, end, pos))

-#define XmlIsPublicId(enc, ptr, end, badPtr)                                   \
+#define XmlIsPublicId(enc, ptr, end, badPtr) \
  (((enc)->isPublicId)(enc, ptr, end, badPtr))

-#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim)                        \
+#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim) \
  (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))

-#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim)                       \
+#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim) \
  (((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))

 typedef struct {
@@ -283,11 +263,16 @@ typedef struct {
  const ENCODING **encPtr;
 } INIT_ENCODING;

-int XmlParseXmlDecl(int isGeneralTextEntity, const ENCODING *enc,
-                    const char *ptr, const char *end, const char **badPtr,
-                    const char **versionPtr, const char **versionEndPtr,
+int XmlParseXmlDecl(int isGeneralTextEntity,
+                    const ENCODING *enc,
+                    const char *ptr,
+                    const char *end,
+                    const char **badPtr,
+                    const char **versionPtr,
+                    const char **versionEndPtr,
                    const char **encodingNamePtr,
-                    const ENCODING **namedEncodingPtr, int *standalonePtr);
+                    const ENCODING **namedEncodingPtr,
+                    int *standalonePtr);

 int XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
 const ENCODING *XmlGetUtf8InternalEncoding(void);
@@ -296,22 +281,34 @@ int FASTCALL XmlUtf8Encode(int charNumber, char *buf);
 int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf);
 int XmlSizeOfUnknownEncoding(void);

-typedef int(XMLCALL *CONVERTER)(void *userData, const char *p);

-ENCODING *XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
-                                 void *userData);
+typedef int (XMLCALL *CONVERTER) (void *userData, const char *p);

-int XmlParseXmlDeclNS(int isGeneralTextEntity, const ENCODING *enc,
-                      const char *ptr, const char *end, const char **badPtr,
-                      const char **versionPtr, const char **versionEndPtr,
+ENCODING *
+XmlInitUnknownEncoding(void *mem,
+                       int *table,
+                       CONVERTER convert,
+                       void *userData);
+
+int XmlParseXmlDeclNS(int isGeneralTextEntity,
+                      const ENCODING *enc,
+                      const char *ptr,
+                      const char *end,
+                      const char **badPtr,
+                      const char **versionPtr,
+                      const char **versionEndPtr,
                      const char **encodingNamePtr,
-                      const ENCODING **namedEncodingPtr, int *standalonePtr);
+                      const ENCODING **namedEncodingPtr,
+                      int *standalonePtr);

 int XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
 const ENCODING *XmlGetUtf8InternalEncodingNS(void);
 const ENCODING *XmlGetUtf16InternalEncodingNS(void);
-ENCODING *XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
-                                   void *userData);
+ENCODING *
+XmlInitUnknownEncodingNS(void *mem,
+                         int *table,
+                         CONVERTER convert,
+                         void *userData);
 #ifdef __cplusplus
 }
 #endif
--- a/3rdparty/expat/xmltok_impl.c
+++ b/3rdparty/expat/xmltok_impl.c
--- a/3rdparty/expat/xmltok_impl.h
+++ b/3rdparty/expat/xmltok_impl.h
@@ -1,74 +1,71 @@
 /*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/

-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2017-2019 Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.

-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
+The Original Code is expat.

-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.

-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
 */

 enum {
-  BT_NONXML,   /* e.g. noncharacter-FFFF */
-  BT_MALFORM,  /* illegal, with regard to encoding */
-  BT_LT,       /* less than = "<" */
-  BT_AMP,      /* ampersand = "&" */
-  BT_RSQB,     /* right square bracket = "[" */
-  BT_LEAD2,    /* lead byte of a 2-byte UTF-8 character */
-  BT_LEAD3,    /* lead byte of a 3-byte UTF-8 character */
-  BT_LEAD4,    /* lead byte of a 4-byte UTF-8 character */
-  BT_TRAIL,    /* trailing unit, e.g. second 16-bit unit of a 4-byte char. */
-  BT_CR,       /* carriage return = "\r" */
-  BT_LF,       /* line feed = "\n" */
-  BT_GT,       /* greater than = ">" */
-  BT_QUOT,     /* quotation character = "\"" */
-  BT_APOS,     /* aposthrophe = "'" */
-  BT_EQUALS,   /* equal sign = "=" */
-  BT_QUEST,    /* question mark = "?" */
-  BT_EXCL,     /* exclamation mark = "!" */
-  BT_SOL,      /* solidus, slash = "/" */
-  BT_SEMI,     /* semicolon = ";" */
-  BT_NUM,      /* number sign = "#" */
-  BT_LSQB,     /* left square bracket = "[" */
-  BT_S,        /* white space, e.g. "\t", " "[, "\r"] */
-  BT_NMSTRT,   /* non-hex name start letter = "G".."Z" + "g".."z" + "_" */
-  BT_COLON,    /* colon = ":" */
-  BT_HEX,      /* hex letter = "A".."F" + "a".."f" */
-  BT_DIGIT,    /* digit = "0".."9" */
-  BT_NAME,     /* dot and middle dot = "." + chr(0xb7) */
-  BT_MINUS,    /* minus = "-" */
-  BT_OTHER,    /* known not to be a name or name start character */
+  BT_NONXML,
+  BT_MALFORM,
+  BT_LT,
+  BT_AMP,
+  BT_RSQB,
+  BT_LEAD2,
+  BT_LEAD3,
+  BT_LEAD4,
+  BT_TRAIL,
+  BT_CR,
+  BT_LF,
+  BT_GT,
+  BT_QUOT,
+  BT_APOS,
+  BT_EQUALS,
+  BT_QUEST,
+  BT_EXCL,
+  BT_SOL,
+  BT_SEMI,
+  BT_NUM,
+  BT_LSQB,
+  BT_S,
+  BT_NMSTRT,
+  BT_COLON,
+  BT_HEX,
+  BT_DIGIT,
+  BT_NAME,
+  BT_MINUS,
+  BT_OTHER, /* known not to be a name or name start character */
  BT_NONASCII, /* might be a name or name start character */
-  BT_PERCNT,   /* percent sign = "%" */
-  BT_LPAR,     /* left parenthesis = "(" */
-  BT_RPAR,     /* right parenthesis = "(" */
-  BT_AST,      /* asterisk = "*" */
-  BT_PLUS,     /* plus sign = "+" */
-  BT_COMMA,    /* comma = "," */
-  BT_VERBAR    /* vertical bar = "|" */
+  BT_PERCNT,
+  BT_LPAR,
+  BT_RPAR,
+  BT_AST,
+  BT_PLUS,
+  BT_COMMA,
+  BT_VERBAR
 };

 #include <stddef.h>
--- a/3rdparty/expat/xmltok_ns.c
+++ b/3rdparty/expat/xmltok_ns.c
@@ -1,83 +1,61 @@
-/* This file is included!
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2017-2021 Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
-   distribute, sublicense, and/or sell copies of the Software, and to permit
-   persons  to whom  the Software  is  furnished to  do so,  subject to  the
-   following conditions:
-
-   The above copyright  notice and this permission notice  shall be included
-   in all copies or substantial portions of the Software.
-
-   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
-   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
 */

+/* This file is included! */
 #ifdef XML_TOK_NS_C

 const ENCODING *
-NS(XmlGetUtf8InternalEncoding)(void) {
+NS(XmlGetUtf8InternalEncoding)(void)
+{
  return &ns(internal_utf8_encoding).enc;
 }

 const ENCODING *
-NS(XmlGetUtf16InternalEncoding)(void) {
-#  if BYTEORDER == 1234
+NS(XmlGetUtf16InternalEncoding)(void)
+{
+#if BYTEORDER == 1234
  return &ns(internal_little2_encoding).enc;
-#  elif BYTEORDER == 4321
+#elif BYTEORDER == 4321
  return &ns(internal_big2_encoding).enc;
-#  else
+#else
  const short n = 1;
-  return (*(const char *)&n ? &ns(internal_little2_encoding).enc
-                            : &ns(internal_big2_encoding).enc);
-#  endif
+  return (*(const char *)&n
+          ? &ns(internal_little2_encoding).enc
+          : &ns(internal_big2_encoding).enc);
+#endif
 }

-static const ENCODING *const NS(encodings)[] = {
-    &ns(latin1_encoding).enc, &ns(ascii_encoding).enc,
-    &ns(utf8_encoding).enc,   &ns(big2_encoding).enc,
-    &ns(big2_encoding).enc,   &ns(little2_encoding).enc,
-    &ns(utf8_encoding).enc /* NO_ENC */
+static const ENCODING * const NS(encodings)[] = {
+  &ns(latin1_encoding).enc,
+  &ns(ascii_encoding).enc,
+  &ns(utf8_encoding).enc,
+  &ns(big2_encoding).enc,
+  &ns(big2_encoding).enc,
+  &ns(little2_encoding).enc,
+  &ns(utf8_encoding).enc /* NO_ENC */
 };

 static int PTRCALL
 NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
-                   const char **nextTokPtr) {
-  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE,
-                  ptr, end, nextTokPtr);
+                   const char **nextTokPtr)
+{
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc,
+                  XML_PROLOG_STATE, ptr, end, nextTokPtr);
 }

 static int PTRCALL
 NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
-                    const char **nextTokPtr) {
-  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE,
-                  ptr, end, nextTokPtr);
+                    const char **nextTokPtr)
+{
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc,
+                  XML_CONTENT_STATE, ptr, end, nextTokPtr);
 }

 int
 NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
-                    const char *name) {
+                    const char *name)
+{
  int i = getEncodingIndex(name);
  if (i == UNKNOWN_ENC)
    return 0;
@@ -91,9 +69,10 @@ NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
 }

 static const ENCODING *
-NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) {
-#  define ENCODING_MAX 128
-  char buf[ENCODING_MAX] = "";
+NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
+{
+#define ENCODING_MAX 128
+  char buf[ENCODING_MAX];
  char *p = buf;
  int i;
  XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
@@ -109,14 +88,28 @@ NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) {
 }

 int
-NS(XmlParseXmlDecl)(int isGeneralTextEntity, const ENCODING *enc,
-                    const char *ptr, const char *end, const char **badPtr,
-                    const char **versionPtr, const char **versionEndPtr,
-                    const char **encodingName, const ENCODING **encoding,
-                    int *standalone) {
-  return doParseXmlDecl(NS(findEncoding), isGeneralTextEntity, enc, ptr, end,
-                        badPtr, versionPtr, versionEndPtr, encodingName,
-                        encoding, standalone);
+NS(XmlParseXmlDecl)(int isGeneralTextEntity,
+                    const ENCODING *enc,
+                    const char *ptr,
+                    const char *end,
+                    const char **badPtr,
+                    const char **versionPtr,
+                    const char **versionEndPtr,
+                    const char **encodingName,
+                    const ENCODING **encoding,
+                    int *standalone)
+{
+  return doParseXmlDecl(NS(findEncoding),
+                        isGeneralTextEntity,
+                        enc,
+                        ptr,
+                        end,
+                        badPtr,
+                        versionPtr,
+                        versionEndPtr,
+                        encodingName,
+                        encoding,
+                        standalone);
 }

 #endif /* XML_TOK_NS_C */
--- a/3rdparty/tiny_gltf/CMakeLists.txt
+++ b/3rdparty/tiny_gltf/CMakeLists.txt
@@ -1,14 +0,0 @@
-add_library(FGTinyGLTF INTERFACE)
-
-target_include_directories(FGTinyGLTF
-  INTERFACE
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-  $<INSTALL_INTERFACE:include>)
-
-# in the non-shared case, we need to export these as well
-if (NOT SIMGEAR_SHARED)
-  install(TARGETS FGTinyGLTF
-    EXPORT SimGearTargets
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-endif()
--- a/3rdparty/tiny_gltf/json.hpp
+++ b/3rdparty/tiny_gltf/json.hpp
--- a/3rdparty/tiny_gltf/tiny_gltf.h
+++ b/3rdparty/tiny_gltf/tiny_gltf.h
--- a/3rdparty/udns/CMakeLists.txt
+++ b/3rdparty/udns/CMakeLists.txt
@@ -13,6 +13,7 @@ CHECK_SYMBOL_EXISTS(AF_INET6 "netinet/in.h" HAVE_IPv6)
 check_include_file(windows.h  WINDOWS)

 CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_BINARY_DIR}/config.h)
+include_directories(${CMAKE_BINARY_DIR})

 set(HEADERS
 )
@@ -37,21 +38,4 @@ set(SOURCES
    udns_XtoX.c
 )

-add_library(FGUdns STATIC ${SOURCES})
-
-target_include_directories(FGUdns BEFORE PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-    $<INSTALL_INTERFACE:include>)
-    
-target_include_directories(FGUdns PRIVATE ${CMAKE_BINARY_DIR})
-
-# match the name of imported UDns 
-add_librarY(Udns::Udns ALIAS FGUdns)
-
-# in the non-shared case, we need to export these as well
-if (NOT SIMGEAR_SHARED)
-    install(TARGETS FGUdns
-        EXPORT SimGearTargets
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-endif()
+simgear_component(udns 3rdparty/udns "${SOURCES}" "${HEADERS}")
--- a/3rdparty/udns/COPYING.LGPL
+++ b/3rdparty/udns/COPYING.LGPL
@@ -55,7 +55,7 @@ modified by someone else and passed on, the recipients should know
 that what they have is not the original version, so that the original
 author's reputation will not be affected by problems that might be
 introduced by others.
-
+
  Finally, software patents pose a constant threat to the existence of
 any free program.  We wish to make sure that a company cannot
 effectively restrict the users of a free program by obtaining a
@@ -111,7 +111,7 @@ modification follow.  Pay close attention to the difference between a
 "work based on the library" and a "work that uses the library".  The
 former contains code derived from the library, whereas the latter must
 be combined with the library in order to run.
-
+
                  GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

@@ -158,7 +158,7 @@ Library.
  You may charge a fee for the physical act of transferring a copy,
 and you may at your option offer warranty protection in exchange for a
 fee.
-
+
  2. You may modify your copy or copies of the Library or any portion
 of it, thus forming a work based on the Library, and copy and
 distribute such modifications or work under the terms of Section 1
@@ -216,7 +216,7 @@ instead of to this License.  (If a newer version than version 2 of the
 ordinary GNU General Public License has appeared, then you can specify
 that version instead if you wish.)  Do not make any other change in
 these notices.
-
+
  Once this change is made in a given copy, it is irreversible for
 that copy, so the ordinary GNU General Public License applies to all
 subsequent copies and derivative works made from that copy.
@@ -267,7 +267,7 @@ Library will still fall under Section 6.)
 distribute the object code for the work under the terms of Section 6.
 Any executables containing that work also fall under Section 6,
 whether or not they are linked directly with the Library itself.
-
+
  6. As an exception to the Sections above, you may also combine or
 link a "work that uses the Library" with the Library to produce a
 work containing portions of the Library, and distribute that work
@@ -329,7 +329,7 @@ restrictions of other proprietary libraries that do not normally
 accompany the operating system.  Such a contradiction means you cannot
 use both them and the Library together in an executable that you
 distribute.
-
+
  7. You may place library facilities that are a work based on the
 Library side-by-side in a single library together with other library
 facilities not covered by this License, and distribute such a combined
@@ -370,7 +370,7 @@ subject to these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties with
 this License.
-
+
  11. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
@@ -422,7 +422,7 @@ conditions either of that version or of any later version published by
 the Free Software Foundation.  If the Library does not specify a
 license version number, you may choose any version ever published by
 the Free Software Foundation.
-
+
  14. If you wish to incorporate parts of the Library into other free
 programs whose distribution conditions are incompatible with these,
 write to the author to ask for permission.  For software which is
@@ -456,7 +456,7 @@ SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 DAMAGES.

                     END OF TERMS AND CONDITIONS
-
+
           How to Apply These Terms to Your New Libraries

  If you develop a new library, and you want it to be of the greatest
--- a/3rdparty/udns/rblcheck.c
+++ b/3rdparty/udns/rblcheck.c
@@ -339,12 +339,10 @@ int main(int argc, char **argv) {
      char *home = getenv("HOME");
      if (!home) home = ".";
      path = malloc(strlen(home) + 1 + sizeof(".rblcheckrc"));
-      if (path) {
-        sprintf(path, "%s/.rblcheckrc", home);
-        if (!addzonefile(path))
-          addzonefile("/etc/rblcheckrc");
-        free(path);
-      }
+      sprintf(path, "%s/.rblcheckrc", home);
+      if (!addzonefile(path))
+        addzonefile("/etc/rblcheckrc");
+      free(path);
    }
  }
  if (!nzones)
--- a/3rdparty/udns/udns_init.c
+++ b/3rdparty/udns/udns_init.c
@@ -24,7 +24,7 @@
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
-#if defined(_WINDOWS) || defined(WINDOWS)
+#ifdef WINDOWS
 # include <winsock2.h>          /* includes <windows.h> */
 # include <iphlpapi.h>		/* for dns server addresses etc */
 #else
@@ -53,7 +53,7 @@ static void dns_set_srch_internal(struct dns_ctx *ctx, char *srch) {
    dns_add_srch(ctx, srch);
 }

-#if defined(_WINDOWS) || defined(WINDOWS)
+#ifdef WINDOWS

 #ifndef NO_IPHLPAPI
 /* Apparently, some systems does not have proper headers for IPHLPAIP to work.
@@ -217,7 +217,7 @@ int dns_init(struct dns_ctx *ctx, int do_open) {
    ctx = &dns_defctx;
  dns_reset(ctx);

-#if defined(_WINDOWS) || defined(WINDOWS)
+#ifdef WINDOWS
  if (dns_initns_iphlpapi(ctx) != 0)
    dns_initns_registry(ctx);
  /*XXX WINDOWS: probably good to get default domain and search list too...
--- a/3rdparty/udns/udns_resolver.c
+++ b/3rdparty/udns/udns_resolver.c
@@ -24,7 +24,7 @@
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
-#if defined(_WINDOWS) || defined(WINDOWS)
+#ifdef WINDOWS
 # include <winsock2.h>          /* includes <windows.h> */
 # include <ws2tcpip.h>          /* needed for struct in6_addr */
 #else
@@ -392,7 +392,7 @@ dns_set_tmcbck(struct dns_ctx *ctx, dns_utm_fn *fn, void *data) {
 }

 static unsigned dns_nonrandom_32(void) {
-#if defined(_WINDOWS) || defined(WINDOWS)
+#ifdef WINDOWS
  FILETIME ft;
  GetSystemTimeAsFileTime(&ft);
  return ft.dwLowDateTime;
@@ -551,7 +551,7 @@ int dns_open(struct dns_ctx *ctx) {
    ctx->dnsc_qstatus = DNS_E_TEMPFAIL;
    return -1;
  }
-#if defined(_WINDOWS) || defined(WINDOWS)
+#ifdef WINDOWS
  { unsigned long on = 1;
    if (ioctlsocket(sock, FIONBIO, &on) == SOCKET_ERROR) {
      closesocket(sock);
@@ -991,7 +991,7 @@ again: /* receive the reply */
     * or remote.  On local errors, we should stop, while
     * remote errors should be ignored (for now anyway).
     */
-#if defined(_WINDOWS) || defined(WINDOWS)
+#ifdef WINDOWS
    if (WSAGetLastError() == WSAEWOULDBLOCK)
 #else
    if (errno == EAGAIN)
--- a/3rdparty/udns/udns_rr_a.c
+++ b/3rdparty/udns/udns_rr_a.c
@@ -27,7 +27,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
-#if !defined(_WINDOWS) && !defined(WINDOWS)
+#ifndef WINDOWS
 # include <sys/types.h>
 # include <netinet/in.h>
 #endif
--- a/3rdparty/utf8/CMakeLists.txt
+++ b/3rdparty/utf8/CMakeLists.txt
@@ -0,0 +1,17 @@
+include (SimGearComponent)
+
+set(HEADERS
+  source/utf8.h
+)
+
+set(HEADERS_utf8
+  source/utf8/checked.h
+  source/utf8/core.h
+  source/utf8/unchecked.h
+)
+
+set(SOURCES
+)
+
+simgear_component(utf8 3rdparty/utf8 "${SOURCES}" "${HEADERS}")
+simgear_component(utf8-internal 3rdparty/utf8/utf8 "" "${HEADERS_utf8}")
--- a/3rdparty/utf8/doc/ReleaseNotes
+++ b/3rdparty/utf8/doc/ReleaseNotes
@@ -0,0 +1,12 @@
+utf8 cpp library
+Release 2.3.4
+
+A minor bug fix release. Thanks to all who reported bugs. 
+
+Note: Version 2.3.3 contained a regression, and therefore was removed.
+
+Changes from version 2.3.2
+- Bug fix [39]: checked.h Line 273 and unchecked.h Line 182 have an extra ';'
+- Bug fix [36]: replace_invalid() only works with back_inserter
+
+Files included in the release: utf8.h, core.h, checked.h, unchecked.h, utf8cpp.html, ReleaseNotes
--- a/3rdparty/utf8/doc/utf8cpp.html
+++ b/3rdparty/utf8/doc/utf8cpp.html
--- a/3rdparty/utf8/source/utf8.h
+++ b/3rdparty/utf8/source/utf8.h
@@ -0,0 +1,34 @@
+// Copyright 2006 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+#include "utf8/checked.h"
+#include "utf8/unchecked.h"
+
+#endif // header guard
--- a/3rdparty/utf8/source/utf8/checked.h
+++ b/3rdparty/utf8/source/utf8/checked.h
@@ -0,0 +1,327 @@
+// Copyright 2006 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+#include "core.h"
+#include <stdexcept>
+
+namespace utf8
+{
+    // Base for the exceptions that may be thrown from the library
+    class exception : public ::std::exception {
+    };
+
+    // Exceptions that may be thrown from the library functions.
+    class invalid_code_point : public exception {
+        uint32_t cp;
+    public:
+        invalid_code_point(uint32_t cp) : cp(cp) {}
+        virtual const char* what() const throw() { return "Invalid code point"; }
+        uint32_t code_point() const {return cp;}
+    };
+
+    class invalid_utf8 : public exception {
+        uint8_t u8;
+    public:
+        invalid_utf8 (uint8_t u) : u8(u) {}
+        virtual const char* what() const throw() { return "Invalid UTF-8"; }
+        uint8_t utf8_octet() const {return u8;}
+    };
+
+    class invalid_utf16 : public exception {
+        uint16_t u16;
+    public:
+        invalid_utf16 (uint16_t u) : u16(u) {}
+        virtual const char* what() const throw() { return "Invalid UTF-16"; }
+        uint16_t utf16_word() const {return u16;}
+    };
+
+    class not_enough_room : public exception {
+    public:
+        virtual const char* what() const throw() { return "Not enough space"; }
+    };
+
+    /// The library API - functions intended to be called by the users
+
+    template <typename octet_iterator>
+    octet_iterator append(uint32_t cp, octet_iterator result)
+    {
+        if (!utf8::internal::is_code_point_valid(cp))
+            throw invalid_code_point(cp);
+
+        if (cp < 0x80)                        // one octet
+            *(result++) = static_cast<uint8_t>(cp);
+        else if (cp < 0x800) {                // two octets
+            *(result++) = static_cast<uint8_t>((cp >> 6)            | 0xc0);
+            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
+        }
+        else if (cp < 0x10000) {              // three octets
+            *(result++) = static_cast<uint8_t>((cp >> 12)           | 0xe0);
+            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
+            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
+        }
+        else {                                // four octets
+            *(result++) = static_cast<uint8_t>((cp >> 18)           | 0xf0);
+            *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)  | 0x80);
+            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
+            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
+        }
+        return result;
+    }
+
+    template <typename octet_iterator, typename output_iterator>
+    output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, uint32_t replacement)
+    {
+        while (start != end) {
+            octet_iterator sequence_start = start;
+            internal::utf_error err_code = utf8::internal::validate_next(start, end);
+            switch (err_code) {
+                case internal::UTF8_OK :
+                    for (octet_iterator it = sequence_start; it != start; ++it)
+                        *out++ = *it;
+                    break;
+                case internal::NOT_ENOUGH_ROOM:
+                    throw not_enough_room();
+                case internal::INVALID_LEAD:
+                    out = utf8::append (replacement, out);
+                    ++start;
+                    break;
+                case internal::INCOMPLETE_SEQUENCE:
+                case internal::OVERLONG_SEQUENCE:
+                case internal::INVALID_CODE_POINT:
+                    out = utf8::append (replacement, out);
+                    ++start;
+                    // just one replacement mark for the sequence
+                    while (start != end && utf8::internal::is_trail(*start))
+                        ++start;
+                    break;
+            }
+        }
+        return out;
+    }
+
+    template <typename octet_iterator, typename output_iterator>
+    inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out)
+    {
+        static const uint32_t replacement_marker = utf8::internal::mask16(0xfffd);
+        return utf8::replace_invalid(start, end, out, replacement_marker);
+    }
+
+    template <typename octet_iterator>
+    uint32_t next(octet_iterator& it, octet_iterator end)
+    {
+        uint32_t cp = 0;
+        internal::utf_error err_code = utf8::internal::validate_next(it, end, cp);
+        switch (err_code) {
+            case internal::UTF8_OK :
+                break;
+            case internal::NOT_ENOUGH_ROOM :
+                throw not_enough_room();
+            case internal::INVALID_LEAD :
+            case internal::INCOMPLETE_SEQUENCE :
+            case internal::OVERLONG_SEQUENCE :
+                throw invalid_utf8(*it);
+            case internal::INVALID_CODE_POINT :
+                throw invalid_code_point(cp);
+        }
+        return cp;
+    }
+
+    template <typename octet_iterator>
+    uint32_t peek_next(octet_iterator it, octet_iterator end)
+    {
+        return utf8::next(it, end);
+    }
+
+    template <typename octet_iterator>
+    uint32_t prior(octet_iterator& it, octet_iterator start)
+    {
+        // can't do much if it == start
+        if (it == start)
+            throw not_enough_room();
+
+        octet_iterator end = it;
+        // Go back until we hit either a lead octet or start
+        while (utf8::internal::is_trail(*(--it)))
+            if (it == start)
+                throw invalid_utf8(*it); // error - no lead byte in the sequence
+        return utf8::peek_next(it, end);
+    }
+
+    /// Deprecated in versions that include "prior"
+    template <typename octet_iterator>
+    uint32_t previous(octet_iterator& it, octet_iterator pass_start)
+    {
+        octet_iterator end = it;
+        while (utf8::internal::is_trail(*(--it)))
+            if (it == pass_start)
+                throw invalid_utf8(*it); // error - no lead byte in the sequence
+        octet_iterator temp = it;
+        return utf8::next(temp, end);
+    }
+
+    template <typename octet_iterator, typename distance_type>
+    void advance (octet_iterator& it, distance_type n, octet_iterator end)
+    {
+        for (distance_type i = 0; i < n; ++i)
+            utf8::next(it, end);
+    }
+
+    template <typename octet_iterator>
+    typename std::iterator_traits<octet_iterator>::difference_type
+    distance (octet_iterator first, octet_iterator last)
+    {
+        typename std::iterator_traits<octet_iterator>::difference_type dist;
+        for (dist = 0; first < last; ++dist)
+            utf8::next(first, last);
+        return dist;
+    }
+
+    template <typename u16bit_iterator, typename octet_iterator>
+    octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
+    {
+        while (start != end) {
+            uint32_t cp = utf8::internal::mask16(*start++);
+            // Take care of surrogate pairs first
+            if (utf8::internal::is_lead_surrogate(cp)) {
+                if (start != end) {
+                    uint32_t trail_surrogate = utf8::internal::mask16(*start++);
+                    if (utf8::internal::is_trail_surrogate(trail_surrogate))
+                        cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
+                    else
+                        throw invalid_utf16(static_cast<uint16_t>(trail_surrogate));
+                }
+                else
+                    throw invalid_utf16(static_cast<uint16_t>(cp));
+
+            }
+            // Lone trail surrogate
+            else if (utf8::internal::is_trail_surrogate(cp))
+                throw invalid_utf16(static_cast<uint16_t>(cp));
+
+            result = utf8::append(cp, result);
+        }
+        return result;
+    }
+
+    template <typename u16bit_iterator, typename octet_iterator>
+    u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
+    {
+        while (start != end) {
+            uint32_t cp = utf8::next(start, end);
+            if (cp > 0xffff) { //make a surrogate pair
+                *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
+                *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
+            }
+            else
+                *result++ = static_cast<uint16_t>(cp);
+        }
+        return result;
+    }
+
+    template <typename octet_iterator, typename u32bit_iterator>
+    octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)
+    {
+        while (start != end)
+            result = utf8::append(*(start++), result);
+
+        return result;
+    }
+
+    template <typename octet_iterator, typename u32bit_iterator>
+    u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
+    {
+        while (start != end)
+            (*result++) = utf8::next(start, end);
+
+        return result;
+    }
+
+    // The iterator class
+    template <typename octet_iterator>
+    class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> {
+      octet_iterator it;
+      octet_iterator range_start;
+      octet_iterator range_end;
+      public:
+      iterator () {}
+      explicit iterator (const octet_iterator& octet_it,
+                         const octet_iterator& range_start,
+                         const octet_iterator& range_end) :
+               it(octet_it), range_start(range_start), range_end(range_end)
+      {
+          if (it < range_start || it > range_end)
+              throw std::out_of_range("Invalid utf-8 iterator position");
+      }
+      // the default "big three" are OK
+      octet_iterator base () const { return it; }
+      uint32_t operator * () const
+      {
+          octet_iterator temp = it;
+          return utf8::next(temp, range_end);
+      }
+      bool operator == (const iterator& rhs) const
+      {
+          if (range_start != rhs.range_start || range_end != rhs.range_end)
+              throw std::logic_error("Comparing utf-8 iterators defined with different ranges");
+          return (it == rhs.it);
+      }
+      bool operator != (const iterator& rhs) const
+      {
+          return !(operator == (rhs));
+      }
+      iterator& operator ++ ()
+      {
+          utf8::next(it, range_end);
+          return *this;
+      }
+      iterator operator ++ (int)
+      {
+          iterator temp = *this;
+          utf8::next(it, range_end);
+          return temp;
+      }
+      iterator& operator -- ()
+      {
+          utf8::prior(it, range_start);
+          return *this;
+      }
+      iterator operator -- (int)
+      {
+          iterator temp = *this;
+          utf8::prior(it, range_start);
+          return temp;
+      }
+    }; // class iterator
+
+} // namespace utf8
+
+#endif //header guard
+
+
--- a/3rdparty/utf8/source/utf8/core.h
+++ b/3rdparty/utf8/source/utf8/core.h
@@ -0,0 +1,329 @@
+// Copyright 2006 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+#include <iterator>
+
+namespace utf8
+{
+    // The typedefs for 8-bit, 16-bit and 32-bit unsigned integers
+    // You may need to change them to match your system.
+    // These typedefs have the same names as ones from cstdint, or boost/cstdint
+    typedef unsigned char   uint8_t;
+    typedef unsigned short  uint16_t;
+    typedef unsigned int    uint32_t;
+
+// Helper code - not intended to be directly called by the library users. May be changed at any time
+namespace internal
+{
+    // Unicode constants
+    // Leading (high) surrogates: 0xd800 - 0xdbff
+    // Trailing (low) surrogates: 0xdc00 - 0xdfff
+    const uint16_t LEAD_SURROGATE_MIN  = 0xd800u;
+    const uint16_t LEAD_SURROGATE_MAX  = 0xdbffu;
+    const uint16_t TRAIL_SURROGATE_MIN = 0xdc00u;
+    const uint16_t TRAIL_SURROGATE_MAX = 0xdfffu;
+    const uint16_t LEAD_OFFSET         = LEAD_SURROGATE_MIN - (0x10000 >> 10);
+    const uint32_t SURROGATE_OFFSET    = 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN;
+
+    // Maximum valid value for a Unicode code point
+    const uint32_t CODE_POINT_MAX      = 0x0010ffffu;
+
+    template<typename octet_type>
+    inline uint8_t mask8(octet_type oc)
+    {
+        return static_cast<uint8_t>(0xff & oc);
+    }
+    template<typename u16_type>
+    inline uint16_t mask16(u16_type oc)
+    {
+        return static_cast<uint16_t>(0xffff & oc);
+    }
+    template<typename octet_type>
+    inline bool is_trail(octet_type oc)
+    {
+        return ((utf8::internal::mask8(oc) >> 6) == 0x2);
+    }
+
+    template <typename u16>
+    inline bool is_lead_surrogate(u16 cp)
+    {
+        return (cp >= LEAD_SURROGATE_MIN && cp <= LEAD_SURROGATE_MAX);
+    }
+
+    template <typename u16>
+    inline bool is_trail_surrogate(u16 cp)
+    {
+        return (cp >= TRAIL_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
+    }
+
+    template <typename u16>
+    inline bool is_surrogate(u16 cp)
+    {
+        return (cp >= LEAD_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
+    }
+
+    template <typename u32>
+    inline bool is_code_point_valid(u32 cp)
+    {
+        return (cp <= CODE_POINT_MAX && !utf8::internal::is_surrogate(cp));
+    }
+
+    template <typename octet_iterator>
+    inline typename std::iterator_traits<octet_iterator>::difference_type
+    sequence_length(octet_iterator lead_it)
+    {
+        uint8_t lead = utf8::internal::mask8(*lead_it);
+        if (lead < 0x80)
+            return 1;
+        else if ((lead >> 5) == 0x6)
+            return 2;
+        else if ((lead >> 4) == 0xe)
+            return 3;
+        else if ((lead >> 3) == 0x1e)
+            return 4;
+        else
+            return 0;
+    }
+
+    template <typename octet_difference_type>
+    inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length)
+    {
+        if (cp < 0x80) {
+            if (length != 1) 
+                return true;
+        }
+        else if (cp < 0x800) {
+            if (length != 2) 
+                return true;
+        }
+        else if (cp < 0x10000) {
+            if (length != 3) 
+                return true;
+        }
+
+        return false;
+    }
+
+    enum utf_error {UTF8_OK, NOT_ENOUGH_ROOM, INVALID_LEAD, INCOMPLETE_SEQUENCE, OVERLONG_SEQUENCE, INVALID_CODE_POINT};
+
+    /// Helper for get_sequence_x
+    template <typename octet_iterator>
+    utf_error increase_safely(octet_iterator& it, octet_iterator end)
+    {
+        if (++it == end)
+            return NOT_ENOUGH_ROOM;
+
+        if (!utf8::internal::is_trail(*it))
+            return INCOMPLETE_SEQUENCE;
+        
+        return UTF8_OK;
+    }
+
+    #define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}    
+
+    /// get_sequence_x functions decode utf-8 sequences of the length x
+    template <typename octet_iterator>
+    utf_error get_sequence_1(octet_iterator& it, octet_iterator end, uint32_t& code_point)
+    {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+
+        code_point = utf8::internal::mask8(*it);
+
+        return UTF8_OK;
+    }
+
+    template <typename octet_iterator>
+    utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_point)
+    {
+        if (it == end) 
+            return NOT_ENOUGH_ROOM;
+        
+        code_point = utf8::internal::mask8(*it);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f);
+
+        return UTF8_OK;
+    }
+
+    template <typename octet_iterator>
+    utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point)
+    {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+            
+        code_point = utf8::internal::mask8(*it);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point += (*it) & 0x3f;
+
+        return UTF8_OK;
+    }
+
+    template <typename octet_iterator>
+    utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_point)
+    {
+        if (it == end)
+           return NOT_ENOUGH_ROOM;
+
+        code_point = utf8::internal::mask8(*it);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point += (utf8::internal::mask8(*it) << 6) & 0xfff;
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point += (*it) & 0x3f;
+
+        return UTF8_OK;
+    }
+
+    #undef UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR
+
+    template <typename octet_iterator>
+    utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_point)
+    {
+        // Save the original value of it so we can go back in case of failure
+        // Of course, it does not make much sense with i.e. stream iterators
+        octet_iterator original_it = it;
+
+        uint32_t cp = 0;
+        // Determine the sequence length based on the lead octet
+        typedef typename std::iterator_traits<octet_iterator>::difference_type octet_difference_type;
+        const octet_difference_type length = utf8::internal::sequence_length(it);
+
+        // Get trail octets and calculate the code point
+        utf_error err = UTF8_OK;
+        switch (length) {
+            case 0: 
+                return INVALID_LEAD;
+            case 1:
+                err = utf8::internal::get_sequence_1(it, end, cp);
+                break;
+            case 2:
+                err = utf8::internal::get_sequence_2(it, end, cp);
+            break;
+            case 3:
+                err = utf8::internal::get_sequence_3(it, end, cp);
+            break;
+            case 4:
+                err = utf8::internal::get_sequence_4(it, end, cp);
+            break;
+        }
+
+        if (err == UTF8_OK) {
+            // Decoding succeeded. Now, security checks...
+            if (utf8::internal::is_code_point_valid(cp)) {
+                if (!utf8::internal::is_overlong_sequence(cp, length)){
+                    // Passed! Return here.
+                    code_point = cp;
+                    ++it;
+                    return UTF8_OK;
+                }
+                else
+                    err = OVERLONG_SEQUENCE;
+            }
+            else 
+                err = INVALID_CODE_POINT;
+        }
+
+        // Failure branch - restore the original value of the iterator
+        it = original_it;
+        return err;
+    }
+
+    template <typename octet_iterator>
+    inline utf_error validate_next(octet_iterator& it, octet_iterator end) {
+        uint32_t ignored;
+        return utf8::internal::validate_next(it, end, ignored);
+    }
+
+} // namespace internal
+
+    /// The library API - functions intended to be called by the users
+
+    // Byte order mark
+    const uint8_t bom[] = {0xef, 0xbb, 0xbf};
+
+    template <typename octet_iterator>
+    octet_iterator find_invalid(octet_iterator start, octet_iterator end)
+    {
+        octet_iterator result = start;
+        while (result != end) {
+            utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end);
+            if (err_code != internal::UTF8_OK)
+                return result;
+        }
+        return result;
+    }
+
+    template <typename octet_iterator>
+    inline bool is_valid(octet_iterator start, octet_iterator end)
+    {
+        return (utf8::find_invalid(start, end) == end);
+    }
+
+    template <typename octet_iterator>
+    inline bool starts_with_bom (octet_iterator it, octet_iterator end)
+    {
+        return (
+            ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) &&
+            ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) &&
+            ((it != end) && (utf8::internal::mask8(*it))   == bom[2])
+           );
+    }
+	
+    //Deprecated in release 2.3 
+    template <typename octet_iterator>
+    inline bool is_bom (octet_iterator it)
+    {
+        return (
+            (utf8::internal::mask8(*it++)) == bom[0] &&
+            (utf8::internal::mask8(*it++)) == bom[1] &&
+            (utf8::internal::mask8(*it))   == bom[2]
+           );
+    }
+} // namespace utf8
+
+#endif // header guard
+
+
--- a/3rdparty/utf8/source/utf8/unchecked.h
+++ b/3rdparty/utf8/source/utf8/unchecked.h
@@ -0,0 +1,228 @@
+// Copyright 2006 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+#include "core.h"
+
+namespace utf8
+{
+    namespace unchecked 
+    {
+        template <typename octet_iterator>
+        octet_iterator append(uint32_t cp, octet_iterator result)
+        {
+            if (cp < 0x80)                        // one octet
+                *(result++) = static_cast<uint8_t>(cp);  
+            else if (cp < 0x800) {                // two octets
+                *(result++) = static_cast<uint8_t>((cp >> 6)          | 0xc0);
+                *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
+            }
+            else if (cp < 0x10000) {              // three octets
+                *(result++) = static_cast<uint8_t>((cp >> 12)         | 0xe0);
+                *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
+                *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
+            }
+            else {                                // four octets
+                *(result++) = static_cast<uint8_t>((cp >> 18)         | 0xf0);
+                *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)| 0x80);
+                *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
+                *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
+            }
+            return result;
+        }
+
+        template <typename octet_iterator>
+        uint32_t next(octet_iterator& it)
+        {
+            uint32_t cp = utf8::internal::mask8(*it);
+            typename std::iterator_traits<octet_iterator>::difference_type length = utf8::internal::sequence_length(it);
+            switch (length) {
+                case 1:
+                    break;
+                case 2:
+                    it++;
+                    cp = ((cp << 6) & 0x7ff) + ((*it) & 0x3f);
+                    break;
+                case 3:
+                    ++it; 
+                    cp = ((cp << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
+                    ++it;
+                    cp += (*it) & 0x3f;
+                    break;
+                case 4:
+                    ++it;
+                    cp = ((cp << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);                
+                    ++it;
+                    cp += (utf8::internal::mask8(*it) << 6) & 0xfff;
+                    ++it;
+                    cp += (*it) & 0x3f; 
+                    break;
+            }
+            ++it;
+            return cp;        
+        }
+
+        template <typename octet_iterator>
+        uint32_t peek_next(octet_iterator it)
+        {
+            return utf8::unchecked::next(it);    
+        }
+
+        template <typename octet_iterator>
+        uint32_t prior(octet_iterator& it)
+        {
+            while (utf8::internal::is_trail(*(--it))) ;
+            octet_iterator temp = it;
+            return utf8::unchecked::next(temp);
+        }
+
+        // Deprecated in versions that include prior, but only for the sake of consistency (see utf8::previous)
+        template <typename octet_iterator>
+        inline uint32_t previous(octet_iterator& it)
+        {
+            return utf8::unchecked::prior(it);
+        }
+
+        template <typename octet_iterator, typename distance_type>
+        void advance (octet_iterator& it, distance_type n)
+        {
+            for (distance_type i = 0; i < n; ++i)
+                utf8::unchecked::next(it);
+        }
+
+        template <typename octet_iterator>
+        typename std::iterator_traits<octet_iterator>::difference_type
+        distance (octet_iterator first, octet_iterator last)
+        {
+            typename std::iterator_traits<octet_iterator>::difference_type dist;
+            for (dist = 0; first < last; ++dist) 
+                utf8::unchecked::next(first);
+            return dist;
+        }
+
+        template <typename u16bit_iterator, typename octet_iterator>
+        octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
+        {       
+            while (start != end) {
+                uint32_t cp = utf8::internal::mask16(*start++);
+            // Take care of surrogate pairs first
+                if (utf8::internal::is_lead_surrogate(cp)) {
+                    uint32_t trail_surrogate = utf8::internal::mask16(*start++);
+                    cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
+                }
+                result = utf8::unchecked::append(cp, result);
+            }
+            return result;         
+        }
+
+        template <typename u16bit_iterator, typename octet_iterator>
+        u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
+        {
+            while (start < end) {
+                uint32_t cp = utf8::unchecked::next(start);
+                if (cp > 0xffff) { //make a surrogate pair
+                    *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
+                    *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
+                }
+                else
+                    *result++ = static_cast<uint16_t>(cp);
+            }
+            return result;
+        }
+
+        template <typename octet_iterator, typename u32bit_iterator>
+        octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)
+        {
+            while (start != end)
+                result = utf8::unchecked::append(*(start++), result);
+
+            return result;
+        }
+
+        template <typename octet_iterator, typename u32bit_iterator>
+        u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
+        {
+            while (start < end)
+                (*result++) = utf8::unchecked::next(start);
+
+            return result;
+        }
+
+        // The iterator class
+        template <typename octet_iterator>
+          class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> { 
+            octet_iterator it;
+            public:
+            iterator () {}
+            explicit iterator (const octet_iterator& octet_it): it(octet_it) {}
+            // the default "big three" are OK
+            octet_iterator base () const { return it; }
+            uint32_t operator * () const
+            {
+                octet_iterator temp = it;
+                return utf8::unchecked::next(temp);
+            }
+            bool operator == (const iterator& rhs) const 
+            { 
+                return (it == rhs.it);
+            }
+            bool operator != (const iterator& rhs) const
+            {
+                return !(operator == (rhs));
+            }
+            iterator& operator ++ () 
+            {
+                ::std::advance(it, utf8::internal::sequence_length(it));
+                return *this;
+            }
+            iterator operator ++ (int)
+            {
+                iterator temp = *this;
+                ::std::advance(it, utf8::internal::sequence_length(it));
+                return temp;
+            }  
+            iterator& operator -- ()
+            {
+                utf8::unchecked::prior(it);
+                return *this;
+            }
+            iterator operator -- (int)
+            {
+                iterator temp = *this;
+                utf8::unchecked::prior(it);
+                return temp;
+            }
+          }; // class iterator
+
+    } // namespace utf8::unchecked
+} // namespace utf8 
+
+
+#endif // header guard
+
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,12 +1,14 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.0)

-if(POLICY CMP0072)
-  cmake_policy(SET CMP0072 NEW)
+if(COMMAND cmake_policy)
+   if(POLICY CMP0054)
+       cmake_policy(SET CMP0054 NEW)
+   endif()
+   if(POLICY CMP0042)
+       cmake_policy(SET CMP0042 NEW)
+   endif()
 endif()

-if(POLICY CMP0093)
-  cmake_policy(SET CMP0093 NEW)
-endif()

 message(STATUS "CMAKE Build type: ${CMAKE_BUILD_TYPE}")
 # Set a default build type if none was specified
@@ -27,21 +29,27 @@ include (GenerateExportHeader)

 # only relevant for building shared libs but let's set it regardless
 set(CMAKE_OSX_RPATH 1)
-set(CMAKE_OSX_DEPLOYMENT_TARGET "10.12" CACHE STRING "Minimum OS X deployment version")

-set(CMAKE_CXX_STANDARD 17)
+# 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 simgear-version versionFile)
+file(READ version versionFile)
 string(STRIP ${versionFile} SIMGEAR_VERSION)

 project(SimGear VERSION ${SIMGEAR_VERSION} LANGUAGES C CXX)

-# add a dependency on the version file
+# 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_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS TRUE)
+set(FIND_LIBRARY_USE_LIB64_PATHS ON)

 # use simgear version also as the SO version (if building SOs)
 SET(SIMGEAR_SOVERSION ${SIMGEAR_VERSION})
@@ -54,12 +62,33 @@ if(InSourceBuild)
    message(WARNING  "  mkdir ../sgbuild && cd ../sgbuild && cmake ${CMAKE_SOURCE_DIR}")
 endif(InSourceBuild)

+#packaging
+SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
+SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
+SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simulation support libraries for FlightGear and related projects")
+SET(CPACK_PACKAGE_VENDOR "The FlightGear project")
+SET(CPACK_GENERATOR "TBZ2")
+SET(CPACK_INSTALL_CMAKE_PROJECTS  ${CMAKE_CURRENT_BINARY_DIR};SimGear;ALL;/)
+
+
+# split version string into components, note CMAKE_MATCH_0 is the entire regexp match
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CPACK_PACKAGE_VERSION ${SIMGEAR_VERSION} )
+set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
+set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+
+message(STATUS "version is ${CPACK_PACKAGE_VERSION_MAJOR} dot ${CPACK_PACKAGE_VERSION_MINOR} dot ${CPACK_PACKAGE_VERSION_PATCH}")
+
+set(CPACK_SOURCE_GENERATOR TBZ2)
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "simgear-${SIMGEAR_VERSION}" CACHE INTERNAL "tarball basename")
+set(CPACK_SOURCE_IGNORE_FILES
+  "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
+
+include (CPack)

 # We have some custom .cmake scripts not in the official distribution.
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules;${CMAKE_MODULE_PATH}")

-include(Packaging)
-
 # Change the default build type to something fast
 if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE Release CACHE STRING
@@ -90,61 +119,85 @@ set(SYSTEM_UDNS OFF)
 endif()

 option(SIMGEAR_HEADLESS "Set to ON to build SimGear without GUI/graphics support" OFF)
-option(ENABLE_CYCLONE   "Set to ON to build SimGear with Cyclone Data Distribution Service support" ON)
 option(ENABLE_RTI       "Set to ON to build SimGear with RTI support" OFF)
-option(ENABLE_GDAL      "Set to ON to build SimGear with GDAL 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_SHADERVG     "Set to ON to use SHaderVG instead of ShivaVG" OFF)
-option(USE_AEONWAVE     "Set to ON to use AeonWave instead of OpenAL" ON)
-option(USE_OPENALSOFT   "Set to ON to use OpenAL from OpenAL-soft" OFF)
-
+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_SIMD      "Enable SSE/SSE2 support for compilers" ON)
-option(ENABLE_SIMD_CODE	"Enable SSE/SSE2 support code for compilers" OFF)
-option(ENABLE_ASAN      "Set to ON to build SimGear with LLVM AddressSanitizer (ASan) support" OFF)
-option(ENABLE_VIDEO_RECORD "Set to ON to build SimGear with video recording" ON)
-
-if (NOT ENABLE_SIMD AND ENABLE_SIMD_CODE)
-  set(ENABLE_SIMD_CODE OFF)
-endif()
-
-if (USE_SHADERVG)
-  set(OPENVG ShaderVG)
-else()
-  set(OPENVG ShivaVG)
-endif()
-message(STATUS "OpenVG: ${OPENVG}")
+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)
-include (ExportDebugSymbols)

 # 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)
-  # override CMake default RelWithDebInfo flags. This is important to ensure
-  # good performance
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/Zi /O2 /Ob2 /D NDEBUG")
-  set(CMAKE_C_FLAGS_RELWITHDEBINFO "/Zi /O2 /Ob2 /D NDEBUG")
-endif ()
+  GET_FILENAME_COMPONENT(PARENT_DIR ${PROJECT_BINARY_DIR} PATH)
+  if (CMAKE_CL_64)
+    SET(TEST_3RDPARTY_DIR "${PARENT_DIR}/3rdparty.x64")
+  else (CMAKE_CL_64)
+    SET(TEST_3RDPARTY_DIR "${PARENT_DIR}/3rdparty")
+  endif (CMAKE_CL_64)
+  if (EXISTS ${TEST_3RDPARTY_DIR})
+    set(MSVC_3RDPARTY_ROOT ${PARENT_DIR} CACHE PATH "Location where the third-party dependencies are extracted")
+  else (EXISTS ${TEST_3RDPARTY_DIR})
+    set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+  endif (EXISTS ${TEST_3RDPARTY_DIR})
+else (MSVC)
+  set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+endif (MSVC)

-# Setup MSVC 3rd party directories
-include( ConfigureMsvc3rdParty )
+if (MSVC AND MSVC_3RDPARTY_ROOT)
+  message(STATUS "3rdparty files located in ${MSVC_3RDPARTY_ROOT}")
+
+  set( OSG_MSVC "msvc" )
+  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 )
+  else (CMAKE_CL_64)
+      set( MSVC_3RDPARTY_DIR 3rdParty )
+  endif (CMAKE_CL_64)
+
+  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)
+
+  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)
 endif()

-find_package(Threads REQUIRED)
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux" OR ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
+    find_package(Threads REQUIRED)
+endif()

 find_package(Boost REQUIRED)
-set (BOOST_CXX_FLAGS "-DBOOST_BIMAP_DISABLE_SERIALIZATION -DBOOST_NO_STDLIB_CONFIG -DBOOST_NO_AUTO_PTR -DBOOST_NO_CXX98_BINDERS")
+set (BOOST_CXX_FLAGS "-DBOOST_BIMAP_DISABLE_SERIALIZATION")
 include(BoostTestTargets)

-set(SG_SOUND_USES_OPENALSOFT OFF) # default to off
-
 if(SIMGEAR_HEADLESS)
    message(STATUS "SimGear mode: HEADLESS")
    set(ENABLE_SOUND 0)
@@ -154,35 +207,15 @@ else()

    if (ENABLE_SOUND)
        if (USE_AEONWAVE)
-            find_package(AAX)
-        endif()
-
-        if(NOT AAX_FOUND)
-            set(USE_AEONWAVE FALSE)
-            if (USE_OPENALSOFT)
-                message(STATUS "Sound requested to use OpenAL-soft: ensure Config.cmake files are in CMAKE_PREFIX_PATH")
-               find_package(OpenAL REQUIRED CONFIG)
-               if (TARGET OpenAL::OpenAL)
-                set(SG_SOUND_USES_OPENALSOFT ON)
-               endif()
-            else()
-              # regular OpenAL is found via the CMake distro-suppling FindOpenAL
-              find_package(OpenAL REQUIRED)
-            endif()
-
-            message(STATUS "OpenAL: ${OPENAL_LIBRARY}")
-        endif()
-
-        if(AAX_FOUND)
-            message(STATUS "Sound support: AeonWave")
-        elseif (TARGET OpenAL::OpenAL)
-           message(STATUS "Sound support: OpenAL-soft")
+            find_package(AAX COMPONENTS aax REQUIRED)
        else()
-            message(STATUS "Sound support: OpenAL (from system)")
+            find_package(OpenAL REQUIRED)
        endif()
+
+        message(STATUS "Sound support: ENABLED")
    endif(ENABLE_SOUND)

-    find_package(OpenSceneGraph 3.6.0 REQUIRED osgText osgSim osgDB osgParticle osgGA osgViewer osgUtil osgTerrain)
+    find_package(OpenSceneGraph 3.2.0 REQUIRED osgText osgSim osgDB osgParticle osgGA osgViewer osgUtil)

    if (MSVC)
      set(CMAKE_REQUIRED_INCLUDES ${OPENSCENEGRAPH_INCLUDE_DIRS})
@@ -200,15 +233,7 @@ else()
    endif()
 endif(SIMGEAR_HEADLESS)

-if(${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
-    # As of 2020-08-01, OpenBSD's system zlib is slightly old, but it's usable
-    # with a workaround in simgear/io/iostreams/gzfstream.cxx.
-    find_package(ZLIB 1.2.3 REQUIRED)
-else()
-    find_package(ZLIB 1.2.4 REQUIRED)
-endif()
-
-find_package(LibLZMA REQUIRED)
+find_package(ZLIB 1.2.4 REQUIRED)
 find_package(CURL REQUIRED)

 if (SYSTEM_EXPAT)
@@ -218,86 +243,114 @@ if (SYSTEM_EXPAT)

 else()
    message(STATUS "Using built-in expat code")
+    # XML_STATIC is important to avoid sg_expat_external.h
+    # declaring symbols as declspec(import)
+    add_definitions(-DHAVE_EXPAT_CONFIG_H -DXML_STATIC)
+    set(EXPAT_INCLUDE_DIRS
+	    ${PROJECT_SOURCE_DIR}/3rdparty/expat
+	    ${PROJECT_BINARY_DIR}/3rdparty/expat)
 endif(SYSTEM_EXPAT)

+check_include_file(inttypes.h HAVE_INTTYPES_H)
+check_include_file(sys/time.h HAVE_SYS_TIME_H)
+check_include_file(unistd.h HAVE_UNISTD_H)
+check_include_file(windows.h HAVE_WINDOWS_H)
+
+if(HAVE_INTTYPES_H)
+  # ShivaVG needs inttypes.h
+  add_definitions(-DHAVE_INTTYPES_H)
+endif()
+
 if(ENABLE_RTI)
-    find_package(PkgConfig)
-    if(PKG_CONFIG_FOUND)
-      SET(ENV{PKG_CONFIG_PATH} "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/pkgconfig:$ENV{PKG_CONFIG_PATH}")
-      pkg_check_modules(RTI IMPORTED_TARGET hla-rti13)
-    endif(PKG_CONFIG_FOUND)
-    if(RTI_FOUND)
-      message(STATUS "RTI: ENABLED")
-    else()
-      message(STATUS "RTI: DISABLED")
-    endif(RTI_FOUND)
+    # See if we have any rti library variant installed
+    message(STATUS "RTI: ENABLED")
+    find_package(RTI)
 else()
    message(STATUS "RTI: DISABLED")
 endif(ENABLE_RTI)

-if(ENABLE_CYCLONE)
-    find_package(CycloneDDS QUIET)
-    if (CycloneDDS_FOUND)
-        message(STATUS "Data Distribution Service support: CycloneDDS")
-        set(SG_HAVE_DDS 1)
-    else(CycloneDDS_FOUND)
-        message(STATUS "Data Distribution Service support: DISBLED")
-    endif(CycloneDDS_FOUND)
-endif(ENABLE_CYCLONE)
+check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
+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(ENABLE_GDAL)
-    find_package(GDAL 2.0.0 REQUIRED)
-endif(ENABLE_GDAL)
-
-
-if (ENABLE_VIDEO_RECORD)
-  find_package(FFmpeg COMPONENTS AVCODEC AVFORMAT AVUTIL SWSCALE)
-  if (FFmpeg_FOUND)
-  # set this so it's picked up in simgear_config.h
-    set(SG_FFMPEG 1)
-  else()
-    message(STATUS "Video recording was requested, but required FFmpeg/avcodec libaries not found")
+if (NOT MSVC)
+  check_function_exists(timegm HAVE_TIMEGM)
+  if (NOT HAVE_TIMEGM)
+    message(FATAL_ERROR "Non-Windows platforms must support timegm()")
  endif()
 endif()

-include(CheckPOSIXFeatures)
+if(HAVE_UNISTD_H)
+    set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
+    check_cxx_source_compiles(
+       "#include <unistd.h>
+        #if !defined(_POSIX_TIMERS) || (0 >= _POSIX_TIMERS)
+            #error clock_gettime is not supported
+        #endif
+
+        int main() { return 0; }
+        "
+        HAVE_CLOCK_GETTIME)
+endif(HAVE_UNISTD_H)
+
+set(RT_LIBRARY "")
+if(HAVE_CLOCK_GETTIME)
+    check_library_exists(rt clock_gettime "" HAVE_RT)
+    if(HAVE_RT)
+        set(RT_LIBRARY rt)
+    endif(HAVE_RT)
+endif(HAVE_CLOCK_GETTIME)
+
+set(DL_LIBRARY "")
+check_cxx_source_compiles(
+    "#include <dlfcn.h>
+    int main(void) {
+        return 0;
+    }
+    "
+    HAVE_DLFCN_H)
+
+if(HAVE_DLFCN_H)
+    check_library_exists(dl dlerror "" HAVE_DL)
+    if(HAVE_DL)
+        set(DL_LIBRARY "dl")
+    endif()
+endif()

 SET(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "add a postfix, usually 'd' on windows")
 SET(CMAKE_RELEASE_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
 SET(CMAKE_RELWITHDEBINFO_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
 SET(CMAKE_MINSIZEREL_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")

-# Check if the <regex> implementation in the C++ standard library is usable.
-# This is necessary because g++ 4.8 lies about its C++11 compliance: its
-# <regex> is utterly unusable, cf. [1].
-# The big preprocessor test essentially comes from [2], and gcc upstream devs
-# appear to back it (see comments following [2], as well as [3]).
-#
-#   [1] https://stackoverflow.com/a/12665408/4756009
-#   [2] https://stackoverflow.com/a/41186162/4756009
-#   [3] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78905
+# isnan might not be real symbol, so can't check using function_exists
 check_cxx_source_compiles(
-    "#include <regex>
+    "#include <cstdlib>
+    int main() { return std::isnan(0.0);} "
+    HAVE_STD_ISNAN)

-     int main() {
-       #if __cplusplus >= 201103L &&                             \
-           (!defined(__GLIBCXX__)                         ||     \
-            (__cplusplus >= 201402L)                      ||     \
-            defined(_GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT) ||     \
-            defined(_GLIBCXX_REGEX_STATE_LIMIT)           ||     \
-            (defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE > 4))
-       #else
-         nullptr = void; // intentionally trigger a compilation error
-       #endif
-     }"
-    HAVE_WORKING_STD_REGEX)
+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 -fPIC")
-    set(WARNING_FLAGS_C   "-Wall -fPIC")
+    set(WARNING_FLAGS_CXX "-Wall")
+    set(WARNING_FLAGS_C   "-Wall")

-    if (X86 OR X86_64)
-        set(SIMD_COMPILER_FLAGS "-msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
+    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
@@ -306,33 +359,26 @@ if(CMAKE_COMPILER_IS_GNUCXX)
    check_cxx_source_compiles(
       "int main() { unsigned mValue; return __sync_add_and_fetch(&mValue, 1); }"
        GCC_ATOMIC_BUILTINS_FOUND)
-
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -g -DNDEBUG")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO  "-O3 -g -DNDEBUG")
 endif(CMAKE_COMPILER_IS_GNUCXX)

 if (CLANG)
    # Boost redeclares class members
-    set(WARNING_FLAGS_CXX "-Wall -fPIC -Wno-overloaded-virtual -Wno-redeclared-class-member")
-    set(WARNING_FLAGS_C   "-Wall -fPIC")
+    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++")
    # fix Boost compilation :(
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
-    # override CMake default RelWithDebInfo flags.
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -g -DNDEBUG")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO  "-O3 -g -DNDEBUG")

-    set(SIMD_COMPILER_FLAGS "-msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
-endif()
+    if (CMAKE_VERSION VERSION_LESS 3.1)
+       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+    endif()

-if (ENABLE_ASAN)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address")
-
-  # needed for check_cxx_source_compiles
-  set(CMAKE_REQUIRED_LINK_OPTIONS "-fsanitize=address")
+    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")
@@ -341,11 +387,6 @@ if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    if(HAS_NOWARN_UNUSED_TYPEDEFS)
        set(WARNING_FLAGS_CXX " ${WARNING_FLAGS_CXX} -Wno-unused-local-typedefs")
    endif()
-
-    check_cxx_compiler_flag(-Wno-inconsistent-missing-override HAS_NOWARN_MISSING_OVERRIDE)
-    if(HAS_NOWARN_MISSING_OVERRIDE)
-        set(WARNING_FLAGS_CXX " ${WARNING_FLAGS_CXX} -Wno-inconsistent-missing-override")
-    endif()
 endif()

 if(WIN32)
@@ -355,9 +396,15 @@ if(WIN32)
    endif()

    if(MSVC)
-        set(MSVC_FLAGS "-D_HAS_STD_BYTE=0 -DWIN32 -DNOMINMAX -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D__CRT_NONSTDC_NO_WARNINGS /MP /bigobj")
-        if (X86)
-          set(SIMD_COMPILER_FLAGS "/arch:SSE /arch:SSE2")
+        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()

        if (NOT OSG_FSTREAM_EXPORT_FIXED)
@@ -366,6 +413,11 @@ if(WIN32)
          # symbols. Suspect this may be an OSG-DB export bug
            set( MSVC_LD_FLAGS "/FORCE:MULTIPLE" )
        endif ()
+
+        if (${MSVC_VERSION} GREATER 1899)
+            # needed for debug builds with VS2015
+            set( MSVC_FLAGS "${MSVC_FLAGS} /bigobj" )
+        endif()
    endif(MSVC)

    # assumed on Windows
@@ -376,25 +428,13 @@ if(WIN32)
    set( RT_LIBRARY "winmm" )
 endif(WIN32)

-# append the SIMD flags if requested
-if (ENABLE_SIMD)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SIMD_COMPILER_FLAGS}")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SIMD_COMPILER_FLAGS}")
-
-  # set for multi-configuration generators
-  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${SIMD_COMPILER_FLAGS}")
-  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${SIMD_COMPILER_FLAGS}")
-
-  set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} ${SIMD_COMPILER_FLAGS}")
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${SIMD_COMPILER_FLAGS}")
-endif()
-
-
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS_C} ${MSVC_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS_CXX} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MSVC_LD_FLAGS}")

-include(CheckCXXFeatures)
+# use BEFORE to ensure local directories are used first,
+# ahead of system-installed libs
+include_directories(BEFORE ${PROJECT_BINARY_DIR}/simgear)

 add_definitions(-DHAVE_CONFIG_H)

@@ -405,18 +445,48 @@ configure_file (
  "${PROJECT_BINARY_DIR}/simgear/simgear_config.h"
  )

-include (Dart)
-enable_testing()
-include(AddSimGearTest) # helper to setup a test
+if(ENABLE_TESTS)
+    # enable CTest / make test target
+    message(STATUS "Tests: ENABLED")
+
+    include (Dart)
+    enable_testing()
+else()
+    message(STATUS "Tests: DISABLED")
+endif(ENABLE_TESTS)
+
+# always set TEST_LIBS as it is also used by other tools/applications
+set(TEST_LIBS_INTERNAL_CORE
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${ZLIB_LIBRARY}
+    ${WINSOCK_LIBRARY}
+    ${SHLWAPI_LIBRARY}
+    ${RT_LIBRARY}
+    ${DL_LIBRARY}
+    ${COCOA_LIBRARY}
+    ${CURL_LIBRARIES})
+set(TEST_LIBS SimGearCore ${TEST_LIBS_INTERNAL_CORE})
+
+if(NOT SIMGEAR_HEADLESS)
+    set(TEST_LIBS SimGearScene ${OPENGL_LIBRARIES} ${TEST_LIBS})
+endif()

 install (FILES ${PROJECT_BINARY_DIR}/simgear/simgear_config.h  DESTINATION include/simgear/)

-if(SYSTEM_UDNS)
-    message(STATUS "Requested to use system udns library, forcing SIMGEAR_SHARED to true")
-    set(SIMGEAR_SHARED ON)
-    find_package(Udns REQUIRED)
+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()

+
 add_subdirectory(3rdparty)
 add_subdirectory(simgear)

--- a/CMakeModules/AddSimGearTest.cmake
+++ b/CMakeModules/AddSimGearTest.cmake
@@ -1,30 +0,0 @@
-
-function(add_simgear_test _name _sources)
-    add_executable(${_name} ${_sources})
-    target_link_libraries(${_name} SimGearCore Threads::Threads)
-
-    # for simgear_config.h
-    target_include_directories(${_name} PRIVATE ${PROJECT_BINARY_DIR}/simgear)
-endfunction()
-
-
-function(add_simgear_autotest _name _sources)
-    add_executable(${_name} ${_sources})
-    target_link_libraries(${_name} SimGearCore Threads::Threads)
-
-    # for simgear_config.h
-    target_include_directories(${_name} PRIVATE ${PROJECT_BINARY_DIR}/simgear)
-
-    add_test(${_name} ${EXECUTABLE_OUTPUT_PATH}/${_name})
-endfunction()
-
-
-function(add_simgear_scene_autotest _name _sources)
-    add_executable(${_name} ${_sources})
-    target_link_libraries(${_name} SimGearScene Threads::Threads)
-
-    # for simgear_config.h
-    target_include_directories(${_name} PRIVATE ${PROJECT_BINARY_DIR}/simgear)
-
-    add_test(${_name} ${EXECUTABLE_OUTPUT_PATH}/${_name})
-endfunction()
--- a/CMakeModules/BoostTestTargets.cmake
+++ b/CMakeModules/BoostTestTargets.cmake
@@ -46,17 +46,11 @@ set(BOOST_TEST_TARGET_PREFIX "test")
 if(NOT Boost_FOUND)
 	find_package(Boost 1.34.0 QUIET)
 endif()
-
-if (NOT Boost_VERSION_MACRO)
-	# Compatibility with pre CMP0093 (CMake 3.15)
-	set(Boost_VERSION_MACRO ${Boost_VERSION})
-endif()
-
-if("${Boost_VERSION_MACRO}0" LESS "1034000")
+if("${Boost_VERSION}0" LESS "1034000")
 	set(_shared_msg
 		"NOTE: boost::test-based targets and tests cannot "
 		"be added: boost >= 1.34.0 required but not found. "
-		"(found: '${Boost_VERSION_MACRO}'; want >=103400) ")
+		"(found: '${Boost_VERSION}'; want >=103400) ")
 	if(ENABLE_TESTS)
 		message(FATAL_ERROR
 			${_shared_msg}
@@ -72,7 +66,7 @@ endif()
 include(GetForceIncludeDefinitions)
 include(CopyResourcesToBuildTree)

-if(Boost_FOUND AND NOT "${Boost_VERSION_MACRO}0" LESS "1034000")
+if(Boost_FOUND AND NOT "${Boost_VERSION}0" LESS "1034000")
 	set(_boosttesttargets_libs)
 	set(_boostConfig "BoostTestTargetsIncluded.h")
 	if(NOT Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
@@ -86,7 +80,7 @@ if(Boost_FOUND AND NOT "${Boost_VERSION_MACRO}0" LESS "1034000")
 			set(_boostConfig "BoostTestTargetsDynamic.h")
 		endif()
 	endif()
-	get_filename_component(_moddir ${CMAKE_CURRENT_LIST_FILE} DIRECTORY)
+	get_filename_component(_moddir ${CMAKE_CURRENT_LIST_FILE} PATH)
 	configure_file("${_moddir}/${_boostConfig}"
 		"${CMAKE_CURRENT_BINARY_DIR}/BoostTestTargetConfig.h"
 		COPYONLY)
@@ -135,7 +129,7 @@ function(add_boost_test _name)
 			"Syntax error in use of add_boost_test: at least one source file required!")
 	endif()

-	if(Boost_FOUND AND NOT "${Boost_VERSION_MACRO}0" LESS "1034000")
+	if(Boost_FOUND AND NOT "${Boost_VERSION}0" LESS "1034000")

 		include_directories(${Boost_INCLUDE_DIRS})

@@ -227,7 +221,7 @@ function(add_boost_test _name)
 			set(_test_command ${_target_name})
 		endif()

-		if(TESTS AND ( "${Boost_VERSION_MACRO}" VERSION_GREATER "103799" ))
+		if(TESTS AND ( "${Boost_VERSION}" VERSION_GREATER "103799" ))
 			foreach(_test ${TESTS})
 				add_test(
 					${_name}-${_test}
--- a/CMakeModules/CheckCXXFeatures.cmake
+++ b/CMakeModules/CheckCXXFeatures.cmake
@@ -1,30 +0,0 @@
-check_cxx_source_compiles("
-  #include <utility>
-  #include <type_traits>
-  std::make_index_sequence<0> t;
-  int main() {}" HAVE_STD_INDEX_SEQUENCE
-)
-
-check_cxx_source_compiles("
-  #include <type_traits>
-  std::remove_cv_t<const int> t;
-  int main() {}" HAVE_STD_REMOVE_CV_T
-)
-
-check_cxx_source_compiles("
-  #include <type_traits>
-  std::remove_cvref_t<const int&> t;
-  int main() {}" HAVE_STD_REMOVE_CVREF_T
-)
-
-check_cxx_source_compiles("
-  #include <type_traits>
-  std::enable_if_t<true, int> t;
-  int main() {}" HAVE_STD_ENABLE_IF_T
-)
-
-check_cxx_source_compiles("
-  #include <type_traits>
-  std::bool_constant<true> t;
-  int main() {}" HAVE_STD_BOOL_CONSTANT
-)
--- a/CMakeModules/CheckPOSIXFeatures.cmake
+++ b/CMakeModules/CheckPOSIXFeatures.cmake
@@ -1,55 +0,0 @@
-check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
-check_function_exists(rint HAVE_RINT)
-check_function_exists(mkdtemp HAVE_MKDTEMP)
-check_function_exists(bcopy HAVE_BCOPY)
-check_function_exists(mmap HAVE_MMAP)
-
-check_include_file(inttypes.h HAVE_INTTYPES_H)
-check_include_file(sys/time.h HAVE_SYS_TIME_H)
-check_include_file(unistd.h HAVE_UNISTD_H)
-check_include_file(windows.h HAVE_WINDOWS_H)
-
-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(
-       "#include <unistd.h>
-        #if !defined(_POSIX_TIMERS) || (0 >= _POSIX_TIMERS)
-            #error clock_gettime is not supported
-        #endif
-
-        int main() { return 0; }
-        "
-        HAVE_CLOCK_GETTIME)
-endif(HAVE_UNISTD_H)
-
-set(RT_LIBRARY "")
-if(HAVE_CLOCK_GETTIME)
-    check_library_exists(rt clock_gettime "" HAVE_RT)
-    if(HAVE_RT)
-        set(RT_LIBRARY rt)
-    endif(HAVE_RT)
-endif(HAVE_CLOCK_GETTIME)
-
-set(DL_LIBRARY "")
-check_cxx_source_compiles(
-    "#include <dlfcn.h>
-    int main(void) {
-        return 0;
-    }
-    "
-    HAVE_DLFCN_H)
-
-if(HAVE_DLFCN_H)
-    check_library_exists(dl dlerror "" HAVE_DL)
-    if(HAVE_DL)
-        set(DL_LIBRARY "dl")
-    endif()
-endif()
-
--- a/CMakeModules/ConfigureMsvc3rdParty.cmake
+++ b/CMakeModules/ConfigureMsvc3rdParty.cmake
@@ -1,132 +0,0 @@
-# ConfigureMsvc3rdParty.cmake - Configure 3rd Party Library Paths on Windows
-
-# we want to handle various cases here:
-# fgmeta layout, where windows-3rd-party is a sibling of our flightgear source dir
-#  - this should work with no manual options
-# explicitly specifying MSVC_3RDPARTY_ROOT: we'll select a subdir based on MSVC version
-# and architecture. We want to allow for people specify various paths here:
-# - path to windows-3rd-party
-# - path to an MSVC versioned subdir, eg -DMSVC_3RDPARTY_ROOT=C:\FGFS\windows-3rd-party\msvc140
-# - path to an architecture specific subdir, eg -DMSVC_3RDPARTY_ROOT=C:\FGFS\windows-3rd-party\msvc140\3rdparty.x64
-
-set(_FOUND_3RDPARTY_DIR "NOTFOUND")
-set(_FOUND_BOOST_INCLUDE_DIR "NOTFOUND")
-
-# try various suffixes of a base directory, and
-# set the variables above on success
-function(_check_candidate_msvc_path pathToCheck)
-    unset (_freeTypeHeader CACHE )
-    unset (_zlibDll CACHE )
-    unset (_boostHeaders CACHE )
-
-    find_path(_freeTypeHeader include/ft2build.h
-        PATHS 
-            ${pathToCheck}
-        PATH_SUFFIXES
-            ${ARCH_SUBDIR_NAME}
-            ${MSVC_SUBDIR_NAME}/${ARCH_SUBDIR_NAME}
-            ${COMPAT_SUBDIR_NAME}/${ARCH_SUBDIR_NAME}
-        NO_DEFAULT_PATH
-    )
-
-    find_path(_zlibDll bin/zlib.dll
-        PATHS 
-            ${pathToCheck}
-        PATH_SUFFIXES
-            ${ARCH_SUBDIR_NAME}
-            ${MSVC_SUBDIR_NAME}/${ARCH_SUBDIR_NAME}
-            ${COMPAT_SUBDIR_NAME}/${ARCH_SUBDIR_NAME}
-        NO_DEFAULT_PATH
-    )
-
-    find_path(_boostHeaders boost/atomic.hpp
-        PATHS 
-            ${pathToCheck}
-        NO_DEFAULT_PATH
-    )
-
-    if (_freeTypeHeader AND _zlibDll)
-        set(_FOUND_3RDPARTY_DIR "${_freeTypeHeader}" PARENT_SCOPE)
-
-        if (_boostHeaders) 
-            set(_FOUND_BOOST_INCLUDE_DIR "${_boostHeaders}" PARENT_SCOPE)
-        endif()
-    endif()
-endfunction()
-
-
-if (MSVC)
-    # compute values for the compiler and arch subdirs
-    string(SUBSTRING ${MSVC_VERSION} 0 2 MSVC_VERSION_MAJOR)
-    string(SUBSTRING ${MSVC_VERSION} 2 2 MSVC_VERSION_MINOR)
-
-    if (${MSVC_VERSION_MAJOR} EQUAL "19")
-        if (${MSVC_VERSION_MINOR} EQUAL "00")
-            set( MSVC_SUBDIR_NAME msvc140 )
-        else ()
-            set( MSVC_SUBDIR_NAME msvc141 )
-            set( COMPAT_SUBDIR_NAME msvc140 )
-        endif()
-    else ()
-        message(FATAL_ERROR "Visual Studio 2017 is required")
-    endif ()
-
-    if (CMAKE_CL_64)
-        SET(ARCH_SUBDIR_NAME "3rdParty.x64")
-    else (CMAKE_CL_64)
-        SET(ARCH_SUBDIR_NAME "3rdParty")
-    endif (CMAKE_CL_64)
-
-    
-    # try the explicitly specified value first
-    if (EXISTS ${MSVC_3RDPARTY_ROOT})
-        _check_candidate_msvc_path("${MSVC_3RDPARTY_ROOT}")
-    endif()
-
-    # then try the fgmeta setup: look for a windows-3rdparty sibling of
-    # our source dir
-    get_filename_component(PARENT_SOURCE_DIR ${PROJECT_SOURCE_DIR} DIRECTORY)
-    get_filename_component(PARENT_BINARY_DIR ${PROJECT_BINARY_DIR} DIRECTORY)
-
-
-    if (NOT _FOUND_3RDPARTY_DIR AND EXISTS "${PARENT_SOURCE_DIR}/windows-3rd-party")
-        message(STATUS "Trying src 3rdparty")
-        _check_candidate_msvc_path("${PARENT_SOURCE_DIR}/windows-3rd-party")
-    endif()
-
-    if (NOT _FOUND_3RDPARTY_DIR AND EXISTS "${PARENT_BINARY_DIR}/windows-3rd-party")
-        message(STATUS "Trying bin 3rdparty")
-        _check_candidate_msvc_path("${PARENT_BINARY_DIR}/windows-3rd-party")
-    endif()
-
-    # try the Jenkins setup, whre the arch dir is copied into the WORKSPACE
-    if (NOT _FOUND_3RDPARTY_DIR AND EXISTS "${PARENT_BINARY_DIR}/${ARCH_SUBDIR_NAME}")
-        message(STATUS "Trying arch subdir ${PARENT_BINARY_DIR}/${ARCH_SUBDIR_NAME}")
-        _check_candidate_msvc_path("${PARENT_BINARY_DIR}/${ARCH_SUBDIR_NAME}")
-    endif()
-
-    if (NOT _FOUND_3RDPARTY_DIR)
-        message(WARNING "Failed to find the Windows 3rdparty files at all.")
-        set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
-    endif()
-
-else (MSVC)
-    set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
-endif (MSVC)
-
-if (MSVC AND _FOUND_3RDPARTY_DIR)
-    message(STATUS "3rdparty files located in ${_FOUND_3RDPARTY_DIR}")
-    list(APPEND CMAKE_PREFIX_PATH ${_FOUND_3RDPARTY_DIR})
-    set(FINAL_MSVC_3RDPARTY_DIR ${_FOUND_3RDPARTY_DIR})
-
-    if (CMAKE_CL_64)
-		set( BOOST_LIB lib64 )
-    else (CMAKE_CL_64)
-	    set( BOOST_LIB lib )
-    endif (CMAKE_CL_64)
-
-    if(NOT BOOST_INCLUDEDIR AND _FOUND_BOOST_INCLUDE_DIR)
-        set(BOOST_INCLUDEDIR ${_FOUND_BOOST_INCLUDE_DIR})
-        message(STATUS "found Boost headers at ${_FOUND_BOOST_INCLUDE_DIR}")
-      endif()
-endif ()
--- a/CMakeModules/CopyResourcesToBuildTree.cmake
+++ b/CMakeModules/CopyResourcesToBuildTree.cmake
@@ -30,12 +30,12 @@ function(copy_resources_to_build_tree _target)
 	endif()

 	get_target_property(_path ${_target} LOCATION)
-	get_filename_component(_path "${_path}" DIRECTORY)
+	get_filename_component(_path "${_path}" PATH)

 	if(NOT MSVC AND NOT "${CMAKE_GENERATOR}" MATCHES "Makefiles")
 		foreach(_config ${CMAKE_CONFIGURATION_TYPES})
 			get_target_property(_path${_config} ${_target} LOCATION_${_config})
-			get_filename_component(_path${_config} "${_path${_config}}" DIRECTORY)
+			get_filename_component(_path${_config} "${_path${_config}}" PATH)
 			add_custom_command(TARGET ${_target}
 						POST_BUILD
 						COMMAND
--- a/CMakeModules/ExportDebugSymbols.cmake
+++ b/CMakeModules/ExportDebugSymbols.cmake
@@ -1,26 +0,0 @@
-
-
-# placehodler target for other ones to depend upon
-add_custom_target(
-    debug_symbols
-)
-
-function(export_debug_symbols target)
-
-    if (NOT SIMGEAR_SHARED)
-        return()
-    endif()
-
-    if (APPLE)
-        add_custom_target(${target}.dSYM
-            COMMENT "Generating dSYM files for ${target}"
-            COMMAND dsymutil --out=${target}.dSYM $<TARGET_FILE:${target}>
-            DEPENDS $<TARGET_FILE:${target}>
-        ) 
-
-        install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${target}.dSYM DESTINATION symbols OPTIONAL)
-
-        add_dependencies(debug_symbols ${target}.dSYM)
-    endif()
-
-endfunction()
--- a/CMakeModules/FindAAX.cmake
+++ b/CMakeModules/FindAAX.cmake
@@ -1,74 +1,48 @@
-# Try to find AAX (AeonWave)
+# Locate AAX
 # This module defines
-#
-# AAX_FOUND - if false, do not try to link to AAX
-# AAX_INCLUDE_DIR - where to find the headers
-# AAX_LIBRARY - Link these to use AAX
-#
-# Copyright (C) 2016-2018 by Erik Hofman.
-# Copyright (C) 2016-2018 by Adalin B.V.
+# 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.
 #
-# This file is Public Domain (www.unlicense.org)
-# This is free and unencumbered software released into the public domain.
+# Created by Erik Hofman.

-if (AAX_LIBRARY AND AAX_INCLUDE_DIR)
-  # in cache already
-  set(AAX_FOUND TRUE)
-else()
-  find_path(AAX_INCLUDE_DIR aax/aax.h
-    HINTS
-    $ENV{AAXDIR}
-    $ENV{ProgramFiles}/aax
-    $ENV{ProgramFiles}/AeonWave
-    $ENV{ProgramFiles}/Adalin/AeonWave
-    ${CMAKE_SOURCE_DIR}/aax
-    PATH_SUFFIXES include
-    PATHS
-    ~/Library/Frameworks
-    /Library/Frameworks
-    /usr/local
-    /usr
-    /opt
-  )
+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 libAAX
-    HINTS
-    $ENV{AAXDIR}
-    $ENV{ProgramFiles}/AAX
-    $ENV{ProgramFiles}/AeonWave
-    $ENV{ProgramFiles}/Adalin/AeonWave
-    ${CMAKE_BUILD_DIR}/aax
-    PATH_SUFFIXES lib64 lib lib/${CMAKE_LIBRARY_ARCHITECTURE} libs64 libs libs/Win32 libs/Win64 bin
-    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_DEFINITIONS "")
-  if (AAX_LIBRARY AND AAX_INCLUDE_DIR)
-    set(AAX_FOUND TRUE)
-  endif()
-
-  if (AAX_FOUND)
-    if (NOT Udns_FIND_QUIETLY)
-      message(STATUS "Found AeonWave: ${AAX_LIBRARY}")
-    endif ()
-  else ()
-    if (Udns_FIND_REQUIRED)
-      message(FATAL_ERROR "Could not find AeonWave")
-    endif ()
-  endif ()
-
-  # show the AAX_INCLUDE_DIR and AAX_LIBRARY variables only in the advanced view
-  mark_as_advanced(AAX_INCLUDE_DIR AAX_LIBRARY)
-
-endif()
+SET(AAX_FOUND "NO")
+IF(AAX_LIBRARY AND AAX_INCLUDE_DIR)
+  SET(AAX_FOUND "YES")
+ENDIF(AAX_LIBRARY AND AAX_INCLUDE_DIR)

--- a/CMakeModules/FindCURL.cmake
+++ b/CMakeModules/FindCURL.cmake
@@ -1,203 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindCURL
--------
-
-Find the native CURL headers and libraries.
-
-This module accept optional COMPONENTS to check supported features and
-protocols::
-
-  PROTOCOLS: ICT FILE FTP FTPS GOPHER HTTP HTTPS IMAP IMAPS LDAP LDAPS POP3
-             POP3S RTMP RTSP SCP SFTP SMB SMBS SMTP SMTPS TELNET TFTP
-  FEATURES:  SSL IPv6 UnixSockets libz AsynchDNS IDN GSS-API PSL SPNEGO
-             Kerberos NTLM NTLM_WB TLS-SRP HTTP2 HTTPS-proxy
-
-IMPORTED Targets
-^^^^^^^^^^^^^^^^
-
-This module defines :prop_tgt:`IMPORTED` target ``CURL::libcurl``, if
-curl has been found.
-
-Result Variables
-^^^^^^^^^^^^^^^^
-
-This module defines the following variables:
-
-``CURL_FOUND``
-  "True" if ``curl`` found.
-
-``CURL_INCLUDE_DIRS``
-  where to find ``curl``/``curl.h``, etc.
-
-``CURL_LIBRARIES``
-  List of libraries when using ``curl``.
-
-``CURL_VERSION_STRING``
-  The version of ``curl`` found.
-
-CURL CMake
-^^^^^^^^^^
-
-If CURL was built using the CMake buildsystem then it provides its own
-``CURLConfig.cmake`` file for use with the :command:`find_package` command's
-config mode. This module looks for this file and, if found,
-returns its results with no further action.
-
-Set ``CURL_NO_CURL_CMAKE`` to ``ON`` to disable this search.
-
-#]=======================================================================]
-
-include(FindPackageHandleStandardArgs)
-
-if(NOT CURL_NO_CURL_CMAKE)
-  # do a find package call to specifically look for the CMake version
-  # of curl
-  find_package(CURL QUIET NO_MODULE)
-  mark_as_advanced(CURL_DIR)
-
-  # if we found the CURL cmake package then we are done, and
-  # can print what we found and return.
-  if(CURL_FOUND)
-    find_package_handle_standard_args(CURL HANDLE_COMPONENTS CONFIG_MODE)
-    return()
-  endif()
-endif()
-
-find_package(PkgConfig QUIET)
-if(PKG_CONFIG_FOUND)
-  pkg_check_modules(PC_CURL QUIET libcurl)
-  if(PC_CURL_FOUND)
-    set(CURL_VERSION_STRING ${PC_CURL_VERSION})
-    pkg_get_variable(CURL_SUPPORTED_PROTOCOLS libcurl supported_protocols)
-    pkg_get_variable(CURL_SUPPORTED_FEATURES libcurl supported_features)
-  endif()
-endif()
-
-# Look for the header file.
-find_path(CURL_INCLUDE_DIR
-          NAMES curl/curl.h
-          HINTS ${PC_CURL_INCLUDE_DIRS})
-mark_as_advanced(CURL_INCLUDE_DIR)
-
-if(NOT CURL_LIBRARY)
-  # Look for the library (sorted from most current/relevant entry to least).
-  find_library(CURL_LIBRARY_RELEASE NAMES
-      curl
-    # Windows MSVC prebuilts:
-      curllib
-      libcurl_imp
-      curllib_static
-    # Windows older "Win32 - MSVC" prebuilts (libcurl.lib, e.g. libcurl-7.15.5-win32-msvc.zip):
-      libcurl
-      HINTS ${PC_CURL_LIBRARY_DIRS}
-  )
-  mark_as_advanced(CURL_LIBRARY_RELEASE)
-
-  find_library(CURL_LIBRARY_DEBUG NAMES
-    # Windows MSVC CMake builds in debug configuration on vcpkg:
-      libcurl-d_imp
-      libcurl-d
-      HINTS ${PC_CURL_LIBRARY_DIRS}
-  )
-  mark_as_advanced(CURL_LIBRARY_DEBUG)
-
-  include(SelectLibraryConfigurations)
-  select_library_configurations(CURL)
-endif()
-
-if(CURL_INCLUDE_DIR AND NOT CURL_VERSION_STRING)
-  foreach(_curl_version_header curlver.h curl.h)
-    if(EXISTS "${CURL_INCLUDE_DIR}/curl/${_curl_version_header}")
-      file(STRINGS "${CURL_INCLUDE_DIR}/curl/${_curl_version_header}" curl_version_str REGEX "^#define[\t ]+LIBCURL_VERSION[\t ]+\".*\"")
-
-      string(REGEX REPLACE "^#define[\t ]+LIBCURL_VERSION[\t ]+\"([^\"]*)\".*" "\\1" CURL_VERSION_STRING "${curl_version_str}")
-      unset(curl_version_str)
-      break()
-    endif()
-  endforeach()
-endif()
-
-if(CURL_FIND_COMPONENTS)
-  set(CURL_KNOWN_PROTOCOLS ICT FILE FTP FTPS GOPHER HTTP HTTPS IMAP IMAPS LDAP LDAPS POP3 POP3S RTMP RTSP SCP SFTP SMB SMBS SMTP SMTPS TELNET TFTP)
-  set(CURL_KNOWN_FEATURES  SSL IPv6 UnixSockets libz AsynchDNS IDN GSS-API PSL SPNEGO Kerberos NTLM NTLM_WB TLS-SRP HTTP2 HTTPS-proxy)
-  foreach(component IN LISTS CURL_KNOWN_PROTOCOLS CURL_KNOWN_FEATURES)
-    set(CURL_${component}_FOUND FALSE)
-  endforeach()
-  if(NOT PC_CURL_FOUND)
-    find_program(CURL_CONFIG_EXECUTABLE NAMES curl-config)
-    if(CURL_CONFIG_EXECUTABLE)
-      execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --version
-                      OUTPUT_VARIABLE CURL_CONFIG_VERSION_STRING
-                      ERROR_QUIET
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
-      execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --feature
-                      OUTPUT_VARIABLE CURL_CONFIG_FEATURES_STRING
-                      ERROR_QUIET
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
-      string(REPLACE "\n" ";" CURL_SUPPORTED_FEATURES "${CURL_CONFIG_FEATURES_STRING}")
-      execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --protocols
-                      OUTPUT_VARIABLE CURL_CONFIG_PROTOCOLS_STRING
-                      ERROR_QUIET
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
-      string(REPLACE "\n" ";" CURL_SUPPORTED_PROTOCOLS "${CURL_CONFIG_PROTOCOLS_STRING}")
-    endif()
-
-  endif()
-  foreach(component IN LISTS CURL_FIND_COMPONENTS)
-    list(FIND CURL_KNOWN_PROTOCOLS ${component} _found)
-    if(_found)
-      list(FIND CURL_SUPPORTED_PROTOCOLS ${component} _found)
-      if(_found)
-        set(CURL_${component}_FOUND TRUE)
-      elseif(CURL_FIND_REQUIRED)
-        message(FATAL_ERROR "CURL: Required protocol ${component} is not found")
-      endif()
-    else()
-      list(FIND CURL_SUPPORTED_FEATURES ${component} _found)
-      if(_found)
-        set(CURL_${component}_FOUND TRUE)
-      elseif(CURL_FIND_REQUIRED)
-        message(FATAL_ERROR "CURL: Required feature ${component} is not found")
-      endif()
-    endif()
-  endforeach()
-endif()
-
-find_package_handle_standard_args(CURL
-                                  REQUIRED_VARS CURL_LIBRARY CURL_INCLUDE_DIR
-                                  VERSION_VAR CURL_VERSION_STRING
-                                  HANDLE_COMPONENTS)
-
-if(CURL_FOUND)
-  set(CURL_LIBRARIES ${CURL_LIBRARY})
-  set(CURL_INCLUDE_DIRS ${CURL_INCLUDE_DIR})
-
-  if(NOT TARGET CURL::libcurl)
-    add_library(CURL::libcurl UNKNOWN IMPORTED)
-    set_target_properties(CURL::libcurl PROPERTIES
-      INTERFACE_INCLUDE_DIRECTORIES "${CURL_INCLUDE_DIRS}")
-
-    if(EXISTS "${CURL_LIBRARY}")
-      set_target_properties(CURL::libcurl PROPERTIES
-        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-        IMPORTED_LOCATION "${CURL_LIBRARY}")
-    endif()
-    if(CURL_LIBRARY_RELEASE)
-      set_property(TARGET CURL::libcurl APPEND PROPERTY
-        IMPORTED_CONFIGURATIONS RELEASE)
-      set_target_properties(CURL::libcurl PROPERTIES
-        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-        IMPORTED_LOCATION_RELEASE "${CURL_LIBRARY_RELEASE}")
-    endif()
-    if(CURL_LIBRARY_DEBUG)
-      set_property(TARGET CURL::libcurl APPEND PROPERTY
-        IMPORTED_CONFIGURATIONS DEBUG)
-      set_target_properties(CURL::libcurl PROPERTIES
-        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-        IMPORTED_LOCATION_DEBUG "${CURL_LIBRARY_DEBUG}")
-    endif()
-  endif()
-endif()
--- a/CMakeModules/FindFFmpeg.cmake
+++ b/CMakeModules/FindFFmpeg.cmake
@@ -1,171 +0,0 @@
-# vim: ts=2 sw=2
-# - Try to find the required ffmpeg components(default: AVFORMAT, AVUTIL, AVCODEC)
-#
-# Once done this will define
-#  FFMPEG_FOUND         - System has the all required components.
-#  FFMPEG_INCLUDE_DIRS  - Include directory necessary for using the required components headers.
-#  FFMPEG_LIBRARIES     - Link these to use the required ffmpeg components.
-#  FFMPEG_DEFINITIONS   - Compiler switches required for using the required ffmpeg components.
-#
-# For each of the components
-#   - AVCODEC
-#   - AVDEVICE
-#   - AVFORMAT
-#   - AVUTIL
-#   - POSTPROCESS
-#   - SWSCALE
-# the following variables will be defined:
-#  <component>_FOUND        - System has <component>
-#  <component>_INCLUDE_DIRS - Include directory necessary for using the <component> headers
-#  <component>_LIBRARIES    - Link these to use <component>
-#  <component>_DEFINITIONS  - Compiler switches required for using <component>
-#  <component>_VERSION      - The components version
-#
-# As the versions of the various FFmpeg components differ for a given release,
-# and CMake supports only one common version for all components, use the
-# following to specify required versions for multiple components:
-#
-# find_package(FFmpeg 57.48 COMPONENTS AVCODEC)
-# find_package(FFmpeg 57.40 COMPONENTS AVFORMAT)
-# find_package(FFmpeg 55.27 COMPONENTS AVUTIL)
-#
-# SPDX-FileCopyrightText: 2006 Matthias Kretz <kretz@kde.org>
-# SPDX-FileCopyrightText: 2008 Alexander Neundorf <neundorf@kde.org>
-# SPDX-FileCopyrightText: 2011 Michael Jansen <kde@michael-jansen.biz>
-# SPDX-FileCopyrightText: 2021 Stefan Brüns <stefan.bruens@rwth-aachen.de>
-# SPDX-License-Identifier: BSD-3-Clause
-
-include(FindPackageHandleStandardArgs)
-
-if (NOT FFmpeg_FIND_COMPONENTS)
-  # The default components were taken from a survey over other FindFFMPEG.cmake files
-  set(FFmpeg_FIND_COMPONENTS AVCODEC AVFORMAT AVUTIL)
-endif ()
-
-list(LENGTH FFmpeg_FIND_COMPONENTS _numComponents)
-if ((${_numComponents} GREATER 1) AND DEFINED ${FFmpeg_FIND_VERSION})
-  message(WARNING "Using a required version in combination with multiple COMPONENTS is not supported")
-  set(_FFmpeg_REQUIRED_VERSION 0)
-elseif (DEFINED FFmpeg_FIND_VERSION)
-  set(_FFmpeg_REQUIRED_VERSION ${FFmpeg_FIND_VERSION})
-else ()
-  set(_FFmpeg_REQUIRED_VERSION 0)
-endif ()
-set(_FFmpeg_ALL_COMPONENTS AVCODEC AVDEVICE AVFORMAT AVUTIL POSTPROCESS SWSCALE)
-
-#
-### Macro: set_component_found
-#
-# Marks the given component as found if both *_LIBRARIES AND *_INCLUDE_DIRS is present.
-#
-macro(set_component_found _component )
-  if (${_component}_LIBRARIES AND ${_component}_INCLUDE_DIRS)
-    set(${_component}_FOUND TRUE)
-    set(FFmpeg_${_component}_FOUND TRUE)
-  endif ()
-endmacro()
-
-#
-### Macro: find_component
-#
-# Checks for the given component by invoking pkgconfig and then looking up the libraries and
-# include directories.
-#
-macro(find_component _component _pkgconfig _library _header)
-
-  if (NOT WIN32)
-     # use pkg-config to get the directories and then use these values
-     # in the FIND_PATH() and FIND_LIBRARY() calls
-     find_package(PkgConfig)
-     if (PKG_CONFIG_FOUND)
-       pkg_check_modules(PC_${_component} QUIET ${_pkgconfig})
-     endif ()
-  endif (NOT WIN32)
-
-  find_path(${_component}_INCLUDE_DIRS ${_header}
-    HINTS
-      ${PC_LIB${_component}_INCLUDEDIR}
-      ${PC_LIB${_component}_INCLUDE_DIRS}
-    PATH_SUFFIXES
-      ffmpeg
-  )
-
-  find_library(${_component}_LIBRARIES NAMES ${_library}
-      HINTS
-      ${PC_LIB${_component}_LIBDIR}
-      ${PC_LIB${_component}_LIBRARY_DIRS}
-  )
-
-  set(${_component}_DEFINITIONS  ${PC_${_component}_CFLAGS_OTHER} CACHE STRING "The ${_component} CFLAGS.")
-  set(${_component}_VERSION      ${PC_${_component}_VERSION}      CACHE STRING "The ${_component} version number.")
-
-  set_component_found(${_component})
-
-  mark_as_advanced(
-    ${_component}_INCLUDE_DIRS
-    ${_component}_LIBRARIES
-    ${_component}_DEFINITIONS
-    ${_component}_VERSION)
-
-endmacro()
-
-# Check for cached results. If there are skip the costly part.
-if (NOT FFMPEG_LIBRARIES)
-
-  # Check for all possible component.
-  find_component(AVCODEC     libavcodec  avcodec  libavcodec/avcodec.h)
-  find_component(AVFORMAT    libavformat avformat libavformat/avformat.h)
-  find_component(AVDEVICE    libavdevice avdevice libavdevice/avdevice.h)
-  find_component(AVUTIL      libavutil   avutil   libavutil/avutil.h)
-  find_component(SWSCALE     libswscale  swscale  libswscale/swscale.h)
-  find_component(POSTPROCESS libpostproc postproc libpostproc/postprocess.h)
-
-  # Check if the required components were found and add their stuff to the FFMPEG_* vars.
-  foreach (_component ${_FFmpeg_ALL_COMPONENTS})
-    if (${_component}_FOUND)
-      set(FFMPEG_LIBRARIES   ${FFMPEG_LIBRARIES}   ${${_component}_LIBRARIES})
-      set(FFMPEG_DEFINITIONS ${FFMPEG_DEFINITIONS} ${${_component}_DEFINITIONS})
-      list(APPEND FFMPEG_INCLUDE_DIRS ${${_component}_INCLUDE_DIRS})
-    endif ()
-  endforeach ()
-
-  # Build the include path with duplicates removed.
-  if (FFMPEG_INCLUDE_DIRS)
-    list(REMOVE_DUPLICATES FFMPEG_INCLUDE_DIRS)
-  endif ()
-
-  # cache the vars.
-  set(FFMPEG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIRS} CACHE STRING "The FFmpeg include directories." FORCE)
-  set(FFMPEG_LIBRARIES    ${FFMPEG_LIBRARIES}    CACHE STRING "The FFmpeg libraries." FORCE)
-  set(FFMPEG_DEFINITIONS  ${FFMPEG_DEFINITIONS}  CACHE STRING "The FFmpeg cflags." FORCE)
-
-  mark_as_advanced(FFMPEG_INCLUDE_DIRS
-                   FFMPEG_LIBRARIES
-                   FFMPEG_DEFINITIONS)
-
-else ()
-  # Set the noncached _FOUND vars for the components.
-  foreach (_component ${_FFmpeg_ALL_COMPONENTS})
-    set_component_found(${_component})
-  endforeach ()
-endif ()
-
-# Compile the list of required vars
-unset(_FFmpeg_REQUIRED_VARS)
-set(_FFmpeg_FOUND_LIBRARIES "")
-foreach (_component ${FFmpeg_FIND_COMPONENTS})
-  if (${_component}_FOUND)
-    if (${_component}_VERSION VERSION_LESS _FFmpeg_REQUIRED_VERSION)
-      message(STATUS "${_component}: ${${_component}_VERSION} < ${_FFmpeg_REQUIRED_VERSION}")
-      unset(${_component}_FOUND)
-    endif ()
-    list(APPEND _FFmpeg_FOUND_LIBRARIES ${${_component}_LIBRARIES})
-  endif ()
-  list(APPEND _FFmpeg_REQUIRED_VARS ${_component}_LIBRARIES ${_component}_INCLUDE_DIRS ${_component}_FOUND)
-endforeach ()
-list(INSERT _FFmpeg_REQUIRED_VARS 0 _FFmpeg_FOUND_LIBRARIES)
-
-# Give a nice error message if some of the required vars are missing.
-find_package_handle_standard_args(FFmpeg
-    REQUIRED_VARS ${_FFmpeg_REQUIRED_VARS}
-    HANDLE_COMPONENTS)
--- a/CMakeModules/FindGDAL.cmake
+++ b/CMakeModules/FindGDAL.cmake
@@ -1,166 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindGDAL
--------
-
-Find Geospatial Data Abstraction Library (GDAL).
-
-IMPORTED Targets
-^^^^^^^^^^^^^^^^
-
-This module defines :prop_tgt:`IMPORTED` target ``GDAL::GDAL``
-if GDAL has been found.
-
-Result Variables
-^^^^^^^^^^^^^^^^
-
-This module will set the following variables in your project:
-
-``GDAL_FOUND``
-  True if GDAL is found.
-``GDAL_INCLUDE_DIRS``
-  Include directories for GDAL headers.
-``GDAL_LIBRARIES``
-  Libraries to link to GDAL.
-``GDAL_VERSION``
-  The version of GDAL found.
-
-Cache variables
-^^^^^^^^^^^^^^^
-
-The following cache variables may also be set:
-
-``GDAL_LIBRARY``
-  The libgdal library file.
-``GDAL_INCLUDE_DIR``
-  The directory containing ``gdal.h``.
-
-Hints
-^^^^^
-
-Set ``GDAL_DIR`` or ``GDAL_ROOT`` in the environment to specify the
-GDAL installation prefix.
-#]=======================================================================]
-
-# $GDALDIR is an environment variable that would
-# correspond to the ./configure --prefix=$GDAL_DIR
-# used in building gdal.
-#
-# Created by Eric Wing. I'm not a gdal user, but OpenSceneGraph uses it
-# for osgTerrain so I whipped this module together for completeness.
-# I actually don't know the conventions or where files are typically
-# placed in distros.
-# Any real gdal users are encouraged to correct this (but please don't
-# break the OS X framework stuff when doing so which is what usually seems
-# to happen).
-
-# This makes the presumption that you are include gdal.h like
-#
-#include "gdal.h"
-
-include(FindPackageHandleStandardArgs)
-
-find_path(GDAL_INCLUDE_DIR gdal.h
-  HINTS
-    ENV GDAL_DIR
-    ENV GDAL_ROOT
-  PATH_SUFFIXES
-     include/gdal
-     include/GDAL
-     include
-)
-
-if(UNIX)
-    # Use gdal-config to obtain the library version (this should hopefully
-    # allow us to -lgdal1.x.y where x.y are correct version)
-    # For some reason, libgdal development packages do not contain
-    # libgdal.so...
-    find_program(GDAL_CONFIG gdal-config
-        HINTS
-          ENV GDAL_DIR
-          ENV GDAL_ROOT
-        PATH_SUFFIXES bin
-    )
-
-    if(GDAL_CONFIG)
-        exec_program(${GDAL_CONFIG} ARGS --libs OUTPUT_VARIABLE GDAL_CONFIG_LIBS)
-
-        if(GDAL_CONFIG_LIBS)
-            # treat the output as a command line and split it up
-            separate_arguments(args NATIVE_COMMAND "${GDAL_CONFIG_LIBS}")
-
-            # only consider libraries whose name matches this pattern
-            set(name_pattern "[gG][dD][aA][lL]")
-
-            # consider each entry as a possible library path, name, or parent directory
-            foreach(arg IN LISTS args)
-                # library name
-                if("${arg}" MATCHES "^-l(.*)$")
-                    set(lib "${CMAKE_MATCH_1}")
-
-                    # only consider libraries whose name matches the expected pattern
-                    if("${lib}" MATCHES "${name_pattern}")
-                        list(APPEND _gdal_lib "${lib}")
-                    endif()
-                # library search path
-                elseif("${arg}" MATCHES "^-L(.*)$")
-                    list(APPEND _gdal_libpath "${CMAKE_MATCH_1}")
-                # assume this is a full path to a library
-                elseif(IS_ABSOLUTE "${arg}" AND EXISTS "${arg}")
-                    # extract the file name
-                    get_filename_component(lib "${arg}" NAME)
-
-                    # only consider libraries whose name matches the expected pattern
-                    if(NOT "${lib}" MATCHES "${name_pattern}")
-                        continue()
-                    endif()
-
-                    # extract the file directory
-                    get_filename_component(dir "${arg}" DIRECTORY)
-
-                    # remove library prefixes/suffixes
-                    string(REGEX REPLACE "^(${CMAKE_SHARED_LIBRARY_PREFIX}|${CMAKE_STATIC_LIBRARY_PREFIX})" "" lib "${lib}")
-                    string(REGEX REPLACE "(${CMAKE_SHARED_LIBRARY_SUFFIX}|${CMAKE_STATIC_LIBRARY_SUFFIX})$" "" lib "${lib}")
-
-                    # use the file name and directory as hints
-                    list(APPEND _gdal_libpath "${dir}")
-                    list(APPEND _gdal_lib "${lib}")
-                endif()
-            endforeach()
-        endif()
-    endif()
-endif()
-
-find_library(GDAL_LIBRARY
-  NAMES ${_gdal_lib} gdal gdal_i gdal1.5.0 gdal1.4.0 gdal1.3.2 GDAL
-  HINTS
-     ENV GDAL_DIR
-     ENV GDAL_ROOT
-     ${_gdal_libpath}
-  PATH_SUFFIXES lib
-)
-
-if (EXISTS "${GDAL_INCLUDE_DIR}/gdal_version.h")
-    file(STRINGS "${GDAL_INCLUDE_DIR}/gdal_version.h" _gdal_version
-        REGEX "GDAL_RELEASE_NAME")
-    string(REGEX REPLACE ".*\"\(.*\)\"" "\\1" GDAL_VERSION "${_gdal_version}")
-    unset(_gdal_version)
-else ()
-    set(GDAL_VERSION GDAL_VERSION-NOTFOUND)
-endif ()
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(GDAL
-    VERSION_VAR GDAL_VERSION
-    REQUIRED_VARS GDAL_LIBRARY GDAL_INCLUDE_DIR)
-
-if (GDAL_FOUND AND NOT TARGET GDAL::GDAL)
-    add_library(GDAL::GDAL UNKNOWN IMPORTED)
-    set_target_properties(GDAL::GDAL PROPERTIES
-        IMPORTED_LOCATION "${GDAL_LIBRARY}"
-        INTERFACE_INCLUDE_DIRECTORIES "${GDAL_INCLUDE_DIR}")
-endif ()
-
-set(GDAL_LIBRARIES ${GDAL_LIBRARY})
-set(GDAL_INCLUDE_DIRS ${GDAL_INCLUDE_DIR})
--- a/CMakeModules/FindLibLZMA.cmake
+++ b/CMakeModules/FindLibLZMA.cmake
@@ -1,124 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindLibLZMA
-----------
-
-Find LZMA compression algorithm headers and library.
-
-
-Imported Targets
-^^^^^^^^^^^^^^^^
-
-This module defines :prop_tgt:`IMPORTED` target ``LibLZMA::LibLZMA``, if
-liblzma has been found.
-
-Result variables
-^^^^^^^^^^^^^^^^
-
-This module will set the following variables in your project:
-
-``LIBLZMA_FOUND``
-  True if liblzma headers and library were found.
-``LIBLZMA_INCLUDE_DIRS``
-  Directory where liblzma headers are located.
-``LIBLZMA_LIBRARIES``
-  Lzma libraries to link against.
-``LIBLZMA_HAS_AUTO_DECODER``
-  True if lzma_auto_decoder() is found (required).
-``LIBLZMA_HAS_EASY_ENCODER``
-  True if lzma_easy_encoder() is found (required).
-``LIBLZMA_HAS_LZMA_PRESET``
-  True if lzma_lzma_preset() is found (required).
-``LIBLZMA_VERSION_MAJOR``
-  The major version of lzma
-``LIBLZMA_VERSION_MINOR``
-  The minor version of lzma
-``LIBLZMA_VERSION_PATCH``
-  The patch version of lzma
-``LIBLZMA_VERSION_STRING``
-  version number as a string (ex: "5.0.3")
-#]=======================================================================]
-
-find_path(LIBLZMA_INCLUDE_DIR lzma.h )
-if(NOT LIBLZMA_LIBRARY)
-  find_library(LIBLZMA_LIBRARY_RELEASE NAMES lzma liblzma NAMES_PER_DIR PATH_SUFFIXES lib)
-  find_library(LIBLZMA_LIBRARY_DEBUG NAMES lzmad liblzmad NAMES_PER_DIR PATH_SUFFIXES lib)
-  include(SelectLibraryConfigurations)
-  select_library_configurations(LIBLZMA)
-else()
-  file(TO_CMAKE_PATH "${LIBLZMA_LIBRARY}" LIBLZMA_LIBRARY)
-endif()
-
-if(LIBLZMA_INCLUDE_DIR AND EXISTS "${LIBLZMA_INCLUDE_DIR}/lzma/version.h")
-    file(STRINGS "${LIBLZMA_INCLUDE_DIR}/lzma/version.h" LIBLZMA_HEADER_CONTENTS REGEX "#define LZMA_VERSION_[A-Z]+ [0-9]+")
-
-    string(REGEX REPLACE ".*#define LZMA_VERSION_MAJOR ([0-9]+).*" "\\1" LIBLZMA_VERSION_MAJOR "${LIBLZMA_HEADER_CONTENTS}")
-    string(REGEX REPLACE ".*#define LZMA_VERSION_MINOR ([0-9]+).*" "\\1" LIBLZMA_VERSION_MINOR "${LIBLZMA_HEADER_CONTENTS}")
-    string(REGEX REPLACE ".*#define LZMA_VERSION_PATCH ([0-9]+).*" "\\1" LIBLZMA_VERSION_PATCH "${LIBLZMA_HEADER_CONTENTS}")
-
-    set(LIBLZMA_VERSION_STRING "${LIBLZMA_VERSION_MAJOR}.${LIBLZMA_VERSION_MINOR}.${LIBLZMA_VERSION_PATCH}")
-    unset(LIBLZMA_HEADER_CONTENTS)
-endif()
-
-# We're using new code known now as XZ, even library still been called LZMA
-# it can be found in http://tukaani.org/xz/
-# Avoid using old codebase
-if (LIBLZMA_LIBRARY)
-  include(CheckLibraryExists)
-  set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET})
-  set(CMAKE_REQUIRED_QUIET ${LibLZMA_FIND_QUIETLY})
-  if(NOT LIBLZMA_LIBRARY_RELEASE AND NOT LIBLZMA_LIBRARY_DEBUG)
-    set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY})
-  elseif(LIBLZMA_LIBRARY_RELEASE)
-    set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY_RELEASE})
-  elseif(LIBLZMA_LIBRARY_DEBUG)
-    set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY_DEBUG})
-  endif()
-  CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_auto_decoder "" LIBLZMA_HAS_AUTO_DECODER)
-  CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_easy_encoder "" LIBLZMA_HAS_EASY_ENCODER)
-  CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_lzma_preset "" LIBLZMA_HAS_LZMA_PRESET)
-  unset(LIBLZMA_LIBRARY_check)
-  set(CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVE})
-endif ()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(LibLZMA  REQUIRED_VARS  LIBLZMA_LIBRARY
-                                                          LIBLZMA_INCLUDE_DIR
-                                                          LIBLZMA_HAS_AUTO_DECODER
-                                                          LIBLZMA_HAS_EASY_ENCODER
-                                                          LIBLZMA_HAS_LZMA_PRESET
-                                           VERSION_VAR    LIBLZMA_VERSION_STRING
-                                 )
-mark_as_advanced( LIBLZMA_INCLUDE_DIR LIBLZMA_LIBRARY )
-
-if (LIBLZMA_FOUND)
-    set(LIBLZMA_LIBRARIES ${LIBLZMA_LIBRARY})
-    set(LIBLZMA_INCLUDE_DIRS ${LIBLZMA_INCLUDE_DIR})
-    if(NOT TARGET LibLZMA::LibLZMA)
-        add_library(LibLZMA::LibLZMA UNKNOWN IMPORTED)
-        set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                              INTERFACE_INCLUDE_DIRECTORIES ${LIBLZMA_INCLUDE_DIR}
-                              IMPORTED_LINK_INTERFACE_LANGUAGES C)
-
-        if(LIBLZMA_LIBRARY_RELEASE)
-            set_property(TARGET LibLZMA::LibLZMA APPEND PROPERTY
-                IMPORTED_CONFIGURATIONS RELEASE)
-            set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                IMPORTED_LOCATION_RELEASE "${LIBLZMA_LIBRARY_RELEASE}")
-        endif()
-
-        if(LIBLZMA_LIBRARY_DEBUG)
-            set_property(TARGET LibLZMA::LibLZMA APPEND PROPERTY
-                IMPORTED_CONFIGURATIONS DEBUG)
-            set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                IMPORTED_LOCATION_DEBUG "${LIBLZMA_LIBRARY_DEBUG}")
-        endif()
-
-        if(NOT LIBLZMA_LIBRARY_RELEASE AND NOT LIBLZMA_LIBRARY_DEBUG)
-            set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                IMPORTED_LOCATION "${LIBLZMA_LIBRARY}")
-        endif()
-    endif()
-endif ()
--- a/CMakeModules/FindUdns.cmake
+++ b/CMakeModules/FindUdns.cmake
@@ -38,18 +38,5 @@ else ()

  # show the UDNS_INCLUDE_DIRS and UDNS_LIBRARIES variables only in the advanced view
  mark_as_advanced(UDNS_INCLUDE_DIRS UDNS_LIBRARIES)
+
 endif ()
-
-if(UDNS_FOUND)
-
-  if(NOT TARGET Udns::Udns)
-    add_library(Udns::Udns UNKNOWN IMPORTED)
-    set_target_properties(Udns::Udns PROPERTIES
-      INTERFACE_INCLUDE_DIRECTORIES "${UDNS_INCLUDE_DIRS}")
-
-      set_target_properties(Udns::Udns PROPERTIES
-        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-        IMPORTED_LOCATION "${UDNS_LIBRARIES}")
-    
-  endif()
-endif()
--- a/CMakeModules/Packaging.cmake
+++ b/CMakeModules/Packaging.cmake
@@ -1,23 +0,0 @@
-#packaging
-SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
-SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
-SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simulation support libraries for FlightGear and related projects")
-SET(CPACK_PACKAGE_VENDOR "The FlightGear project")
-SET(CPACK_GENERATOR "TBZ2")
-SET(CPACK_INSTALL_CMAKE_PROJECTS  ${CMAKE_CURRENT_BINARY_DIR};SimGear;ALL;/)
-
-
-# split version string into components, note CMAKE_MATCH_0 is the entire regexp match
-string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CPACK_PACKAGE_VERSION ${SIMGEAR_VERSION} )
-set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
-set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
-set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
-
-message(STATUS "version is ${CPACK_PACKAGE_VERSION_MAJOR} dot ${CPACK_PACKAGE_VERSION_MINOR} dot ${CPACK_PACKAGE_VERSION_PATCH}")
-
-set(CPACK_SOURCE_GENERATOR TBZ2)
-set(CPACK_SOURCE_PACKAGE_FILE_NAME "simgear-${SIMGEAR_VERSION}" CACHE INTERNAL "tarball basename")
-set(CPACK_SOURCE_IGNORE_FILES
-  "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
-
-include (CPack)
--- a/CMakeModules/SimGearComponent.cmake
+++ b/CMakeModules/SimGearComponent.cmake
@@ -12,11 +12,6 @@ macro(simgear_component_common name includePath sourcesList sources headers)
 		set_property(GLOBAL
 			APPEND PROPERTY PUBLIC_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
        set(fh${sourcesList} "${fh${sourcesList}}#${CMAKE_CURRENT_SOURCE_DIR}/${h}")
-
-        # also append headers to the sources list, so that IDEs find the files
-        # correctly (otherwise they are not in the project)
-        set_property(GLOBAL
-            APPEND PROPERTY ${sourcesList} "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
 	endforeach()

    set_property(GLOBAL APPEND PROPERTY FG_GROUPS_${sourcesList}_C "${fc${sourcesList}}@")
--- a/568
+++ b/568
--- a/DoxygenMain.cxx
+++ b/DoxygenMain.cxx
@@ -2,10 +2,6 @@
   documentation.  It has a .cxx extension so that emacs will happily
   autoindent correctly. */

-/**
- * \namespace simgear
- * \brief \ref index "SimGear" main namespace.
- */
 /** \mainpage SimGear
 * Simulation, Visualization, and Game development libraries.

--- a/README.OpenAL
+++ b/README.OpenAL
@@ -0,0 +1,20 @@
+[This file is mirrored in both the FlightGear and SimGear packages.]
+
+You *must* have the development components of OpenAL installed on your system
+to build FlightGear!"  You can get a copy here:
+
+      http://connect.creativelabs.com/openal/default.aspx
+
+Build notes:
+
+You can download a versioned release of the openal library from 
+http://www.openal.org/downloads.html. Download the openal source,
+release 0.0.8 (dated February 11, 2006) and run:  
+tar xjvf openal-soft-1.5.304.tar.bz2
+cd openal-soft-1.5.304/
+ccmake .
+
+[ While running ccmake: press 'c' to configure, press 'c' once more, and
+  then press 'g' to generate and exit ]
+
+
--- a/README.sound
+++ b/README.sound
@@ -1,39 +0,0 @@
-[This file is mirrored in both the FlightGear and SimGear packages.]
-
-For Sound support FlightGear requires one of the two following packages:
- OpenAL
- AeonWave
-
-== OpenAL ===
-
-You *must* have the development components of OpenAL installed on your system
-to build FlightGear!"  You can get a copy here:
-
-      http://connect.creativelabs.com/openal/default.aspx
-
-Build notes:
-
-You can download a versioned release of the openal library from
-http://www.openal.org/downloads.html. Download the openal source,
-release 0.0.8 (dated February 11, 2006) and run:
-tar xjvf openal-soft-1.5.304.tar.bz2
-cd openal-soft-1.5.304/
-ccmake .
-
-[ While running ccmake: press 'c' to configure, press 'c' once more, and
-  then press 'g' to generate and exit ]
-
-
-== AeonWave ===
-
-For FlightGear AeonWave has a number of advantages over OpenAL:
-* Correct Doppler effect behavior
-* Default distance attenuation frequency filtering
-* Native support for 29 types of audio formats.
-* Native support for wav, mp3, vorbis and raw file formats.
-
-The source code of AeonWave can be found on GitHub:
-https://github.com/adalinbv
-
-Optimized binary packages are available at:
-http://www.adalin.com/
--- a/SimGear.spec.in
+++ b/SimGear.spec.in
@@ -0,0 +1,76 @@
+%define ver	@VERSION@
+%define rel	1
+%define prefix	/usr
+
+Summary:	Simulator Construction Gear.
+Name:		@PACKAGE@
+Version:	%ver
+Release:	%rel
+Copyright:	LGPL
+Group:		Libraries/Graphics
+Source:		%{name}-%{version}.tar.gz
+#URL:		
+BuildRoot:	/tmp/%{name}-%{version}-%{rel}-root
+Packager:	Fill In As You Wish
+Docdir:		%{prefix}/doc
+
+%description
+This package contains a tools and libraries useful for constructing 
+simulation and visualization applications such as FlightGear or TerraGear. 
+
+Authors:
+	N/A
+
+%prep
+%setup -n %{name}-%{version}
+
+
+%build
+# Needed for snapshot releases.
+if [ ! -f configure ]; then
+	CFLAGS="$RPM_OPT_FLAGS" ./autogen.sh --prefix=%prefix
+else
+	CFLAGS="$RPM_OPT_FLAGS" ./configure --prefix=%prefix
+fi
+
+if [ "$SMP" != "" ]; then
+	JSMP	= '"MAKE=make -k -j $SMP"'
+fi
+
+make ${JSMP};
+
+
+%install
+[ -d ${RPM_BUILD_ROOT} ] && rm -rf ${RPM_BUILD_ROOT}
+
+make prefix=${RPM_BUILD_ROOT}%{prefix} install
+
+#
+# Generating file lists and store them in file-lists
+# Starting with the directory listings
+#
+find ${RPM_BUILD_ROOT}%{prefix}/{bin,include,lib} -type d | sed "s#^${RPM_BUILD_ROOT}#\%attr (-\,root\,root) \%dir #" > file-lists
+%{?ETCDR:find ${RPM_BUILD_ROOT}%{!?SYSCF:%{prefix}}/etc -type d | sed "s#^${RPM_BUILD_ROOT}#\%attr (-\,root\,root) \%dir #" >> file-lists}
+
+#
+# Then, the file listings
+#
+echo "%defattr (-, root, root)" >> file-lists
+%{?ETCDR:find ${RPM_BUILD_ROOT}%{!?SYSCF:%{prefix}}/etc/%{name}.conf -type f | sed -e "s#^${RPM_BUILD_ROOT}#%config #g" >> file-lists}
+find ${RPM_BUILD_ROOT}%{prefix} -type f | sed -e "s#^${RPM_BUILD_ROOT}##g" >> file-lists
+
+
+%clean
+(cd ..; rm -rf %{name}-%{version} ${RPM_BUILD_ROOT})
+
+
+%files -f file-lists
+%defattr (-, root, root)
+%doc AUTHORS
+%doc COPYING
+%doc ChangeLog
+%doc INSTALL
+%doc NEWS
+%doc README
+%doc %{name}.spec.in
+
--- a/SimGearConfig.cmake.in
+++ b/SimGearConfig.cmake.in
@@ -1,63 +1,20 @@
 include(CMakeFindDependencyMacro)

 find_dependency(ZLIB)
-find_dependency(LibLZMA)
 find_dependency(Threads)
-find_dependency(CURL)

 # OSG

 set(SIMGEAR_HEADLESS @SIMGEAR_HEADLESS@)
 set(SIMGEAR_SOUND @ENABLE_SOUND@)
-set(USE_AEONWAVE @USE_AEONWAVE@)
-set(SG_SOUND_USES_OPENALSOFT @SG_SOUND_USES_OPENALSOFT@)

-set(USE_SHADERVG @USE_SHADERVG@)
-if (USE_SHADERVG)
-endif()
-
-set(ENABLE_ASAN @ENABLE_ASAN@)
-set(SIMGEAR_SHARED @SIMGEAR_SHARED@)
+# OpenAL isn't a public dependency, so maybe not needed
+#if (SIMGEAR_SOUND)
+#  find_dependency(OpenAL)
+#endif()

 # SSE/SSE2 support

 set(ENABLE_SIMD @ENABLE_SIMD@)

-# SycloneDDS support
-set(SG_HAVE_DDS @SG_HAVE_DDS@)
-if(SG_HAVE_DDS)
-    find_dependency(CycloneDDS)
-endif()
-
-
-if (SIMGEAR_SOUND)
-  # find the sound dependency
-  if (USE_AEONWAVE)
-    find_dependency(AAX)
-  elseif(SG_SOUND_USES_OPENALSOFT)
-    # must force CONFIG mode when using OpenAL soft, to avoid picking
-    # the CMake supplied FindOpenAL and hence defaults to the system
-    # framework on macOS
-    find_dependency(OpenAL CONFIG)
-  else()
-    find_dependency(OpenAL)
-  endif()
-endif()
-
-# OpenRTI support
-set(ENABLE_RTI @ENABLE_RTI@)
-if(ENABLE_RTI)
-    find_dependency(PkgConfig)
-    if(PKG_CONFIG_FOUND)
-      pkg_check_modules(RTI IMPORTED_TARGET hla-rti13)
-    endif(PKG_CONFIG_FOUND)
-endif(ENABLE_RTI)
-
-# Alternative terrain engine based on pagedLOD
-
-set(ENABLE_GDAL @ENABLE_GDAL@)
-if (ENABLE_GDAL)
-  find_dependency(GDAL)
-endif()
-
 include("${CMAKE_CURRENT_LIST_DIR}/SimGearTargets.cmake")
--- a/package/RedHat/README
+++ b/package/RedHat/README
@@ -0,0 +1,13 @@
+Building a SimGear RPM package for Red Hat
+
+Please see the "package/openSUSE" directory for an
+example how to build a SimGear RPM package with
+shared SimGear libraries.
+
+You may need to adapt the names (exact spelling) of some
+of the package dependencies in the openSUSE RPM spec,
+since these may slightly differ for Red Hat.
+
+(If you have a working and tested Red Hat RPM spec,
+you're welcome to contribute it to this project.)
+
--- a/package/openSUSE/README
+++ b/package/openSUSE/README
@@ -0,0 +1,23 @@
+Building a SimGear RPM package for openSUSE
+
+(Last tested with openSUSE 11.4+12.1)
+
+This directory contains the files which, along with
+the source code tar files, can be used to build
+an RPM package targeted at an openSUSE Linux system.
+
+To build SimGear from source do the following:
+
+1. obtain simgear-2.8.0.tar.bz2 (adapt version if
+    necessary) and copy it into ~/rpmbuild/SOURCES
+
+2. look in the BuildRequires section of SimGear.spec
+   and check that all the packages referred to are
+   installed (note, some of these packages may be part
+   of openSUSE's "games" repository).
+
+3. run 'rpmbuild -ba simgear.spec' and find the RPM
+   build result in ~/rpmbuild/RPMS
+
+That's all!
+
--- a/package/openSUSE/SimGear.spec
+++ b/package/openSUSE/SimGear.spec
@@ -0,0 +1,63 @@
+Summary:    Simulator Construction Gear
+Name:       SimGear
+Version:    2.8.0
+Release:    1
+License:    LGPL
+URL:        http://www.flightgear.org
+Group:      Amusements/Games/3D/Simulation
+Source:     http://mirrors.ibiblio.org/pub/mirrors/flightgear/ftp/Source/simgear-%{version}.tar.bz2
+BuildRoot:  %{_tmppath}/%{name}-%{version}-build
+
+BuildRequires: gcc, gcc-c++, cmake
+BuildRequires: libopenal1-soft, openal-soft
+BuildRequires: libOpenSceneGraph-devel >= 3.0
+BuildRequires: zlib, zlib-devel
+BuildRequires: libjpeg62, libjpeg62-devel
+BuildRequires: boost-devel >= 1.37
+BuildRequires: subversion-devel, libapr1-devel
+Requires:      OpenSceneGraph-plugins >= 3.0
+
+%description
+This package contains a tools and libraries useful for constructing
+simulation and visualization applications such as FlightGear or TerraGear.
+
+%package devel
+Group:         Development/Libraries/Other
+Summary:       Development header files for SimGear
+Requires:      SimGear = %{version}
+
+%description devel
+Development headers and libraries for building applications against SimGear.
+
+%prep
+%setup -T -q -n simgear-%{version} -b 0
+
+%build
+export CFLAGS="$RPM_OPT_FLAGS"
+export CXXFLAGS="$RPM_OPT_FLAGS"
+# build SHARED simgear libraries
+cmake -DCMAKE_INSTALL_PREFIX=%{_prefix} -DSIMGEAR_SHARED:BOOL=ON -DENABLE_TESTS:BOOL=OFF -DJPEG_FACTORY:BOOL=ON
+make %{?_smp_mflags}
+
+%install
+make DESTDIR=%{buildroot} install
+
+%post -p /sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+%files
+%defattr (-, root, root, -)
+%doc AUTHORS COPYING ChangeLog NEWS README
+%{_libdir}/libSimGear*.so.*
+
+%files devel
+%defattr(-,root,root,-)
+%dir %{_includedir}/simgear
+%{_includedir}/simgear/*
+%{_libdir}/libSimGear*.so
+
+%changelog
+* Mon Jul 02 2012 thorstenb@flightgear.org
+- Initial version
+
--- a/1
+++ b/1
@@ -1 +0,0 @@
-2020.4.0
--- a/simgear/CMakeLists.txt
+++ b/simgear/CMakeLists.txt
@@ -5,8 +5,6 @@ foreach( mylibfolder
        bucket
        bvh
        debug
-        embedded_resources
-        emesary
        ephemeris
        io
        magvar
@@ -16,7 +14,6 @@ foreach( mylibfolder
        nasal/cppbind
        props
        serial
-        std
        structure
        threads
        timing
@@ -48,6 +45,7 @@ install (FILES ${HEADERS}  DESTINATION include/simgear/)
 get_property(coreSources GLOBAL PROPERTY CORE_SOURCES)
 get_property(sceneSources GLOBAL PROPERTY SCENE_SOURCES)
 get_property(publicHeaders GLOBAL PROPERTY PUBLIC_HEADERS)
+get_property(localExpatSources GLOBAL PROPERTY LOCAL_EXPAT_SOURCES)

 if(SIMGEAR_SHARED)
    message(STATUS "Library building mode: SHARED LIBRARIES")
@@ -64,9 +62,6 @@ if(SIMGEAR_SHARED)
        set_property(TARGET SimGearScene PROPERTY VERSION   ${SIMGEAR_VERSION})
        set_property(TARGET SimGearScene PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
    endif()
-
-    export_debug_symbols(SimGearCore)
-    export_debug_symbols(SimGearScene)
 else()
    message(STATUS "Library building mode: STATIC LIBRARIES")

@@ -88,7 +83,7 @@ else()
 		source_group("${name}\\Headers" FILES ${g2})
 	endforeach()

-    add_library(SimGearCore STATIC ${coreSources})
+    add_library(SimGearCore STATIC ${coreSources} ${localExpatSources})

    if(NOT SIMGEAR_HEADLESS)
 		get_property(FG_GROUPS_SCENE_SOURCES_C GLOBAL PROPERTY FG_GROUPS_SCENE_SOURCES_C)
@@ -117,98 +112,74 @@ target_include_directories(SimGearCore BEFORE PUBLIC
    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
    $<INSTALL_INTERFACE:include>)

-# for simgear_config.h
-target_include_directories(SimGearCore PRIVATE ${PROJECT_BINARY_DIR}/simgear)
-
 target_include_directories(SimGearCore PUBLIC
-  ${Boost_INCLUDE_DIRS})
+  ${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})
+    install(TARGETS SimGearCore
+            EXPORT SimGearTargets
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})

-# we expose ZLib in some of our headers
-target_link_libraries(SimGearCore PUBLIC ZLIB::ZLIB)
+if (NOT SIMGEAR_HEADLESS)
+  install(TARGETS SimGearScene
+          EXPORT SimGearTargets
+          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})

-if (SG_HAVE_DDS)
-    target_link_libraries(SimGearCore PRIVATE CycloneDDS::ddsc)
-endif()
+  target_include_directories(SimGearScene BEFORE PUBLIC
+      $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+    $<INSTALL_INTERFACE:include>)

-if (ENABLE_RTI)
-    target_sources(SimGearCore PRIVATE $<TARGET_OBJECTS:rti> $<TARGET_OBJECTS:rti13>)
-    target_link_libraries(SimGearCore PRIVATE PkgConfig::RTI)
-endif()
-
-# all of these we keep privately
-target_link_libraries(SimGearCore PRIVATE
-    ${SHLWAPI_LIBRARY}
-    ${RT_LIBRARY}
-    ${DL_LIBRARY}
-    Threads::Threads
-    ${COCOA_LIBRARY}
-    CURL::libcurl
-    EXPAT::EXPAT
-    Udns::Udns
-    LibLZMA::LibLZMA
-    ${WINSOCK_LIBRARY})
-
-if(NOT SIMGEAR_HEADLESS)
-    target_include_directories(SimGearScene PRIVATE ${PROJECT_SOURCE_DIR}/simgear/canvas/${OPENVG}/include)
-
-    target_link_libraries(SimGearScene PUBLIC         
-        SimGearCore
-        ${OPENSCENEGRAPH_LIBRARIES}
-    )
-
-    if(HAVE_INTTYPES_H)
-        # ShivaVG/ShaderVG needs inttypes.h
-        target_compile_definitions(SimGearScene PRIVATE HAVE_INTTYPES_H)
-    endif()
-
-    target_link_libraries(SimGearScene PRIVATE
-        ZLIB::ZLIB
-        ${OPENGL_LIBRARY}
-        ${JPEG_LIBRARY}
-        ${FFMPEG_LIBRARIES}
-        FGTinyGLTF)
-
-    # ToDo: define an ALIAS target for the sound backend, to get
-    # rid of this logic here
-    if (ENABLE_SOUND)
-        if (USE_AEONWAVE)
-            target_link_libraries(SimGearScene PRIVATE ${AAX_LIBRARY})
-        else()
-            target_link_libraries(SimGearScene PRIVATE ${OPENAL_LIBRARY} )
-        endif()
-    endif()
-
-    if(ENABLE_GDAL)
-        # FIXME: should be RIVATE, but we leak GDAL headers
-        # in our own headers :(
-        target_link_libraries(SimGearScene PUBLIC GDAL::GDAL)
-    endif()
-
-    # only actually needed by canvas/KeyboardEvent.cxx
-    target_include_directories(SimGearScene PRIVATE ${PROJECT_SOURCE_DIR}/3rdparty/utf8/source)
-    target_include_directories(SimGearScene PRIVATE ${FFMPEG_INCLUDE_DIRS})
-
-    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>)
-
-    # for simgear_config.h
-    target_include_directories(SimGearScene PRIVATE ${PROJECT_BINARY_DIR}/simgear)
    target_include_directories(SimGearScene PUBLIC ${OPENSCENEGRAPH_INCLUDE_DIRS})

    if (USE_AEONWAVE)
-        target_include_directories(SimGearScene PRIVATE ${AAX_INCLUDE_DIR} )
+      target_include_directories(SimGearScene PRIVATE ${AAX_INCLUDE_DIR} )
    else()
-        target_include_directories(SimGearScene PRIVATE ${OPENAL_INCLUDE_DIR} )
+      target_include_directories(SimGearScene PRIVATE ${OPENAL_INCLUDE_DIR} )
    endif()
 endif()
+
+
+target_link_libraries(SimGearCore
+    ${ZLIB_LIBRARY}
+    ${RT_LIBRARY}
+    ${DL_LIBRARY}
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${COCOA_LIBRARY}
+    ${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}
+        ${OPENSCENEGRAPH_LIBRARIES}
+        ${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)
+    # Ugly first aid to make hla compile agian
+    set_property(SOURCE hla/RTI13InteractionClass.cxx hla/RTI13ObjectClass.cxx
+        hla/RTI13ObjectInstance.cxx hla/RTI13Federate.cxx
+        hla/RTI13FederateFactory.cxx
+        APPEND PROPERTY COMPILE_FLAGS "-I${RTI_INCLUDE_DIR}")
+endif(ENABLE_RTI)
--- a/simgear/bucket/CMakeLists.txt
+++ b/simgear/bucket/CMakeLists.txt
@@ -6,6 +6,11 @@ set(SOURCES newbucket.cxx)

 simgear_component(bucket bucket "${SOURCES}" "${HEADERS}")

+
 if(ENABLE_TESTS)
-    add_simgear_autotest(test_bucket test_bucket.cxx)
+
+add_executable(test_bucket test_bucket.cxx)
+add_test(test_bucket ${EXECUTABLE_OUTPUT_PATH}/test_bucket)
+target_link_libraries(test_bucket ${TEST_LIBS})
+
 endif(ENABLE_TESTS)
--- a/simgear/bucket/newbucket.cxx
+++ b/simgear/bucket/newbucket.cxx
@@ -184,99 +184,6 @@ void SGBucket::innerSet( double dlon, double dlat )
    }
 }

-std::string SGBucket::gen_vpb_base() const {
-    // long int index;
-    int top_lon, top_lat, main_lon, main_lat;
-    char hem, pole;
-    char raw_path[256];
-
-    top_lon = lon / 10;
-    main_lon = lon;
-    if ( (lon < 0) && (top_lon * 10 != lon) ) {
-	top_lon -= 1;
-    }
-    top_lon *= 10;
-    if ( top_lon >= 0 ) {
-	hem = 'e';
-    } else {
-	hem = 'w';
-	top_lon *= -1;
-    }
-    if ( main_lon < 0 ) {
-	main_lon *= -1;
-    }
-    
-    top_lat = lat / 10;
-    main_lat = lat;
-    if ( (lat < 0) && (top_lat * 10 != lat) ) {
-	top_lat -= 1;
-    }
-    top_lat *= 10;
-    if ( top_lat >= 0 ) {
-	pole = 'n';
-    } else {
-	pole = 's';
-	top_lat *= -1;
-    }
-    if ( main_lat < 0 ) {
-	main_lat *= -1;
-    }
-
-    ::snprintf(raw_path, 256, "%c%03d%c%02d/%c%03d%c%02d/ws_%c%03d%c%02d",
-	    hem, top_lon, pole, top_lat, 
-	    hem, main_lon, pole, main_lat,
-        hem, main_lon, pole, main_lat);
-
-    return raw_path;
-}
-
-std::string SGBucket::gen_vpb_subtile(int level, int x, int y) const {
-    // long int index;
-    int top_lon, top_lat, main_lon, main_lat;
-    char hem, pole;
-    char raw_path[256];
-
-    top_lon = lon / 10;
-    main_lon = lon;
-    if ( (lon < 0) && (top_lon * 10 != lon) ) {
-	top_lon -= 1;
-    }
-    top_lon *= 10;
-    if ( top_lon >= 0 ) {
-	hem = 'e';
-    } else {
-	hem = 'w';
-	top_lon *= -1;
-    }
-    if ( main_lon < 0 ) {
-	main_lon *= -1;
-    }
-    
-    top_lat = lat / 10;
-    main_lat = lat;
-    if ( (lat < 0) && (top_lat * 10 != lat) ) {
-	top_lat -= 1;
-    }
-    top_lat *= 10;
-    if ( top_lat >= 0 ) {
-	pole = 'n';
-    } else {
-	pole = 's';
-	top_lat *= -1;
-    }
-    if ( main_lat < 0 ) {
-	main_lat *= -1;
-    }
-
-    ::snprintf(raw_path, 256, "%c%03d%c%02d/%c%03d%c%02d/ws_%c%03d%c%02d_root_L0_X0_Y0/ws_%c%03d%c%02d_L%d_X%d_Y%d_subtile",
-	    hem, top_lon, pole, top_lat, 
-	    hem, main_lon, pole, main_lat,
-        hem, main_lon, pole, main_lat,
-        hem, main_lon, pole, main_lat,
-        level, x, y);
-
-    return raw_path;
-}
 // Build the path name for this bucket
 std::string SGBucket::gen_base_path() const {
    // long int index;
--- a/simgear/bucket/newbucket.hxx
+++ b/simgear/bucket/newbucket.hxx
@@ -179,21 +179,7 @@ public:
     * @return tile index
     */
    inline long int gen_index() const {
-	    return ((lon + 180) << 14) + ((lat + 90) << 6) + static_cast<unsigned char>(y << 3) + x;
-    }
-
-    /**
-     * Generate a tile index for this bucket shared with all other buckets with the same lat/lon.
-     * Used as an index for VPB tiles, which are 1x1 in size.
-     *
-     * The index is constructed as follows:
-     * 
-     * 9 bits - to represent 360 degrees of longitude (-180 to 179)
-     * 8 bits - to represent 180 degrees of latitude (-90 to 89)
-     * @return tile index
-     */
-    inline long int gen_vpb_index() const {
-	    return ((lon + 180) << 8) + (lat + 90);
+	return ((lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x;
    }

    /**
@@ -209,14 +195,6 @@ public:
     */
    std::string gen_base_path() const;

-    /**
-     * Build the base path name for this bucket.
-     * @return base path in string form
-     */
-    std::string gen_vpb_base() const;
-    std::string gen_vpb_base_alt() const;
-    std::string gen_vpb_subtile(int level, int x, int y) const;
-
    /**
     * @return the center lon of a tile.
     */
--- a/simgear/bucket/test_bucket.cxx
+++ b/simgear/bucket/test_bucket.cxx
@@ -53,7 +53,7 @@ void testBasic()
    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);
    SG_CHECK_EQUAL(b2.get_chunk_lon(), -11);
    SG_CHECK_EQUAL(b2.get_chunk_lat(), -44);
@@ -62,7 +62,7 @@ void testBasic()
    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);
    SG_CHECK_EQUAL(b3.get_chunk_lon(), 123);
    SG_CHECK_EQUAL(b3.get_chunk_lat(), 9);
@@ -70,10 +70,10 @@ void testBasic()
    SG_CHECK_EQUAL(b3.get_y(), 0);
    SG_CHECK_EQUAL(b3.gen_base_path(), "e120n00/e123n09");
    SG_VERIFY(b3.isValid());
-
+    
    SGBucket defBuck;
    SG_VERIFY(!defBuck.isValid());
-
+    
    b3.make_bad();
    SG_VERIFY(!b3.isValid());

@@ -87,47 +87,19 @@ void testBasic()
    SG_CHECK_EQUAL(atAntiMeridian2.get_chunk_lon(), -180);
    SG_CHECK_EQUAL(atAntiMeridian2.get_x(), 0);

-    // check comparison operator overload
+// check comparisom operator overload
    SGBucket b4(5.11, 55.1);
    SG_VERIFY(b1 == b4); // should be equal
    SG_VERIFY(b1 == b1);
    SG_VERIFY(b1 != defBuck);
    SG_VERIFY(b1 != b2);
-
-    // check wrapping/clipping of inputs
+    
+// check wrapping/clipping of inputs
    SGBucket wrapMeridian(-200.0, 45.0);
    SG_CHECK_EQUAL(wrapMeridian.get_chunk_lon(), 160);

    SGBucket clipPole(48.9, 91);
    SG_CHECK_EQUAL(clipPole.get_chunk_lat(), 89);
-
-    // test override of a bucket's geod
-    auto geod = SGGeod::fromDegFt(-86.678, 36.1248, 599.0);
-#ifndef NO_DEPRECATED_API
-    SGBucket bna_airport;
-    bna_airport.set_bucket(geod);
-#else
-    SGBucket bna_airport(geod);
-#endif
-    SG_VERIFY(bna_airport.isValid());
-    SG_CHECK_EQUAL(bna_airport.get_chunk_lon(), -87);           // left origin of the 1-degree chunk
-    SG_CHECK_EQUAL(bna_airport.get_chunk_lat(), 36);            // bottom origin of the 1-degree chunk
-    SG_CHECK_EQUAL(bna_airport.get_x(), 1);                     // buckets are 0.25 deg wide at the W87 parallel
-                                                                //   we're 0.322 deg from the origin (second bucket)
-    SG_CHECK_EQUAL(bna_airport.get_y(), 0);                     // buckets are always 0.125 deg tall
-                                                                //   we're 0.1248 deg from the origin (first bucket)
-    SG_CHECK_EQUAL(bna_airport.gen_base_path(), "w090n30/w087n36");
-    SG_CHECK_EQUAL_EP2(bna_airport.get_width_m(), 22479.1, 0.1);
-    SG_CHECK_EQUAL_EP2(bna_airport.get_height_m(), 13914.9, 0.1);
-    SG_CHECK_EQUAL(bna_airport.gen_index_str(), "1531777");     // 0x175F81 = b01011101|01111110|000|001
-                                                                //          =   93-180 | 126-90 | 0 | 1
-                                                                //          =      -87 |     36 | 0 | 1
-
-    // test stream output
-    cout << "[TEST] BNA Airport: " << bna_airport << endl;
-    auto center = bna_airport.get_center();
-    cout << "[TEST] BNA lon: " << center.getLongitudeDeg() << endl;
-    cout << "[TEST] BNA lat: " << center.getLatitudeDeg() << endl;
 }

 void testPolar()
@@ -138,17 +110,17 @@ void testPolar()
    SG_CHECK_EQUAL(b1.get_chunk_lon(), 0);
    SG_CHECK_EQUAL(b1.get_x(), 0);
    SG_CHECK_EQUAL(b1.get_y(), 7);
-
+    
    SG_CHECK_EQUAL_EP(b1.get_highest_lat(), 90.0);
    SG_CHECK_EQUAL_EP(b1.get_width_m(), 10.0);
-
+    
    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);
-
+    
    SG_CHECK_EQUAL(b1.gen_index(), b2.gen_index());
-
+    
    SGGeod actualNorthPole1 = b1.get_corner(2);
    SGGeod actualNorthPole2 = b1.get_corner(3);
    SG_CHECK_EQUAL_EP(actualNorthPole1.getLatitudeDeg(), 90.0);
@@ -159,11 +131,11 @@ void testPolar()
    SGBucket b3(-2, 89.88);
    SGBucket b4(-7, 89.88);
    SG_CHECK_EQUAL(b3.gen_index(), b4.gen_index());
-
+    
    // south pole
    SGBucket b5(-170, -89.88);
    SGBucket b6(-179, -89.88);
-
+    
    SG_CHECK_EQUAL(b5.get_chunk_lat(), -90);
    SG_CHECK_EQUAL(b5.get_chunk_lon(), -180);
    SG_CHECK_EQUAL(b5.get_x(), 0);
@@ -171,16 +143,17 @@ void testPolar()
    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);
    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);
    SG_CHECK_EQUAL(b7.get_chunk_lon(), -168);
+
 }

 // test the tiles just below the pole (between 86 & 89 degrees N/S)
@@ -194,7 +167,7 @@ void testNearPolar()

    SGBucket b3(176.1, 88.5);
    SG_CHECK_EQUAL(b3.get_chunk_lon(), 176);
-
+    
    SGBucket b4(-178, 88.5);
    SG_CHECK_EQUAL(b4.get_chunk_lon(), -180);
 }
@@ -208,7 +181,7 @@ void testOffset()
    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));
    SG_CHECK_EQUAL(b2.get_chunk_lat(), 22);
@@ -217,7 +190,7 @@ void testOffset()
    SG_CHECK_EQUAL(b2.get_y(), 0);

    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.
@@ -226,7 +199,7 @@ void testOffset()
    SG_CHECK_EQUAL(b3.get_chunk_lon(), -61);
    SG_CHECK_EQUAL(b3.get_x(), 1);
    SG_CHECK_EQUAL(b3.get_y(), 0);
-
+    
    SG_CHECK_EQUAL(b3.gen_index(), sgBucketOffset(-59.8, 21.9, -3, 1));
 }

@@ -237,40 +210,40 @@ void testPolarOffset()
    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));
    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);
-
+    
    SG_CHECK_EQUAL(b2.gen_index(), sgBucketOffset(-11.7, -89.6, -2, 0));
-
-    // offset and wrap
+    
+// offset and wrap
    SGBucket b3(-170, 89.1);
    SGBucket b4(b3.sibling(-1, 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);
-
+    
    SG_CHECK_EQUAL(b4.gen_index(), sgBucketOffset(-170, 89.1, -1, 0));

-
+    
    SGBucket b5(177, 87.3);
    SGBucket b6(b5.sibling(1, 1));
    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);
-
+    
    SG_CHECK_EQUAL(b6.gen_index(), sgBucketOffset(177, 87.3, 1, 1));

    // offset vertically towards the pole
    SGBucket b7(b1.sibling(0, -5));
    SG_VERIFY(!b7.isValid());
-
+    
    SG_VERIFY(!SGBucket(0, 90).sibling(0, 1).isValid());
 }

@@ -283,80 +256,29 @@ void testOffsetWrap()
    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));
    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));
-}
-
-void testSiblings()
-{
-    SGBucket bna_airport(-86.678, 36.1248);
-    SG_VERIFY(bna_airport.isValid());
-
-    // retrieve the sibling two positions north-east of my position
-    auto sib1 = bna_airport.sibling(2, 2);
-    SG_CHECK_EQUAL(sib1.get_chunk_lon(), bna_airport.get_chunk_lon());
-    SG_CHECK_EQUAL(sib1.get_chunk_lat(), bna_airport.get_chunk_lat());
-    SG_CHECK_EQUAL(sib1.get_x(), 3);        // my x-pos (1) + 2 = 3
-    SG_CHECK_EQUAL(sib1.get_y(), 2);        // my y-pos (0) + 2 = 2
-    SG_CHECK_EQUAL(sib1.gen_base_path(), bna_airport.gen_base_path());
-
-    // retrieve the one sibling two positions to the north-east
-    std::vector<SGBucket> siblings;
-    bna_airport.siblings(2, 2, siblings);
-    SG_CHECK_EQUAL(siblings.size(), static_cast<std::vector<SGBucket>::size_type>(1));
-    siblings.clear();
-
-    // retrieve the one sibling at the chunk origin of sib1
-    sib1.siblings(-2, -2, siblings);
-    SG_CHECK_EQUAL(siblings.size(), static_cast<std::vector<SGBucket>::size_type>(1));
-    siblings.clear();
-
-    // calculate delta between two buckets
-    int dx = 0;
-    int dy = 0;
-    sgBucketDiff(bna_airport, sib1, &dx, &dy);
-    SG_CHECK_EQUAL(dx, 2);
-    SG_CHECK_EQUAL(dy, 2);
-
-    // retrieve all siblings between two geodetic locations
-    auto geod_bna = SGGeod::fromDegFt(-86.678, 36.1248, 599.0);
-    auto geod_m54 = SGGeod::fromDegFt(-86.317, 36.1908, 122.0);
-    sgGetBuckets(geod_bna, geod_m54, siblings);
-    SG_CHECK_EQUAL(siblings.size(), static_cast<std::vector<SGBucket>::size_type>(4));
-    siblings.clear();
-
-    // edge cases
-
-    // ensure you cannot retrieve the sibling of an invalid bucket
-    SGBucket bad;
-    auto bad_sib = bad.sibling(1, 1);
-    SG_CHECK_EQUAL(bad_sib.get_chunk_lon(), -1000);
-    SG_CHECK_EQUAL(bad.siblings(2, 2, siblings), 0);
-
-    // if we drop below the 22nd parallel, the bucket widths are half the size
-    // expect this to retrieve two buckets
-    bna_airport.siblings(0, -160, siblings);
-    SG_CHECK_EQUAL(siblings.size(), static_cast<std::vector<SGBucket>::size_type>(2));
-    siblings.clear();
+    
+    
 }

 int main(int argc, char* argv[])
 {
    testBucketSpans();
-
+    
    testBasic();
    testPolar();
    testNearPolar();
    testOffset();
    testOffsetWrap();
    testPolarOffset();
-    testSiblings();
-
+    
    cout << "all tests passed OK" << endl;
    return 0; // passed
 }
+
--- a/simgear/package/Delegate.cxx
+++ b/simgear/package/Delegate.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2017  James Turner - zakalawe@mac.com
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,25 +15,21 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //

-#include <simgear/package/Delegate.hxx>
-#include <simgear/package/Install.hxx>
-#include <simgear/package/Package.hxx>
-#include <simgear/package/Catalog.hxx>
+#include "BVHMaterial.hxx"

-namespace simgear
+namespace simgear {
+
+BVHMaterial::BVHMaterial() :
+    _solid(true),
+    _friction_factor(1),
+    _rolling_friction(0.02),
+    _bumpiness(0),
+    _load_resistance(1e30)
 {
+}

-	namespace pkg
-	{
+BVHMaterial::~BVHMaterial()
+{
+}

-		void Delegate::installStatusChanged(InstallRef aInstall, StatusCode aReason)
-		{
-		}
-
-		void Delegate::dataForThumbnail(const std::string& aThumbnailUrl,
-			size_t lenth, const uint8_t* bytes)
-		{
-		}
-
-	} // of namespace pkg
-} // of namespace simgear
+}
--- a/simgear/bvh/BVHMaterial.hxx
+++ b/simgear/bvh/BVHMaterial.hxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2008 - 2021  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -19,29 +19,19 @@
 #define BVHMaterial_hxx

 #include <simgear/structure/SGReferenced.hxx>
-#include <simgear/props/props.hxx>
-
-#include <cstdio>

 namespace simgear {

 class BVHMaterial : public SGReferenced {
 public:
-    BVHMaterial() = default;
-    virtual ~BVHMaterial() = default;
+    BVHMaterial();
+    virtual ~BVHMaterial();

    /**
     * Return if the surface material is solid, if it is not solid, a fluid
     * can be assumed, that is usually water.
     */
-    bool get_solid () const {
-      return _solid_is_prop ? _solid_property->getBoolValue() : _solid;
-    }
-
-    /**
-     * Return whether the solid factor is a propery.
-     */
-    bool solid_is_prop () const { return _solid_is_prop; }
+    bool get_solid () const { return _solid; }
    
    /**
     * Get the friction factor for that material
@@ -65,26 +55,21 @@ public:

 protected:    
    // True if the material is solid, false if it is a fluid
-    bool _solid = true;
+    bool _solid;
    
    // the friction factor of that surface material
-    double _friction_factor = 1.0;
+    double _friction_factor;
    
    // the rolling friction of that surface material
-    double _rolling_friction = 0.02;
+    double _rolling_friction;
    
    // the bumpiness of that surface material
-    double _bumpiness = 0.0;
+    double _bumpiness;
    
    // the load resistance of that surface material
-    double _load_resistance = 1e30;
-
-    // Placeholder for the solid property, if defined
-    SGPropertyNode_ptr _solid_property;
-    bool _solid_is_prop = false;
+    double _load_resistance;
 };

-
 }

 #endif
--- a/simgear/bvh/BVHPageNode.cxx
+++ b/simgear/bvh/BVHPageNode.cxx
@@ -15,8 +15,6 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //

-#include <simgear_config.h>
-
 #include "BVHPageNode.hxx"

 #include "BVHPager.hxx"
--- a/simgear/bvh/BVHPageRequest.cxx
+++ b/simgear/bvh/BVHPageRequest.cxx
@@ -15,8 +15,6 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //

-#include <simgear_config.h>
-
 #include "BVHPageRequest.hxx"

 namespace simgear {
--- a/simgear/bvh/BVHPager.cxx
+++ b/simgear/bvh/BVHPager.cxx
@@ -15,14 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //

-#include <simgear_config.h>
-
 #include "BVHPager.hxx"

 #include <list>
-#include <mutex>

 #include <simgear/threads/SGThread.hxx>
+#include <simgear/threads/SGGuard.hxx>

 #include "BVHPageNode.hxx"
 #include "BVHPageRequest.hxx"
@@ -37,12 +35,12 @@ struct BVHPager::_PrivateData : protected SGThread {
    struct _LockedQueue {
        void _push(const _Request& request)
        {
-            std::lock_guard<std::mutex> scopeLock(_mutex);
+            SGGuard<SGMutex> scopeLock(_mutex);
            _requestList.push_back(request);
        }
        _Request _pop()
        {
-            std::lock_guard<std::mutex> scopeLock(_mutex);
+            SGGuard<SGMutex> scopeLock(_mutex);
            if (_requestList.empty())
                return _Request();
            _Request request;
@@ -51,7 +49,7 @@ struct BVHPager::_PrivateData : protected SGThread {
            return request;
        }
    private:
-        std::mutex _mutex;
+        SGMutex _mutex;
        _RequestList _requestList;
    };
    
@@ -62,7 +60,7 @@ struct BVHPager::_PrivateData : protected SGThread {
        }
        void _push(const _Request& request)
        {
-            std::lock_guard<std::mutex> scopeLock(_mutex);
+            SGGuard<SGMutex> scopeLock(_mutex);
            bool needSignal = _requestList.empty();
            _requestList.push_back(request);
            if (needSignal)
@@ -70,7 +68,7 @@ struct BVHPager::_PrivateData : protected SGThread {
        }
        _Request _pop()
        {
-            std::lock_guard<std::mutex> scopeLock(_mutex);
+            SGGuard<SGMutex> scopeLock(_mutex);
            while (_requestList.empty())
                _waitCondition.wait(_mutex);
            _Request request;
@@ -79,7 +77,7 @@ struct BVHPager::_PrivateData : protected SGThread {
            return request;
        }
    private:
-        std::mutex _mutex;
+        SGMutex _mutex;
        SGWaitCondition _waitCondition;
        _RequestList _requestList;
    };
--- a/simgear/bvh/BVHStaticGeometryBuilder.hxx
+++ b/simgear/bvh/BVHStaticGeometryBuilder.hxx
@@ -47,10 +47,8 @@ public:
        _currentMaterial(0),
        _currentMaterialIndex(~0u)
    { }
-
    virtual ~BVHStaticGeometryBuilder()
-    {
-    }
+    { }

    struct LeafRef {
        LeafRef(const BVHStaticLeaf* leaf, const BVHStaticData& data) :
@@ -64,7 +62,7 @@ public:
    };
    typedef std::list<LeafRef> LeafRefList;

-    struct LeafRefLess {
+    struct LeafRefLess : public std::binary_function<LeafRef, LeafRef, bool> {
        LeafRefLess(unsigned sortAxis) : _sortAxis(sortAxis) {}
        bool operator()(const LeafRef& x, const LeafRef& y)
        { return x._center[_sortAxis] < y._center[_sortAxis]; }
@@ -113,7 +111,6 @@ public:
            return;
        _triangleSet.insert(indexKey);
        BVHStaticTriangle* staticTriangle;
-        // REVIEW: Memory Leak - 11,680 bytes in 365 blocks are indirectly lost
        staticTriangle = new BVHStaticTriangle(_currentMaterialIndex, indices);
        _leafRefList.push_back(LeafRef(staticTriangle, *_staticData));
    }
--- a/simgear/bvh/BVHStaticNode.cxx
+++ b/simgear/bvh/BVHStaticNode.cxx
@@ -15,8 +15,6 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //

-#include <simgear_config.h>
-
 #include "BVHStaticNode.hxx"

 namespace simgear {
--- a/simgear/bvh/CMakeLists.txt
+++ b/simgear/bvh/CMakeLists.txt
@@ -39,11 +39,14 @@ set(SOURCES
    BVHStaticNode.cxx
    BVHStaticTriangle.cxx
    BVHSubTreeCollector.cxx
+    BVHMaterial.cxx
    BVHTransform.cxx
 )

 simgear_component(bvh bvh "${SOURCES}" "${HEADERS}")

 if(ENABLE_TESTS)
-  add_simgear_autotest(bvhtest bvhtest.cxx)
+  add_executable(bvhtest bvhtest.cxx)
+  target_link_libraries(bvhtest SimGearCore)
+  add_test(bvhtest ${EXECUTABLE_OUTPUT_PATH}/bvhtest)
 endif(ENABLE_TESTS)
--- a/simgear/bvh/bvhtest.cxx
+++ b/simgear/bvh/bvhtest.cxx
@@ -15,7 +15,6 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //

-#include <simgear_config.h>
 #include <iostream>
 #include <simgear/structure/SGSharedPtr.hxx>

--- a/simgear/canvas/CMakeLists.txt
+++ b/simgear/canvas/CMakeLists.txt
@@ -29,7 +29,7 @@ set(SOURCES
  VGInitOperation.cxx
 )

-add_subdirectory(${OPENVG}/src)
+add_subdirectory(ShivaVG/src)
 add_subdirectory(elements)
 add_subdirectory(events)
 add_subdirectory(layout)
--- a/simgear/canvas/Canvas.cxx
+++ b/simgear/canvas/Canvas.cxx
@@ -1,5 +1,4 @@
-///@file
-/// The canvas for rendering with the 2d API
+// The canvas for rendering with the 2d API
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -17,16 +16,12 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA

-#include <simgear_config.h>
-
 #include "Canvas.hxx"
 #include "CanvasEventManager.hxx"
 #include "CanvasEventVisitor.hxx"
 #include "CanvasPlacement.hxx"
-
 #include <simgear/canvas/events/KeyboardEvent.hxx>
 #include <simgear/canvas/events/MouseEvent.hxx>
-#include <simgear/misc/strutils.hxx>
 #include <simgear/scene/util/parse_color.hxx>
 #include <simgear/scene/util/RenderConstants.hxx>

@@ -35,79 +30,13 @@
 #include <osgText/Text>
 #include <osgViewer/Viewer>

+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/foreach.hpp>
+
 namespace simgear
 {
 namespace canvas
 {
-  static int globalinstanceid = 1;
-  /**
-   * Camera Callback for moving completed canvas images to subscribed listener.
-   */
-  class CanvasImageCallback : public osg::Camera::DrawCallback {
-    public:
-    osg::Image *_rawImage;
-
-    CanvasImageCallback(osg::Image *rawImage)
-    : _min_delta_tick(1.0 / 8.0) {
-      _previousFrameTick = osg::Timer::instance()->tick();
-      _rawImage = rawImage;
-      SG_LOG(SG_GENERAL,SG_INFO,"CanvasImageCallback created. instance is " << instanceid);
-    }
-
-    virtual void operator()(osg::RenderInfo& renderInfo) const {
-      osg::Timer_t n = osg::Timer::instance()->tick();
-      double dt = osg::Timer::instance()->delta_s(_previousFrameTick, n);
-      if (dt < _min_delta_tick)
-        return;
-      _previousFrameTick = n;
-      SG_LOG(SG_GENERAL,SG_DEBUG,"CanvasImageCallback " << instanceid << ": image available for " << _subscribers.size() << " subscribers. camera is " << renderInfo.getCurrentCamera());
-
-      bool hasSubscribers = false;
-      {
-        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_lock);
-        hasSubscribers = !_subscribers.empty();
-      }
-      if (hasSubscribers) {
-        //Make sure image can be overwritten by next frame while it is still returned to the client
-        osg::Image* image = new osg::Image(*_rawImage, osg::CopyOp::DEEP_COPY_ALL);
-        {
-          OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_lock);
-          while (!_subscribers.empty()) {
-            try {
-              CanvasImageReadyListener *subs = _subscribers.back();
-              if (subs){
-                subs->imageReady(image);
-              }else{
-                SG_LOG(SG_GENERAL,SG_WARN,"CanvasImageCallback subscriber null");
-              }
-            } catch (...) { }
-            _subscribers.pop_back();
-          }
-        }
-      }
-    }
-
-    void subscribe(CanvasImageReadyListener * subscriber) {
-      OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_lock);
-      _subscribers.push_back(subscriber);
-    }
-
-    void unsubscribe(CanvasImageReadyListener * subscriber) {
-      OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_lock);
-      _subscribers.remove(subscriber);
-    }
-
-    int getSubscriberCount() {
-      return _subscribers.size();
-    }
-
-    private:
-      mutable list<CanvasImageReadyListener*> _subscribers;
-      mutable OpenThreads::Mutex _lock;
-      mutable double _previousFrameTick;
-      double _min_delta_tick;
-      int instanceid = globalinstanceid++;
-  };

  //----------------------------------------------------------------------------
  Canvas::CullCallback::CullCallback(const CanvasWeakPtr& canvas):
@@ -133,12 +62,19 @@ namespace canvas
  //----------------------------------------------------------------------------
  Canvas::Canvas(SGPropertyNode* node):
    PropertyBasedElement(node),
+    _canvas_mgr(0),
    _event_manager(new EventManager),
+    _size_x(-1),
+    _size_y(-1),
+    _view_width(-1),
+    _view_height(-1),
    _status(node, "status"),
-    _status_msg(node, "status-msg")
+    _status_msg(node, "status-msg"),
+    _sampling_dirty(false),
+    _render_dirty(true),
+    _visible(true),
+    _render_always(false)
  {
-    // Looks like we need to propogate value changes upwards.
-    node->setAttribute(SGPropertyNode::VALUE_CHANGED_DOWN, true);
    _status = 0;
    setStatusFlags(MISSING_SIZE_X | MISSING_SIZE_Y);

@@ -298,10 +234,6 @@ namespace canvas

    if( _status & STATUS_DIRTY )
    {
-      // Retrieve reference here, to ensure the scene group is not deleted while
-      // creating the new texture and camera
-      osg::ref_ptr<osg::Group> root_scene_group = _root_group->getSceneGroup();
-
      _texture.setSize(_size_x, _size_y);

      if( !_texture.serviceable() )
@@ -319,21 +251,6 @@ namespace canvas

      osg::Camera* camera = _texture.getCamera();

-      string canvasname = _node->getStringValue("name");
-      int renderToImage = _node->getBoolValue("render-to-image");
-
-      if (renderToImage){
-        CanvasImageCallback *_screenshotCallback = dynamic_cast<CanvasImageCallback*> (camera->getFinalDrawCallback());
-        if (!_screenshotCallback) {
-          // no draw callback yet
-          osg::Image* shot = new osg::Image();
-          shot->allocateImage(getSizeX(), getSizeY(), 1, GL_RGB, GL_UNSIGNED_BYTE);
-          camera->attach(osg::Camera::COLOR_BUFFER, shot);
-          camera->setFinalDrawCallback(new CanvasImageCallback(shot));
-          SG_LOG(SG_GENERAL,SG_INFO,"CanvasImage: attached image and draw callback to camera " << camera << " for canvas " << canvasname << ". Ready for subscriber now.");
-        }
-      }
-
      // TODO Allow custom render order? For now just keep in order with
      //      property tree.
      camera->setRenderOrder(osg::Camera::PRE_RENDER, _node->getIndex());
@@ -342,7 +259,7 @@ namespace canvas
      parseColor(_node->getStringValue("background"), clear_color);
      camera->setClearColor(clear_color);

-      camera->addChild(root_scene_group);
+      camera->addChild(_root_group->getMatrixTransform());

      if( _texture.serviceable() )
      {
@@ -362,7 +279,7 @@ namespace canvas

    if( _visible || _render_always )
    {
-      for(auto& canvas_weak: _child_canvases)
+      BOOST_FOREACH(CanvasWeakPtr canvas_weak, _child_canvases)
      {
        // TODO should we check if the image the child canvas is displayed
        //      within is really visible?
@@ -374,7 +291,7 @@ namespace canvas
      if( _render_dirty )
      {
        // Also mark all canvases this canvas is displayed within as dirty
-        for(auto& canvas_weak: _parent_canvases)
+        BOOST_FOREACH(CanvasWeakPtr canvas_weak, _parent_canvases)
        {
          CanvasPtr canvas = canvas_weak.lock();
          if( canvas )
@@ -402,13 +319,6 @@ namespace canvas
      _sampling_dirty = false;
      _render_dirty = true;
    }
-	
-    if( _anisotropy_dirty )
-    {
-      _texture.setMaxAnisotropy( _node->getFloatValue("anisotropy") );
-      _anisotropy_dirty = false;
-      _render_dirty = true;
-    }

    while( !_dirty_placements.empty() )
    {
@@ -440,41 +350,6 @@ namespace canvas
    }
  }

-  int Canvas::subscribe(CanvasImageReadyListener * subscriber) {
-    osg::Camera* camera = _texture.getCamera();
-    const string canvasname = _node->getStringValue("name");
-
-    SG_LOG(SG_GENERAL,SG_DEBUG,"CanvasImage: subscribe to canvas " << canvasname.c_str() << ", camera ="<< camera);
-
-    if (!_node->getBoolValue("render-to-image")) {
-      SG_LOG(SG_GENERAL,SG_INFO,"CanvasImage: Setting render-to-image");
-      _node->addChild("render-to-image", 0)->setBoolValue(1);
-      setStatusFlags(STATUS_DIRTY, true);
-    }
-
-    CanvasImageCallback *_screenshotCallback = dynamic_cast<CanvasImageCallback*> (camera->getFinalDrawCallback());
-    if (_screenshotCallback) {
-      // Camera ready for subscriber. Otherwise, draw callback is created by canvas thread later.
-      SG_LOG(SG_GENERAL,SG_DEBUG,"CanvasImage: adding subscriber to camera draw callback");
-      _screenshotCallback->subscribe(subscriber);
-      // TODO: check: Is this the correct way to ensure the canvas will be available?
-      enableRendering(true);
-      return 1;
-    }
-    return 0;
-  }
-
-  int Canvas::unsubscribe(CanvasImageReadyListener * subscriber) {
-    osg::Camera* camera = _texture.getCamera();
-    SG_LOG(SG_GENERAL,SG_DEBUG,"CanvasImage: unsubscribe");
-    CanvasImageCallback *cb = dynamic_cast<CanvasImageCallback*> (camera->getFinalDrawCallback());
-    if (cb) {
-      SG_LOG(SG_GENERAL,SG_DEBUG,"CanvasImage: unsubscribe from camera " << camera);
-      cb->unsubscribe(subscriber);
-    }
-    return 0;
-  }
-
  //----------------------------------------------------------------------------
  bool Canvas::addEventListener( const std::string& type,
                                 const EventListener& cb )
@@ -645,8 +520,8 @@ namespace canvas
  {
    const std::string& name = node->getNameString();

-    if(    strutils::starts_with(name, "status")
-        || strutils::starts_with(name, "data-") )
+    if(    boost::starts_with(name, "status")
+        || boost::starts_with(name, "data-") )
      return;
    _render_dirty = true;

@@ -661,7 +536,7 @@ namespace canvas
        if( !placements.empty() )
        {
          bool placement_dirty = false;
-          for(auto& placement: placements)
+          BOOST_FOREACH(PlacementPtr& placement, placements)
          {
            // check if change can be directly handled by placement
            if(    placement->getProps() == node->getParent()
@@ -700,10 +575,6 @@ namespace canvas
      {
        _sampling_dirty = true;
      }
-      else if( name == "anisotropy" )
-      {
-        _anisotropy_dirty = true;
-      }
      else if( name == "additive-blend" )
      {
        _texture.useAdditiveBlend( node->getBoolValue() );
--- a/simgear/canvas/Canvas.hxx
+++ b/simgear/canvas/Canvas.hxx
@@ -33,7 +33,7 @@
 #include <osg/NodeCallback>
 #include <osg/observer_ptr>

-#include <memory>
+#include <boost/scoped_ptr.hpp>
 #include <string>

 namespace simgear
@@ -44,17 +44,6 @@ namespace canvas
  class CanvasMgr;
  class MouseEvent;

-  /**
-   * A listener interested in completed canvas drawing.
-   */
-  class CanvasImageReadyListener {
-  public:
-    virtual void imageReady(osg::ref_ptr<osg::Image>) = 0;
-    virtual ~CanvasImageReadyListener()
-    {
-    }
-  };
-
  /**
   * Canvas to draw onto (to an off-screen render target).
   */
@@ -82,18 +71,18 @@ namespace canvas
        public osg::NodeCallback
      {
        public:
-          explicit CullCallback(const CanvasWeakPtr& canvas);
+          CullCallback(const CanvasWeakPtr& canvas);

        private:
          CanvasWeakPtr _canvas;

-          void operator()(osg::Node* node, osg::NodeVisitor* nv) override;
+          virtual void operator()(osg::Node* node, osg::NodeVisitor* nv);
      };
      typedef osg::ref_ptr<CullCallback> CullCallbackPtr;

-      explicit Canvas(SGPropertyNode* node);
+      Canvas(SGPropertyNode* node);
      virtual ~Canvas();
-      void onDestroy() override;
+      virtual void onDestroy();

      void setCanvasMgr(CanvasMgr* canvas_mgr);
      CanvasMgr* getCanvasMgr() const;
@@ -171,12 +160,7 @@ namespace canvas
       */
      void enableRendering(bool force = false);

-      void update(double delta_time_sec) override;
-
-      osg::Camera* getCamera();
-      int subscribe(CanvasImageReadyListener * subscriber);
-      int unsubscribe(CanvasImageReadyListener * subscriber);
-      int getSubscriberCount();
+      void update(double delta_time_sec);

      bool addEventListener(const std::string& type, const EventListener& cb);
      bool dispatchEvent(const EventPtr& event);
@@ -200,9 +184,11 @@ namespace canvas
      bool propagateEvent( EventPtr const& event,
                           EventPropagationPath const& path );

-      void childAdded(SGPropertyNode* parent, SGPropertyNode* child) override;
-      void childRemoved(SGPropertyNode* parent, SGPropertyNode* child) override;
-      void valueChanged(SGPropertyNode * node) override;
+      virtual void childAdded( SGPropertyNode * parent,
+                               SGPropertyNode * child );
+      virtual void childRemoved( SGPropertyNode * parent,
+                                 SGPropertyNode * child );
+      virtual void valueChanged (SGPropertyNode * node);

      osg::Texture2D* getTexture() const;

@@ -225,22 +211,21 @@ namespace canvas

    protected:

-      CanvasMgr *_canvas_mgr {nullptr};
+      CanvasMgr        *_canvas_mgr;

-      std::unique_ptr<EventManager> _event_manager;
+      boost::scoped_ptr<EventManager> _event_manager;

-      int _size_x {-1},
-          _size_y {-1},
-          _view_width {-1},
-          _view_height {-1};
+      int _size_x,
+          _size_y,
+          _view_width,
+          _view_height;

      PropertyObject<int>           _status;
      PropertyObject<std::string>   _status_msg;

-      bool _sampling_dirty {false},
-           _anisotropy_dirty {false},
-           _render_dirty {true},
-           _visible {true};
+      bool _sampling_dirty,
+           _render_dirty,
+           _visible;

      ODGauge _texture;

@@ -250,9 +235,7 @@ namespace canvas
      ElementWeakPtr _focus_element;

      CullCallbackPtr _cull_callback;
-
-      /** Used to disable automatic lazy rendering (culling) */
-      bool _render_always {false};
+      bool _render_always; //!< Used to disable automatic lazy rendering (culling)

      std::vector<SGPropertyNode*> _dirty_placements;
      std::vector<Placements> _placements;
@@ -269,8 +252,8 @@ namespace canvas

      static SystemAdapterPtr _system_adapter;

-      Canvas(const Canvas&) = delete;
-      Canvas& operator=(const Canvas&) = delete;
+      Canvas(const Canvas&); // = delete;
+      Canvas& operator=(const Canvas&); // = delete;
  };

 } // namespace canvas
--- a/simgear/canvas/CanvasEvent.cxx
+++ b/simgear/canvas/CanvasEvent.cxx
@@ -1,5 +1,4 @@
-///@file
-/// Canvas Event for event model similar to DOM Level 3 Event Model
+// Canvas Event for event model similar to DOM Level 3 Event Model
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -17,8 +16,6 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA

-#include <simgear_config.h>
-
 #include "CanvasEvent.hxx"

 namespace simgear
@@ -126,10 +123,10 @@ namespace canvas
  //----------------------------------------------------------------------------
  std::string Event::typeToStr(int type)
  {
-    auto const& map_by_id = getTypeMap().by<id>();
+    TypeMap const& type_map = getTypeMap();

-    auto it = map_by_id.find(type);
-    if( it == map_by_id.end() )
+    TypeMap::map_by<id>::const_iterator it = type_map.by<id>().find(type);
+    if( it == type_map.by<id>().end() )
      return "unknown";
    return it->second;
  }
--- a/simgear/canvas/CanvasEvent.hxx
+++ b/simgear/canvas/CanvasEvent.hxx
@@ -65,11 +65,6 @@ namespace canvas
      // of the actual event instances.
      virtual ~Event();

-      /**
-       * Clone event and set to the given type (Same type if not specified)
-       */
-      virtual Event* clone(int type = 0) const = 0;
-
      /**
       * Get whether this events support bubbling
       */
@@ -115,14 +110,7 @@ namespace canvas
       */
      bool defaultPrevented() const;

-      /**
-       * Register a new type string or get the id of an existing type string
-       *
-       * @param type    Type string
-       * @return Id of the given @a type
-       */
      static int getOrRegisterType(const std::string& type);
-
      static int strToType(const std::string& type);
      static std::string typeToStr(int type);

--- a/simgear/canvas/CanvasEventManager.cxx
+++ b/simgear/canvas/CanvasEventManager.cxx
@@ -1,5 +1,4 @@
-///@file
-/// Manage event handling inside a Canvas similar to the DOM Level 3 Event Model
+// Manage event handling inside a Canvas similar to the DOM Level 3 Event Model
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -17,12 +16,9 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA

-#include <simgear_config.h>
-
 #include "CanvasEventManager.hxx"
-#include "elements/CanvasElement.hxx"
-#include "events/MouseEvent.hxx"
-
+#include <simgear/canvas/events/MouseEvent.hxx>
+#include <simgear/canvas/elements/CanvasElement.hxx>
 #include <cmath>

 namespace simgear
@@ -117,8 +113,6 @@ namespace canvas
        return handled;
      }
      case Event::DRAG:
-      case Event::DRAG_START:
-      case Event::DRAG_END:
        if( !_last_mouse_down.valid() )
          return false;
        else
--- a/simgear/canvas/CanvasEventManager.hxx
+++ b/simgear/canvas/CanvasEventManager.hxx
@@ -1,5 +1,4 @@
-///@file
-/// Manage event handling inside a Canvas similar to the DOM Level 3 Event Model
+// Manage event handling inside a Canvas similar to the DOM Level 3 Event Model
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
--- a/simgear/canvas/CanvasEventTypes.hxx
+++ b/simgear/canvas/CanvasEventTypes.hxx
@@ -1,5 +1,4 @@
-///@file
-/// Mapping between canvas gui Event types and their names
+// Mapping between canvas gui Event types and their names
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -26,8 +25,6 @@ ENUM_MAPPING(MOUSE_UP,    "mouseup",    MouseEvent)
 ENUM_MAPPING(CLICK,       "click",      MouseEvent)
 ENUM_MAPPING(DBL_CLICK,   "dblclick",   MouseEvent)
 ENUM_MAPPING(DRAG,        "drag",       MouseEvent)
-ENUM_MAPPING(DRAG_START,  "dragstart",  MouseEvent)
-ENUM_MAPPING(DRAG_END,    "dragend",    MouseEvent)
 ENUM_MAPPING(WHEEL,       "wheel",      MouseEvent)
 ENUM_MAPPING(MOUSE_MOVE,  "mousemove",  MouseEvent)
 ENUM_MAPPING(MOUSE_OVER,  "mouseover",  MouseEvent)
--- a/simgear/canvas/CanvasEventVisitor.cxx
+++ b/simgear/canvas/CanvasEventVisitor.cxx
@@ -1,6 +1,5 @@
-///@file
-/// Visitor for traversing a canvas element hierarchy similar to the traversal
-/// of the DOM Level 3 Event Model
+// Visitor for traversing a canvas element hierarchy similar to the traversal
+// of the DOM Level 3 Event Model
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -18,11 +17,9 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA

-#include <simgear_config.h>
-
 #include "CanvasEvent.hxx"
 #include "CanvasEventVisitor.hxx"
-#include "elements/CanvasElement.hxx"
+#include <simgear/canvas/elements/CanvasElement.hxx>

 namespace simgear
 {
--- a/simgear/canvas/CanvasEventVisitor.hxx
+++ b/simgear/canvas/CanvasEventVisitor.hxx
@@ -1,6 +1,5 @@
-///@file
-/// Visitor for traversing a canvas element hierarchy similar to the traversal
-/// of the DOM Level 3 Event Model
+// Visitor for traversing a canvas element hierarchy similar to the traversal
+// of the DOM Level 3 Event Model
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
--- a/simgear/canvas/CanvasMgr.cxx
+++ b/simgear/canvas/CanvasMgr.cxx
@@ -1,5 +1,4 @@
-///@file
-/// Canvas with 2D rendering API
+// Canvas with 2D rendering API
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -17,12 +16,12 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA

-#include <simgear_config.h>
-
 #include "CanvasMgr.hxx"
 #include "Canvas.hxx"
 #include "CanvasEventManager.hxx"

+#include <boost/bind.hpp>
+
 namespace simgear
 {
 namespace canvas
--- a/simgear/canvas/CanvasMgr.hxx
+++ b/simgear/canvas/CanvasMgr.hxx
@@ -1,5 +1,4 @@
-///@file
-/// Canvas with 2D rendering API
+// Canvas with 2D rendering API
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -28,39 +27,42 @@ namespace simgear
 namespace canvas
 {

-class CanvasMgr : public PropertyBasedMgr
-{
-public:
-    /**
-     * @param node    Root node of branch used to control canvasses
-     */
-    CanvasMgr(SGPropertyNode_ptr node);
+  class CanvasMgr:
+    public PropertyBasedMgr
+  {
+    public:

-    /**
-     * Create a new canvas
-     *
-     * @param name    Name of the new canvas
-     */
-    CanvasPtr createCanvas(const std::string& name = "");
+      /**
+       * @param node    Root node of branch used to control canvasses
+       */
+      CanvasMgr(SGPropertyNode_ptr node);

-    /**
-     * Get ::Canvas by index
-     *
-     * @param index Index of texture node in /canvas/by-index/
-     */
-    CanvasPtr getCanvas(size_t index) const;
+      /**
+       * Create a new canvas
+       *
+       * @param name    Name of the new canvas
+       */
+      CanvasPtr createCanvas(const std::string& name = "");

-    /**
-     * Get ::Canvas by name
-     *
-     * @param name Value of child node "name" in
-     *             /canvas/by-index/texture[i]/name
-     */
-    CanvasPtr getCanvas(const std::string& name) const;
+      /**
+       * Get ::Canvas by index
+       *
+       * @param index Index of texture node in /canvas/by-index/
+       */
+      CanvasPtr getCanvas(size_t index) const;

-protected:
-    void elementCreated(PropertyBasedElementPtr element) override;
-};
+      /**
+       * Get ::Canvas by name
+       *
+       * @param name Value of child node "name" in
+       *             /canvas/by-index/texture[i]/name
+       */
+      CanvasPtr getCanvas(const std::string& name) const;
+
+    protected:
+
+      virtual void elementCreated(PropertyBasedElementPtr element);
+  };

 } // namespace canvas
 } // namespace simgear
--- a/simgear/canvas/CanvasObjectPlacement.cxx
+++ b/simgear/canvas/CanvasObjectPlacement.cxx
@@ -1,5 +1,4 @@
-///@file
-/// Canvas placement for placing a canvas texture onto osg objects
+// Canvas placement for placing a canvas texture onto osg objects.
 //
 // It also provides a SGPickCallback for passing mouse events to the canvas and
 // manages emissive lighting of the placed canvas.
@@ -20,8 +19,6 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA

-#include <simgear_config.h>
-
 #include "Canvas.hxx"
 #include "CanvasObjectPlacement.hxx"
 #include <simgear/canvas/events/MouseEvent.hxx>
--- a/simgear/canvas/CanvasObjectPlacement.hxx
+++ b/simgear/canvas/CanvasObjectPlacement.hxx
@@ -1,5 +1,5 @@
 ///@file
-/// Placement for putting a canvas texture onto OpenSceneGraph objects
+/// Placement for putting a canvas texture onto OpenSceneGraph objects.
 ///
 /// It also provides a SGPickCallback for passing mouse events to the canvas and
 /// manages emissive lighting of the placed canvas.
@@ -60,7 +60,7 @@ namespace canvas
       */
      void setCaptureEvents(bool enable);

-      bool childChanged(SGPropertyNode* child) override;
+      virtual bool childChanged(SGPropertyNode* child);

    protected:
      typedef SGSharedPtr<SGPickCallback> PickCallbackPtr;
--- a/simgear/canvas/CanvasPlacement.cxx
+++ b/simgear/canvas/CanvasPlacement.cxx
@@ -1,5 +1,4 @@
-///@file
-/// Base class for canvas placements
+// Base class for canvas placements
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -17,7 +16,6 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA

-#include <simgear_config.h>
 #include "CanvasPlacement.hxx"
 #include <simgear/props/props.hxx>

--- a/simgear/canvas/CanvasPlacement.hxx
+++ b/simgear/canvas/CanvasPlacement.hxx
@@ -1,5 +1,4 @@
-///@file
-/// Base class for canvas placements
+// Base class for canvas placements
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -41,8 +40,9 @@ namespace canvas
    protected:
      SGPropertyNode_ptr _node;

-      Placement(const Placement&) = delete;
-      Placement& operator=(const Placement&) = delete;
+    private:
+      Placement(const Placement&) /* = delete */;
+      Placement& operator=(const Placement&) /* = delete */;
  };

 } // namespace canvas
--- a/simgear/canvas/CanvasSystemAdapter.hxx
+++ b/simgear/canvas/CanvasSystemAdapter.hxx
@@ -1,5 +1,4 @@
-///@file
-/// Adapter for using the canvas with different applications
+// Adapter for using the canvas with different applications
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -30,10 +29,6 @@ namespace HTTP { class Client; }
 namespace canvas
 {

-  /**
-   * Provides access to different required systems of the application to the
-   * Canvas
-   */
  class SystemAdapter
  {
    public:
--- a/simgear/canvas/CanvasWindow.cxx
+++ b/simgear/canvas/CanvasWindow.cxx
@@ -1,5 +1,4 @@
-///@file
-/// Window for placing a Canvas onto it (for dialogs, menus, etc.)
+// Window for placing a Canvas onto it (for dialogs, menus, etc.)
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -17,17 +16,18 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA

-#include <simgear_config.h>
 #include "CanvasMgr.hxx"
 #include "CanvasSystemAdapter.hxx"
 #include "CanvasWindow.hxx"

 #include <simgear/canvas/Canvas.hxx>
-#include <simgear/misc/strutils.hxx>
 #include <simgear/scene/util/OsgMath.hxx>

 #include <osgGA/GUIEventHandler>

+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/foreach.hpp>
+
 namespace simgear
 {
 namespace canvas
@@ -42,6 +42,9 @@ namespace canvas
                  const Style& parent_style,
                  Element* parent ):
    Image(canvas, node, parent_style, parent),
+    _attributes_dirty(0),
+    _resizable(false),
+    _capture_events(true),
    _resize_top(node, "resize-top"),
    _resize_right(node, "resize-right"),
    _resize_bottom(node, "resize-bottom"),
@@ -88,7 +91,7 @@ namespace canvas
        _capture_events = node->getBoolValue();
      else if( name == "decoration-border" )
        parseDecorationBorder(node->getStringValue());
-      else if(    strutils::starts_with(name, "shadow-")
+      else if(    boost::starts_with(name, "shadow-")
               || name == "content-size" )
        _attributes_dirty |= DECORATION;
      else
@@ -99,10 +102,16 @@ namespace canvas
      Image::valueChanged(node);
  }

+  //----------------------------------------------------------------------------
+  osg::Group* Window::getGroup()
+  {
+    return getMatrixTransform();
+  }
+
  //----------------------------------------------------------------------------
  const SGVec2<float> Window::getPosition() const
  {
-    auto const& m = getMatrix();
+    const osg::Matrix& m = getMatrixTransform()->getMatrix();
    return SGVec2<float>( m(3, 0), m(3, 1) );
  }

@@ -213,19 +222,6 @@ namespace canvas
      _resize_left = getRegion().l() + offset.x();
  }

-  //----------------------------------------------------------------------------
-  bool Window::handleEvent(const EventPtr& event)
-  {
-    if( auto mouse_event = dynamic_cast<MouseEvent*>(event.get()) )
-    {
-      mouse_event->local_pos =
-      mouse_event->client_pos =
-        mouse_event->screen_pos - toOsg(getPosition());
-    }
-
-    return Image::handleEvent(event);
-  }
-
  //----------------------------------------------------------------------------
  void Window::parseDecorationBorder(const std::string& str)
  {
--- a/simgear/canvas/CanvasWindow.hxx
+++ b/simgear/canvas/CanvasWindow.hxx
@@ -1,5 +1,4 @@
-///@file
-/// Window for placing a Canvas onto it (for dialogs, menus, etc.)
+// Window for placing a Canvas onto it (for dialogs, menus, etc.)
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -68,9 +67,10 @@ namespace canvas
              Element* parent = 0 );
      virtual ~Window();

-      void update(double delta_time_sec) override;
-      void valueChanged(SGPropertyNode* node) override;
+      virtual void update(double delta_time_sec);
+      virtual void valueChanged(SGPropertyNode* node);

+      osg::Group* getGroup();
      const SGVec2<float> getPosition() const;
      const SGRect<float>  getScreenRegion() const;

@@ -84,8 +84,8 @@ namespace canvas
      bool isResizable() const;
      bool isCapturingEvents() const;

-      void setVisible(bool visible) override;
-      bool isVisible() const override;
+      virtual void setVisible(bool visible);
+      virtual bool isVisible() const;

      /**
       * Moves window on top of all other windows with the same z-index.
@@ -97,8 +97,6 @@ namespace canvas
      void handleResize( uint8_t mode,
                         const osg::Vec2f& offset = osg::Vec2f() );

-      bool handleEvent(const EventPtr& event) override;
-
    protected:

      enum Attributes
@@ -106,7 +104,7 @@ namespace canvas
        DECORATION = 1
      };

-      uint32_t  _attributes_dirty {0};
+      uint32_t  _attributes_dirty;

      CanvasPtr        _canvas_decoration;
      CanvasWeakPtr    _canvas_content;
@@ -115,8 +113,8 @@ namespace canvas
      ImagePtr _image_content,
               _image_shadow;

-      bool _resizable {false},
-           _capture_events {true};
+      bool _resizable,
+           _capture_events;

      PropertyObject<int> _resize_top,
                          _resize_right,
--- a/simgear/canvas/ODGauge.cxx
+++ b/simgear/canvas/ODGauge.cxx
@@ -1,5 +1,4 @@
-///@file
-/// Owner Drawn Gauge helper class
+// Owner Drawn Gauge helper class
 //
 // Written by Harald JOHNSEN, started May 2005.
 //
@@ -7,9 +6,9 @@
 //
 // Ported to OSG by Tim Moore - Jun 2007
 //
-// Heavily modified to be usable for the 2d Canvas by Thomas Geymayer - April
-// 2012 Supports now multisampling/mipmapping, usage of the stencil buffer and
-// placing the texture in the scene by certain filter criteria.
+// Heavily modified to be usable for the 2d Canvas by Thomas Geymayer - April 2012
+// Supports now multisampling/mipmapping, usage of the stencil buffer and placing
+// the texture in the scene by certain filter criteria
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -45,6 +44,7 @@
 #include <osg/ShadeModel>
 #include <osg/StateSet>
 #include <osg/FrameBufferObject> // for GL_DEPTH_STENCIL_EXT on Windows
+#include <osg/Version>
 #include <osgUtil/RenderBin>

 #include <cassert>
@@ -201,16 +201,11 @@ namespace canvas
    updateSampling();
  }

-  //----------------------------------------------------------------------------
-  void ODGauge::setMaxAnisotropy(float anis)
-  {
-    texture->setMaxAnisotropy(anis);
-  }
-
  //----------------------------------------------------------------------------
  void ODGauge::setRender(bool render)
  {
-    camera->setNodeMask(render ? 0xffffffff : 0);
+    // Only the far camera should trigger this texture to be rendered.
+    camera->setNodeMask(render ? simgear::BACKGROUND_BIT : 0);
  }

  //----------------------------------------------------------------------------
@@ -222,7 +217,6 @@ namespace canvas
  //----------------------------------------------------------------------------
  void ODGauge::allocRT(osg::NodeCallback* camera_cull_callback)
  {
-    // REVIEW: Memory Leak - 2,712 bytes in 3 blocks are indirectly lost
    camera = new osg::Camera;
    camera->setDataVariance(osg::Object::DYNAMIC);
    camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
@@ -244,31 +238,21 @@ namespace canvas
    stateSet->setMode(GL_CULL_FACE, osg::StateAttribute::OFF);
    stateSet->setMode(GL_FOG, osg::StateAttribute::OFF);
    stateSet->setMode(GL_DEPTH_TEST, osg::StateAttribute::OFF);
-    // REVIEW: Memory Leak - 168 bytes in 3 blocks are indirectly lost
    stateSet->setAttributeAndModes(
      new osg::PolygonMode( osg::PolygonMode::FRONT_AND_BACK,
                            osg::PolygonMode::FILL ),
      osg::StateAttribute::ON );
-    // REVIEW: Memory Leak - 3,572 (8 direct, 3,564 indirect) bytes in 1 blocks are definitely lost
    stateSet->setAttributeAndModes(
      new osg::AlphaFunc(osg::AlphaFunc::GREATER, 0.001f),
      osg::StateAttribute::ON );
-    // REVIEW: Memory Leak - 384 bytes in 3 blocks are indirectly lost
    stateSet->setAttribute(new osg::ShadeModel(osg::ShadeModel::FLAT));

    if( !texture )
    {
-      // It shouldn't be necessary to allocate an image for the
-      // texture that is the target of dynamic rendering, but
-      // otherwise OSG won't construct all the mipmaps for the texture
-      // and dynamic mipmap generation doesn't work.
-      osg::Image* image = new osg::Image;
-      image->allocateImage(_size_x, _size_y, 1, GL_RGBA, GL_UNSIGNED_BYTE);
-      // REVIEW: Memory Leak - 1,176 bytes in 3 blocks are indirectly lost
      texture = new osg::Texture2D;
      texture->setResizeNonPowerOfTwoHint(false);
-      texture->setImage(image);
-      texture->setUnRefImageDataAfterApply(true);
+      texture->setTextureSize(_size_x, _size_y);
+      texture->setInternalFormat(GL_RGBA);
    }

    updateSampling();
@@ -285,7 +269,11 @@ namespace canvas
  {
    osg::NodeCallback* cull_callback =
      camera
+#if OSG_VERSION_LESS_THAN(3,3,2)
+      ? camera->getCullCallback()
+#else
      ? dynamic_cast<osg::NodeCallback*>(camera->getCullCallback())
+#endif
      : 0;

    clear();
@@ -297,8 +285,8 @@ namespace canvas
  {
    if( camera.valid() && Canvas::getSystemAdapter() )
      Canvas::getSystemAdapter()->removeCamera(camera.get());
-    camera = nullptr;
-    texture = nullptr;
+    camera.release();
+    texture.release();

    _flags &= ~AVAILABLE;
  }
@@ -345,7 +333,6 @@ namespace canvas

    if( _flags & USE_STENCIL )
    {
-      // REVIEW: Memory Leak - 264 bytes in 3 blocks are indirectly lost
      camera->attach( osg::Camera::PACKED_DEPTH_STENCIL_BUFFER,
                       GL_DEPTH_STENCIL_EXT );
      mask |= GL_STENCIL_BUFFER_BIT;
@@ -384,7 +371,6 @@ namespace canvas
  {
    assert( camera );

-    // REVIEW: Memory Leak - 3,572 (136 direct, 3,436 indirect) bytes in 1 blocks are definitely lost
    camera->getOrCreateStateSet()
      ->setAttributeAndModes
      (
--- a/simgear/canvas/ODGauge.hxx
+++ b/simgear/canvas/ODGauge.hxx
@@ -1,5 +1,4 @@
-///@file
-/// Owner Drawn Gauge helper class
+// Owner Drawn Gauge helper class
 //
 // Written by Harald JOHNSEN, started May 2005.
 //
@@ -7,9 +6,9 @@
 //
 // Ported to OSG by Tim Moore - Jun 2007
 //
-// Heavily modified to be usable for the 2d Canvas by Thomas Geymayer - April
-// 2012 Supports now multisampling/mipmapping, usage of the stencil buffer and
-// placing the texture in the scene by certain filter criteria.
+// Heavily modified to be usable for the 2d Canvas by Thomas Geymayer - April 2012
+// Supports now multisampling/mipmapping, usage of the stencil buffer and placing
+// the texture in the scene by certain filter criteria
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -109,8 +108,6 @@ namespace canvas
                        int coverage_samples = 0,
                        int color_samples = 0 );

-      void setMaxAnisotropy(float anis);
-
      /**
       * Enable/Disable updating the texture (If disabled the contents of the
       * texture remains with the outcome of the last rendering pass)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Automatic Release Builder	e084bd89e7	new version: 2017.1.2	2017-03-01 20:40:03 +01:00
James Turner	cfe9ddc2de	Fix issues with package upgrades on Windows.	2017-02-23 13:27:02 +00:00