build: Bump version to v1.35.4

Fixes #1799

.github/workflows/build.yml

@@ -76,7 +76,7 @@ jobs:
           -DIMHEX_REPLACE_DWARF_WITH_PDB=ON                         \
           -DDOTNET_EXECUTABLE="C:/Program Files/dotnet/dotnet.exe"  \
           ..
-    
+
     - name: 🛠️ Build
       run: |
         cd build
@@ -107,7 +107,7 @@ jobs:
       run: |
         set -x
         echo "NoGPU version Powered by Mesa 3D : https://fdossena.com/?p=mesa%2Findex.frag" > build/install/MESA.md
-        curl https://werwolv.net/downloads/mesa/MesaForWindows-x64-latest.7z -L -o mesa.7z
+        curl https://downloads.fdossena.com/geth.php?r=mesa64-latest -L -o mesa.7z
         7z e mesa.7z
         mv opengl32.dll build/install
 
@@ -153,15 +153,14 @@ jobs:
 
     - name: ⬇️ Install dependencies
       run: |
-        set -x
-        brew reinstall python || brew link --overwrite python
+        brew reinstall python || brew link --overwrite python || true
         brew bundle --no-lock --file dist/Brewfile
         rm -rf /usr/local/Cellar/capstone
 
     - name: ⬇️ Install classic glfw
       if: ${{! matrix.custom_glfw}}
       run: |
-        brew install glfw
+        brew install glfw || true
 
     - name: ⬇️ Install .NET
       uses: actions/setup-dotnet@v4
@@ -174,7 +173,7 @@ jobs:
       with:
         repository: glfw/glfw
         path: glfw
-    
+
     # GLFW custom build (to allow software rendering)
     - name: ⬇️ Patch and install custom glfw
       if: ${{matrix.custom_glfw}}
@@ -219,7 +218,7 @@ jobs:
           -DIMHEX_COMMIT_HASH_LONG="${GITHUB_SHA}"                                                  \
           -DIMHEX_COMMIT_BRANCH="${GITHUB_REF##*/}"                                                 \
           ..
-      
+
     - name: 🛠️ Build
       run: cd build && ninja install
 
@@ -264,7 +263,7 @@ jobs:
       uses: actions/checkout@v4
       with:
         submodules: recursive
-    
+
     - name: 📁 Restore docker /cache
       uses: actions/cache@v4
       with:
@@ -346,7 +345,7 @@ jobs:
           if-no-files-found: error
           name: macOS DMG arm64
           path: ./*.dmg
-  
+
   # Ubuntu build
   ubuntu:
     strategy:
@@ -354,7 +353,7 @@ jobs:
       matrix:
         include:
           - release_num: 22.04
-          - release_num: 23.04
+          - release_num: 24.04
 
     name: 🐧 Ubuntu ${{ matrix.release_num }}
     runs-on: ubuntu-latest
@@ -384,11 +383,6 @@ jobs:
           apt update
           bash dist/get_deps_debian.sh
 
-          apt install software-properties-common -y
-          add-apt-repository ppa:ubuntu-toolchain-r/test -y
-          apt update
-          apt install -y gcc-13 g++-13
-
       - name: ⬇️ Install .NET
         uses: actions/setup-dotnet@v4
         with:
@@ -402,7 +396,7 @@ jobs:
           git config --global --add safe.directory '*'
           mkdir -p build
           cd build
-          CC=gcc-13 CXX=g++-13 cmake -G "Ninja"                       \
+          CC=gcc-12 CXX=g++-12 cmake -G "Ninja"                       \
             -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}                    \
             -DCMAKE_INSTALL_PREFIX="/usr"                             \
             -DCMAKE_C_COMPILER_LAUNCHER=ccache                        \
@@ -414,9 +408,9 @@ jobs:
             -DIMHEX_USE_GTK_FILE_PICKER=ON                            \
             -DDOTNET_EXECUTABLE="dotnet"                              \
             ..
-      
+
       - name: 🛠️ Build
-        run: cd build && DESTDIR=DebDir ninja install 
+        run: cd build && DESTDIR=DebDir ninja install
 
       - name: 📜 Set version variable
         run: |
@@ -451,7 +445,7 @@ jobs:
           path: cache
           key: appimage-ccache-${{ github.run_id }}
           restore-keys: appimage-cache
-      
+
       - name: 🐳 Inject /cache into docker
         uses: reproducible-containers/buildkit-cache-dance@v2
         with:
@@ -537,9 +531,9 @@ jobs:
           -DIMHEX_ENABLE_LTO=ON                         \
           -DIMHEX_USE_GTK_FILE_PICKER=ON                \
           ..
-      
+
       - name: 🛠️ Build
-        run: cd build && DESTDIR=installDir ninja install 
+        run: cd build && DESTDIR=installDir ninja install
 
       - name: 📜 Set version variable
         run: |
@@ -587,14 +581,14 @@ jobs:
             mock_release: rawhide
             release_num: rawhide
             mock_config: fedora-rawhide
+          - name: Fedora
+            mock_release: f40
+            release_num: 40
+            mock_config: fedora-40
           - name: Fedora
             mock_release: f39
             release_num: 39
             mock_config: fedora-39
-          - name: Fedora
-            mock_release: f38
-            release_num: 38
-            mock_config: fedora-38
           - name: RHEL-AlmaLinux
             mock_release: epel9
             release_num: 9

.github/workflows/tests.yml

@@ -48,6 +48,7 @@ jobs:
         CC=gcc-12 CXX=g++-12 cmake                                                                                 \
           -DCMAKE_BUILD_TYPE=Debug                                                                                 \
           -DIMHEX_ENABLE_UNIT_TESTS=ON                                                                             \
+          -DIMHEX_ENABLE_PLUGIN_TESTS=ON                                                                           \
           -DCMAKE_C_COMPILER_LAUNCHER=ccache                                                                       \
           -DCMAKE_CXX_COMPILER_LAUNCHER=ccache                                                                     \
           -DCMAKE_C_FLAGS="-fuse-ld=lld -fsanitize=address,leak,undefined -fno-sanitize-recover=all --coverage"    \

CMakeLists.txt

@@ -21,7 +21,7 @@ option(IMHEX_REPLACE_DWARF_WITH_PDB     "Remove DWARF information from binaries
 option(IMHEX_ENABLE_STD_ASSERTS         "Enable debug asserts in the C++ std library. (Breaks Plugin ABI!)"                     OFF)
 option(IMHEX_ENABLE_UNIT_TESTS          "Enable building unit tests"                                                            OFF)
 option(IMHEX_ENABLE_PRECOMPILED_HEADERS "Enable precompiled headers"                                                            OFF)
-option(IMHEX_COMPRESS_DEBUG_INFO "Compress debug information"                                                                   ON )
+option(IMHEX_COMPRESS_DEBUG_INFO        "Compress debug information"                                                            ON )
 
 set(IMHEX_BASE_FOLDER "${CMAKE_CURRENT_SOURCE_DIR}")
 set(CMAKE_MODULE_PATH "${IMHEX_BASE_FOLDER}/cmake/modules")
@@ -35,13 +35,13 @@ set(CMAKE_INCLUDE_DIRECTORIES_BEFORE ON)
 include("${IMHEX_BASE_FOLDER}/cmake/build_helpers.cmake")
 
 # Setup project
-loadVersion(IMHEX_VERSION)
+loadVersion(IMHEX_VERSION IMHEX_VERSION_PLAIN)
 setVariableInParent(IMHEX_VERSION ${IMHEX_VERSION})
 configureCMake()
 
 project(imhex
         LANGUAGES       C CXX
-        VERSION         ${IMHEX_VERSION}
+        VERSION         ${IMHEX_VERSION_PLAIN}
         DESCRIPTION     "The ImHex Hex Editor"
         HOMEPAGE_URL    "https://imhex.werwolv.net"
 )
@@ -69,7 +69,6 @@ addBundledLibraries()
 add_subdirectory(lib/libimhex)
 add_subdirectory(main)
 addPluginDirectories()
-add_subdirectory(lib/trace)
 
 # Add unit tests
 if (IMHEX_ENABLE_UNIT_TESTS)

README.md

@@ -1,13 +1,16 @@
 <a href="https://imhex.werwolv.net">
   <h1 align="center">
     <picture>
-      <img height="300px" src="./resources/dist/common/logo/ImHexLogoSVGBG.svg">
+      <img height="300px" style="margin: 0; padding: 0" src="./resources/dist/common/logo/ImHexLogoSVGBG.svg">
     </picture>
   </h1>
 </a>
 
-<p align="center">A Hex Editor for Reverse Engineers, Programmers and people who value their retinas when working at 3 AM.</p>
-
+<p align="center">
+    A Hex Editor for Reverse Engineers, Programmers and people who value their retinas when working at 3 AM.
+    <br>
+    <a href="https://itinerarium.github.io/phoneme-synthesis/?w=/'ˈɪmhɛks/"><strong>/ˈɪmhɛks/</strong></a>
+</p>
 <p align="center">
   <a title="'Build' workflow Status" href="https://github.com/WerWolv/ImHex/actions?query=workflow%3ABuild"><img alt="'Build' workflow Status" src="https://img.shields.io/github/actions/workflow/status/WerWolv/ImHex/build.yml?longCache=true&style=for-the-badge&label=Build&logoColor=fff&logo=GitHub%20Actions&branch=master"></a>
   <a title="Discord Server" href="https://discord.gg/X63jZ36xBY"><img alt="Discord Server" src="https://img.shields.io/discord/789833418631675954?label=Discord&logo=Discord&logoColor=fff&style=for-the-badge"></a>
@@ -315,7 +318,8 @@ To use ImHex, the following minimal system requirements need to be met.
 
 - **OS**: 
   - **Windows**: Windows 7 or higher (Windows 10/11 recommended)
-  - **macOS**: macOS 11 (Big Sur) or higher, 
+  - **macOS**: macOS 12.1 (Monterey) or higher, 
+    - Lower versions are supported, but you'll need to compile ImHex yourself
   - **Linux**: "Modern" Linux. The following distributions have official releases available. Other distros are supported through the AppImage and Flatpak releases.
     - Ubuntu 22.04/23.04
     - Fedora 36/37

VERSION

@@ -1 +1 @@
-1.33.0
+1.35.4

cmake/build_helpers.cmake

@@ -59,6 +59,7 @@ macro(detectOS)
         set(CMAKE_INSTALL_LIBDIR ".")
         set(PLUGINS_INSTALL_LOCATION "plugins")
         add_compile_definitions(WIN32_LEAN_AND_MEAN)
+        add_compile_definitions(UNICODE)
     elseif (APPLE)
         add_compile_definitions(OS_MACOS)
         set(CMAKE_INSTALL_BINDIR ".")
@@ -268,7 +269,7 @@ macro(createPackage)
                 find_program(CODESIGN_PATH codesign)
                 if (CODESIGN_PATH)
                     install(CODE "message(STATUS \"Signing bundle '${CMAKE_INSTALL_PREFIX}/${BUNDLE_NAME}'...\")")
-                    install(CODE "execute_process(COMMAND ${CODESIGN_PATH} --force --deep --sign - ${CMAKE_INSTALL_PREFIX}/${BUNDLE_NAME} COMMAND_ERROR_IS_FATAL ANY)")
+                    install(CODE "execute_process(COMMAND ${CODESIGN_PATH} --force --deep --entitlements ${CMAKE_SOURCE_DIR}/resources/macos/Entitlements.plist --sign - ${CMAKE_INSTALL_PREFIX}/${BUNDLE_NAME} COMMAND_ERROR_IS_FATAL ANY)")
                 endif()
             endif()
 
@@ -397,12 +398,14 @@ macro(setDefaultBuiltTypeIfUnset)
     endif()
 endmacro()
 
-function(loadVersion version)
+function(loadVersion version plain_version)
     set(VERSION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/VERSION")
     set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${VERSION_FILE})
     file(READ "${VERSION_FILE}" read_version)
     string(STRIP ${read_version} read_version)
+    string(REPLACE ".WIP" "" read_version_plain ${read_version})
     set(${version} ${read_version} PARENT_SCOPE)
+    set(${plain_version} ${read_version_plain} PARENT_SCOPE)
 endfunction()
 
 function(detectBadClone)
@@ -543,8 +546,10 @@ macro(setupDebugCompressionFlag)
 
     if (NOT DEBUG_COMPRESSION_FLAG) # Cache variable
         if (ZSTD_AVAILABLE_COMPILER AND ZSTD_AVAILABLE_LINKER)
+            message("Using Zstd compression for debug info because both compiler and linker support it")
             set(DEBUG_COMPRESSION_FLAG "-gz=zstd" CACHE STRING "Cache to use for debug info compression")
         elseif (COMPRESS_AVAILABLE_COMPILER AND COMPRESS_AVAILABLE_LINKER)
+            message("Using default compression for debug info because both compiler and linker support it")
             set(DEBUG_COMPRESSION_FLAG "-gz" CACHE STRING "Cache to use for debug info compression")
         endif()
     endif()
@@ -696,6 +701,14 @@ macro(addBundledLibraries)
         set(JTHREAD_LIBRARIES jthread)
     endif()
 
+    if (USE_SYSTEM_BOOST)
+        find_package(boost REQUIRED)
+        set(BOOST_LIBRARIES boost::regex)
+    else()
+        add_subdirectory(${THIRD_PARTY_LIBS_FOLDER}/boost ${CMAKE_CURRENT_BINARY_DIR}/boost EXCLUDE_FROM_ALL)
+        set(BOOST_LIBRARIES boost::regex)
+    endif()
+
     set(LIBPL_BUILD_CLI_AS_EXECUTABLE OFF CACHE BOOL "" FORCE)
     set(LIBPL_ENABLE_PRECOMPILED_HEADERS ${IMHEX_ENABLE_PRECOMPILED_HEADERS} CACHE BOOL "" FORCE)
 
@@ -730,6 +743,30 @@ macro(addBundledLibraries)
 
     find_package(mbedTLS 3.4.0 REQUIRED)
     find_package(Magic 5.39 REQUIRED)
+
+    if (NOT IMHEX_DISABLE_STACKTRACE)
+        if (WIN32)
+            message(STATUS "StackWalk enabled!")
+            set(LIBBACKTRACE_LIBRARIES DbgHelp.lib)
+        else ()
+            find_package(Backtrace)
+            if (${Backtrace_FOUND})
+                message(STATUS "Backtrace enabled! Header: ${Backtrace_HEADER}")
+
+                if (Backtrace_HEADER STREQUAL "backtrace.h")
+                    set(LIBBACKTRACE_LIBRARIES ${Backtrace_LIBRARY})
+                    set(LIBBACKTRACE_INCLUDE_DIRS ${Backtrace_INCLUDE_DIR})
+                    add_compile_definitions(BACKTRACE_HEADER=<${Backtrace_HEADER}>)
+                    add_compile_definitions(HEX_HAS_BACKTRACE)
+                elseif (Backtrace_HEADER STREQUAL "execinfo.h")
+                    set(LIBBACKTRACE_LIBRARIES ${Backtrace_LIBRARY})
+                    set(LIBBACKTRACE_INCLUDE_DIRS ${Backtrace_INCLUDE_DIR})
+                    add_compile_definitions(BACKTRACE_HEADER=<${Backtrace_HEADER}>)
+                    add_compile_definitions(HEX_HAS_EXECINFO)
+                endif()
+            endif()
+        endif()
+    endif()
 endmacro()
 
 function(enableUnityBuild TARGET)
@@ -811,6 +848,9 @@ function(generateSDKDirectory)
     if (NOT USE_SYSTEM_NLOHMANN_JSON)
         install(DIRECTORY ${CMAKE_SOURCE_DIR}/lib/third_party/nlohmann_json DESTINATION "${SDK_PATH}/lib/third_party")
     endif()
+        if (NOT USE_SYSTEM_NLOHMANN_JSON)
+        install(DIRECTORY ${CMAKE_SOURCE_DIR}/lib/third_party/boost DESTINATION "${SDK_PATH}/lib/third_party")
+    endif()
 
     install(DIRECTORY ${CMAKE_SOURCE_DIR}/cmake/modules DESTINATION "${SDK_PATH}/cmake")
     install(FILES ${CMAKE_SOURCE_DIR}/cmake/build_helpers.cmake DESTINATION "${SDK_PATH}/cmake")

cmake/modules/FindCoreClrEmbed.cmake

@@ -89,4 +89,5 @@ if (CoreClrEmbed_INCLUDE_DIR AND CoreClrEmbed_LIBRARY)
     set(CoreClrEmbed_LIBRARIES "${CoreClrEmbed_LIBRARY}" CACHE STRING "CoreClrEmbed libraries" FORCE)
     set(CoreClrEmbed_SHARED_LIBRARIES "${CoreClrEmbed_SHARED_LIBRARY}" CACHE STRING "CoreClrEmbed shared libraries" FORCE)
     set(CoreClrEmbed_INCLUDE_DIRS "${CoreClrEmbed_INCLUDE_DIR}" CACHE STRING "CoreClrEmbed include directories" FORCE)
+    set(CoreClrEmbed_VERSION "${CORECLR_RUNTIME_VERSION_FULL}" CACHE STRING "CoreClrEmbed version" FORCE)
 endif()

cmake/modules/FindZSTD.cmake

@@ -38,4 +38,8 @@ if (ZSTD_FOUND)
     message(STATUS "Found Zstd: ${ZSTD_LIBRARY}")
 endif()
 
-mark_as_advanced(ZSTD_INCLUDE_DIR ZSTD_LIBRARY)
+mark_as_advanced(ZSTD_INCLUDE_DIR ZSTD_LIBRARY)
+
+add_library(ZSTD::zstd INTERFACE IMPORTED)
+set_property(TARGET ZSTD::zstd PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${ZSTD_INCLUDE_DIR})
+set_property(TARGET ZSTD::zstd PROPERTY INTERFACE_LINK_LIBRARIES ${ZSTD_LIBRARY})

cmake/modules/ImHexPlugin.cmake

@@ -37,7 +37,7 @@ macro(add_imhex_plugin)
     # Add include directories and link libraries
     target_include_directories(${IMHEX_PLUGIN_NAME} PUBLIC ${IMHEX_PLUGIN_INCLUDES})
     target_link_libraries(${IMHEX_PLUGIN_NAME} PUBLIC ${IMHEX_PLUGIN_LIBRARIES})
-    target_link_libraries(${IMHEX_PLUGIN_NAME} PRIVATE libimhex ${FMT_LIBRARIES} imgui_all_includes libwolv tracing)
+    target_link_libraries(${IMHEX_PLUGIN_NAME} PRIVATE libimhex ${FMT_LIBRARIES} imgui_all_includes libwolv)
     addIncludesFromLibrary(${IMHEX_PLUGIN_NAME} libpl)
     addIncludesFromLibrary(${IMHEX_PLUGIN_NAME} libpl-gen)
 
@@ -72,10 +72,23 @@ macro(add_imhex_plugin)
     add_subdirectory(${IMHEX_BASE_FOLDER}/lib/external/libromfs ${CMAKE_CURRENT_BINARY_DIR}/libromfs)
     target_link_libraries(${IMHEX_PLUGIN_NAME} PRIVATE ${LIBROMFS_LIBRARY})
 
-    foreach(feature ${IMHEX_PLUGIN_FEATURES})
-        string(TOUPPER ${feature} feature)
-        add_definitions(-DIMHEX_PLUGIN_${IMHEX_PLUGIN_NAME}_FEATURE_${feature}=0)
-    endforeach()
+    set(FEATURE_DEFINE_CONTENT)
+
+    if (IMHEX_PLUGIN_FEATURES)
+        list(LENGTH IMHEX_PLUGIN_FEATURES IMHEX_FEATURE_COUNT)
+        math(EXPR IMHEX_FEATURE_COUNT "${IMHEX_FEATURE_COUNT} - 1" OUTPUT_FORMAT DECIMAL)
+        foreach(index RANGE 0 ${IMHEX_FEATURE_COUNT} 2)
+            list(SUBLIST IMHEX_PLUGIN_FEATURES ${index} 2 IMHEX_PLUGIN_FEATURE)
+            list(GET IMHEX_PLUGIN_FEATURE 0 feature_define)
+            list(GET IMHEX_PLUGIN_FEATURE 1 feature_description)
+
+            string(TOUPPER ${feature_define} feature_define)
+            add_definitions(-DIMHEX_PLUGIN_${IMHEX_PLUGIN_NAME}_FEATURE_${feature_define}=0)
+            set(FEATURE_DEFINE_CONTENT "${FEATURE_DEFINE_CONTENT}{ \"${feature_description}\", IMHEX_FEATURE_ENABLED(${feature_define}) },")
+        endforeach()
+    endif()
+
+    target_compile_options(${IMHEX_PLUGIN_NAME} PRIVATE -DIMHEX_PLUGIN_FEATURES_CONTENT=${FEATURE_DEFINE_CONTENT})
 
     # Add the new plugin to the main dependency list so it gets built by default
     if (TARGET imhex_all)
@@ -88,12 +101,28 @@ macro(add_imhex_plugin)
 
     # Fix rpath
     if (APPLE)
-        set_target_properties(${IMHEX_PLUGIN_NAME} PROPERTIES INSTALL_RPATH "@executable_path/../Frameworks;@executable_path/plugins")
+        set_target_properties(
+                ${IMHEX_PLUGIN_NAME}
+                PROPERTIES
+                    INSTALL_RPATH "@executable_path/../Frameworks;@executable_path/plugins"
+        )
     elseif (UNIX)
-        set_target_properties(${IMHEX_PLUGIN_NAME} PROPERTIES INSTALL_RPATH_USE_ORIGIN ON INSTALL_RPATH "$ORIGIN/")
+        set(PLUGIN_RPATH "")
+        list(APPEND PLUGIN_RPATH "$ORIGIN")
+
+        if (IMHEX_PLUGIN_ADD_INSTALL_PREFIX_TO_RPATH)
+            list(APPEND PLUGIN_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+        endif()
+
+        set_target_properties(
+                ${IMHEX_PLUGIN_NAME}
+                PROPERTIES
+                    INSTALL_RPATH_USE_ORIGIN ON
+                    INSTALL_RPATH "${PLUGIN_RPATH}"
+        )
     endif()
 
-    if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt AND IMHEX_ENABLE_UNIT_TESTS)
+    if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt AND IMHEX_ENABLE_UNIT_TESTS AND IMHEX_ENABLE_PLUGIN_TESTS)
         add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tests)
         target_link_libraries(${IMHEX_PLUGIN_NAME} PUBLIC ${IMHEX_PLUGIN_NAME}_tests)
         target_compile_definitions(${IMHEX_PLUGIN_NAME}_tests PRIVATE IMHEX_PROJECT_NAME="${IMHEX_PLUGIN_NAME}-tests")
@@ -101,6 +130,10 @@ macro(add_imhex_plugin)
 endmacro()
 
 macro(add_romfs_resource input output)
+    if (NOT EXISTS ${input})
+        message(WARNING "Resource file ${input} does not exist")
+    endif()
+
     configure_file(${input} ${CMAKE_CURRENT_BINARY_DIR}/romfs/${output} COPYONLY)
 
     list(APPEND LIBROMFS_RESOURCE_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/romfs)

cmake/sdk/CMakeLists.txt

@@ -29,6 +29,10 @@ add_subdirectory_if_exists(lib/third_party/nlohmann_json)
 set(NLOHMANN_JSON_LIBRARIES nlohmann_json PARENT_SCOPE)
 set(NLOHMANN_JSON_LIBRARIES nlohmann_json)
 
+add_subdirectory_if_exists(lib/third_party/boost)
+set(BOOST_LIBRARIES boost::regex PARENT_SCOPE)
+set(BOOST_LIBRARIES boost::regex)
+
 add_subdirectory(lib/external/libwolv EXCLUDE_FROM_ALL)
 
 set(LIBPL_ENABLE_CLI OFF CACHE BOOL "" FORCE)
@@ -44,7 +48,7 @@ add_subdirectory(lib/libimhex)
 if (WIN32)
     set_target_properties(libimhex PROPERTIES
             IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/../libimhex.dll"
-            IMPORTED_IMPLIB "${CMAKE_CURRENT_SOURCE_DIR}/lib/libimhex.dll.a"
+            IMPORTED_IMPLIB "${CMAKE_CURRENT_SOURCE_DIR}/lib/liblibimhex.dll.a"
             INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/lib/libimhex/include")
 elseif (APPLE)
     file(GLOB LIBIMHEX_DYLIB "${CMAKE_CURRENT_SOURCE_DIR}/../../Frameworks/libimhex.*.dylib")

dist/gen_release_notes.py

@@ -0,0 +1,48 @@
+import subprocess
+import sys
+
+def get_commits(branch: str, start_tag: str, end_tag: str) -> list[str]:
+    try:
+        commits_raw = subprocess.check_output([ "git", "--no-pager", "log", branch, "--no-color", "--pretty=oneline", "--abbrev-commit", f"{start_tag}..{end_tag}"], stderr=subprocess.DEVNULL).decode("UTF-8").split("\n")
+    except:
+        return []
+
+    commits = []
+    for line in commits_raw:
+        commits.append(line[9:])
+
+    return commits
+
+def main(args: list) -> int:
+    if len(args) != 2:
+        print(f"Usage: {args[0]} prev_minor")
+        return 1
+    
+    last_minor_version = f"v1.{args[1]}"
+
+    master_commits = get_commits("master", f"{last_minor_version}.0", "master")
+
+    for i in range(1, 100):
+        branch_commits = get_commits(f"releases/{last_minor_version}.X", f"{last_minor_version}.0", f"{last_minor_version}.{i}")
+
+        if len(branch_commits) == 0:
+            break
+
+        master_commits = [commit for commit in master_commits if commit not in branch_commits]
+
+    sorted_commits = {}
+    for commit in master_commits:
+        category, commit_name = commit.split(":", 1)
+
+        if category not in sorted_commits:
+            sorted_commits[category] = []
+        sorted_commits[category].append(commit_name)
+
+    for category in sorted_commits:
+        print(f"## {category}\n")
+        for commit in sorted_commits[category]:
+            print(f"- {commit}")
+        print(f"\n")
+
+if __name__ == "__main__":
+    exit(main(sys.argv))

dist/imhex.desktop

@@ -8,3 +8,4 @@ Type=Application
 StartupNotify=true
 Categories=Development;IDE;
 StartupWMClass=imhex
+Keywords=static-analysis;reverse-engineering;disassembler;disassembly;hacking;forensics;hex-editor;cybersecurity;security;binary-analysis;

dist/rpm/imhex.spec

@@ -1,3 +1,5 @@
+%define source_date_epoch_from_changelog 0
+
 Name:           imhex
 Version:        VERSION
 Release:        0%{?dist}
@@ -124,7 +126,4 @@ cp -a lib/third_party/xdgpp/LICENSE                                  %{buildroot
 %{_datadir}/applications/%{name}.desktop
 %{_libdir}/libimhex.so*
 %{_libdir}/%{name}/
-%{_metainfodir}/net.werwolv.%{name}.metainfo.xml
-
-
-%changelog
+%{_metainfodir}/net.werwolv.%{name}.metainfo.xml

dist/web/source/index.html

@@ -62,7 +62,7 @@
 </head>
 <body>
 <div id="loading" class="centered">
-    <img src="https://raw.githubusercontent.com/WerWolv/ImHex/master/plugins/builtin/romfs/assets/dark/banner.png" id="logo" alt="ImHex Logo">
+    <img src="https://raw.githubusercontent.com/WerWolv/ImHex/master/plugins/builtin/romfs/assets/dark/banner.svg" id="logo" alt="ImHex Logo">
     <h1>A Hex Editor for Reverse Engineers, Programmers and people who value their retinas when working at 3 AM.</h1>
     <h2>Available both natively and on the web</h2>
     <h5>ImHex runs directly in your web browser with the help of Emscripten and WebAssembly.</h5>

dist/web/source/style.css

@@ -137,7 +137,7 @@ a:hover {
 
 
 :root {
-    --progress: 25%;
+    --progress: 0%;
 }
 
 .progress-bar-container {
@@ -174,4 +174,15 @@ a:hover {
 .progress-moved .progress-bar {
     width: var(--progress);
     background-color: #3864cb;
+}
+
+#logo {
+    height: 25%;
+    margin-top: 50px;
+}
+
+.canvas-fixed {
+    position: absolute;
+    top: 0;
+    left: 0;
 }

dist/web/source/wasm-config.js

@@ -100,7 +100,77 @@ var notWorkingTimer = setTimeout(() => {
 
 var Module = {
     preRun:  [],
-    postRun: [],
+    postRun: function() {
+        // Patch the emscripten GLFW module to send mouse and touch events in the right order
+        // For ImGui interactions to correctly work with touch input, MousePos events need
+        // to be processed first and then MouseButton events in the next frame. By default,
+        // GLFW does the exact opposite, which causes buttons to require two taps to register
+        // and windows get "stuck" to the cursor when dragged or resized
+        GLFW.onMousemove = event => {
+            if (event.type === "touchmove") {
+                event.preventDefault();
+                let primaryChanged = false;
+                for (let i of event.changedTouches) {
+                    if (GLFW.primaryTouchId === i.identifier) {
+                        Browser.setMouseCoords(i.pageX, i.pageY);
+                        primaryChanged = true;
+                        break;
+                    }
+                }
+                if (!primaryChanged) {
+                    return;
+                }
+            } else {
+                Browser.calculateMouseEvent(event);
+            }
+        };
+
+        GLFW.onMouseButtonChanged = (event, status) => {
+            if (!GLFW.active) return;
+            if (event.target != Module["canvas"]) return;
+            const isTouchType = event.type === "touchstart" || event.type === "touchend" || event.type === "touchcancel";
+            let eventButton = 0;
+            if (isTouchType) {
+                event.preventDefault();
+                let primaryChanged = false;
+                if (GLFW.primaryTouchId === null && event.type === "touchstart" && event.targetTouches.length > 0) {
+                    const chosenTouch = event.targetTouches[0];
+                    GLFW.primaryTouchId = chosenTouch.identifier;
+                    Browser.setMouseCoords(chosenTouch.pageX, chosenTouch.pageY);
+                    primaryChanged = true;
+                } else if (event.type === "touchend" || event.type === "touchcancel") {
+                    for (let i of event.changedTouches) {
+                        if (GLFW.primaryTouchId === i.identifier) {
+                            GLFW.primaryTouchId = null;
+                            primaryChanged = true;
+                            break;
+                        }
+                    }
+                }
+                if (!primaryChanged) {
+                    return;
+                }
+            } else {
+                Browser.calculateMouseEvent(event);
+                eventButton = GLFW.DOMToGLFWMouseButton(event);
+            }
+            if (status == 1) {
+                GLFW.active.buttons |= (1 << eventButton);
+                try {
+                    event.target.setCapture();
+                } catch (e) {}
+            } else {
+                GLFW.active.buttons &= ~(1 << eventButton);
+            }
+
+            if (GLFW.active.cursorPosFunc) {
+                getWasmTableEntry(GLFW.active.cursorPosFunc)(GLFW.active.id, Browser.mouseX, Browser.mouseY);
+            }
+            if (GLFW.active.mouseButtonFunc) {
+                getWasmTableEntry(GLFW.active.mouseButtonFunc)(GLFW.active.id, eventButton, status, GLFW.getModBits(GLFW.active));
+            }
+        };
+    },
     onRuntimeInitialized: function() {
         // Triggered when the wasm module is loaded and ready to use.
         document.getElementById("loading").style.display = "none"
@@ -111,13 +181,55 @@ var Module = {
     print:   (function() { })(),
     printErr: function(text) {  },
     canvas: (function() {
-        let canvas = document.getElementById('canvas');
-        // As a default initial behavior, pop up an alert when webgl context is lost. To make your
-        // application robust, you may want to override this behavior before shipping!
-        // See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2
-        canvas.addEventListener("webglcontextlost", function(e) { alert('WebGL context lost. You will need to reload the page.'); e.preventDefault(); }, false);
+        const canvas = document.getElementById('canvas');
+        canvas.addEventListener("webglcontextlost", function(e) {
+            alert('WebGL context lost, please reload the page');
+            e.preventDefault();
+        }, false);
 
-        return canvas;
+        // Turn long touches into right-clicks
+        let timer = null;
+        canvas.addEventListener('touchstart', event => {
+            timer = setTimeout(() => {
+                let eventArgs = {
+                    bubbles: true,
+                    cancelable: true,
+                    view: window,
+                    screenX: event.touches[0].screenX,
+                    screenY: event.touches[0].screenY,
+                    clientX: event.touches[0].clientX,
+                    clientY: event.touches[0].clientY,
+                    button: 2,
+                    buttons: 2,
+                    relatedTarget: event.target,
+                    region: event.region
+                }
+
+                canvas.dispatchEvent(new MouseEvent('mousedown', eventArgs));
+                canvas.dispatchEvent(new MouseEvent('mouseup', eventArgs));
+            }, 400);
+        });
+
+        canvas.addEventListener('touchend', event => {
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+        });
+
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+            let gl = canvas.getContext('webgl2', { stencil: true });
+            if (!gl) {
+                console.error('WebGL 2 not available, falling back to WebGL');
+                gl = canvas.getContext('webgl', { stencil: true });
+            }
+            if (!gl) {
+                alert('WebGL not available with stencil buffer');
+            }
+            return canvas;
+        } else {
+            alert('WebGL 2 not supported by this browser');
+        }
     })(),
     setStatus: function(text) { },
     totalDependencies: 0,
@@ -144,14 +256,9 @@ if (urlParams.has("lang")) {
 window.addEventListener('resize', js_resizeCanvas, false);
 function js_resizeCanvas() {
     let canvas = document.getElementById('canvas');
+
+    canvas.top    = document.documentElement.clientTop;
+    canvas.left   = document.documentElement.clientLeft;
     canvas.width  = Math.min(document.documentElement.clientWidth, window.innerWidth || 0);
     canvas.height = Math.min(document.documentElement.clientHeight, window.innerHeight || 0);
-
-    canvas.classList.add("canvas_full_screen")
-
-    if (GLFW.active && GLFW.active.windowPosFunc) {
-        getWasmTableEntry(GLFW.active.windowPosFunc)(GLFW.active.id, GLFW.active.x, GLFW.active.y);
-    }
-
-    GLFW.onWindowSizeChanged();
 }

lib/libimhex/CMakeLists.txt

@@ -36,6 +36,8 @@ set(LIBIMHEX_SOURCES
         source/helpers/logger.cpp
         source/helpers/tar.cpp
         source/helpers/debugging.cpp
+        source/helpers/default_paths.cpp
+        source/helpers/imgui_hooks.cpp
 
         source/test/tests.cpp
 
@@ -123,7 +125,7 @@ target_link_directories(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${MBEDTLS_LIBRARY_DIR}
 
 if (NOT EMSCRIPTEN)
     # curl is only used in non-emscripten builds
-    target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${CURL_LIBRARIES})
+    target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} CURL::libcurl)
 endif()
 
 
@@ -142,7 +144,7 @@ if (NOT IMHEX_EXTERNAL_PLUGIN_BUILD)
     precompileHeaders(libimhex "${CMAKE_CURRENT_SOURCE_DIR}/include")
 endif()
 
-target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${NLOHMANN_JSON_LIBRARIES} imgui_all_includes ${MBEDTLS_LIBRARIES} ${FMT_LIBRARIES} ${LUNASVG_LIBRARIES} tracing)
+target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${NLOHMANN_JSON_LIBRARIES} imgui_all_includes ${MBEDTLS_LIBRARIES} ${FMT_LIBRARIES} ${LUNASVG_LIBRARIES} ${BOOST_LIBRARIES})
 
 set_property(TARGET libimhex PROPERTY INTERPROCEDURAL_OPTIMIZATION FALSE)
 

lib/libimhex/include/hex/api/content_registry.hpp

@@ -774,6 +774,7 @@ namespace hex {
                 const std::multimap<u32, MainMenuItem>& getMainMenuItems();
 
                 const std::multimap<u32, MenuItem>& getMenuItems();
+                const std::vector<MenuItem*>& getToolbarMenuItems();
                 std::multimap<u32, MenuItem>& getMenuItemsMutable();
 
                 const std::vector<DrawCallback>& getWelcomeScreenEntries();
@@ -916,6 +917,11 @@ namespace hex {
              */
             void addMenuItemToToolbar(const UnlocalizedString &unlocalizedName, ImGuiCustomCol color);
 
+            /**
+             * @brief Reconstructs the toolbar items list after they have been modified
+             */
+            void updateToolbarItems();
+
             /**
              * @brief Adds a new sidebar item
              * @param icon The icon to use for the item
@@ -981,12 +987,34 @@ namespace hex {
             namespace impl {
 
                 using Callback = std::function<std::string(prv::Provider *provider, u64 address, size_t size)>;
-                struct Entry {
+                struct ExportMenuEntry {
                     UnlocalizedString unlocalizedName;
                     Callback callback;
                 };
 
-                const std::vector<Entry>& getEntries();
+                struct FindOccurrence {
+                    Region region;
+                    enum class DecodeType { ASCII, Binary, UTF16, Unsigned, Signed, Float, Double } decodeType;
+                    std::endian endian = std::endian::native;
+                    bool selected;
+                };
+
+                using FindExporterCallback = std::function<std::vector<u8>(const std::vector<FindOccurrence>&, std::function<std::string(FindOccurrence)>)>;
+                struct FindExporterEntry {
+                    UnlocalizedString unlocalizedName;
+                    std::string fileExtension;
+                    FindExporterCallback callback;
+                };
+
+                /**
+                 * @brief Retrieves a list of all registered data formatters used by the 'File -> Export' menu
+                 */
+                const std::vector<ExportMenuEntry>& getExportMenuEntries();
+
+                /**
+                 * @brief Retrieves a list of all registered data formatters used in the Results section of the 'Find' view
+                 */
+                const std::vector<FindExporterEntry>& getFindExporterEntries();
 
             }
 
@@ -996,7 +1024,14 @@ namespace hex {
              * @param unlocalizedName The unlocalized name of the formatter
              * @param callback The function to call to format the data
              */
-            void add(const UnlocalizedString &unlocalizedName, const impl::Callback &callback);
+            void addExportMenuEntry(const UnlocalizedString &unlocalizedName, const impl::Callback &callback);
+
+            /**
+             * @brief Adds a new data exporter for Find results
+             * @param unlocalizedName The unlocalized name of the formatter
+             * @param callback The function to call to format the data
+             */
+            void addFindExportFormatter(const UnlocalizedString &unlocalizedName, const std::string fileExtension, const impl::FindExporterCallback &callback);
 
         }
 
@@ -1057,7 +1092,7 @@ namespace hex {
             };
 
             struct MiniMapVisualizer {
-                using Callback = std::function<ImColor(const std::vector<u8>&)>;
+                using Callback = std::function<void(u64, std::span<const u8>, std::vector<ImColor>&)>;
 
                 UnlocalizedString unlocalizedName;
                 Callback callback;

lib/libimhex/include/hex/api/event_manager.hpp

@@ -14,18 +14,18 @@
 
 #include <wolv/types/type_name.hpp>
 
-#define EVENT_DEF_IMPL(event_name, event_name_string, should_log, ...)                                                                          \
-    struct event_name final : public hex::impl::Event<__VA_ARGS__> {                                                                            \
-        constexpr static auto Id = [] { return hex::impl::EventId(event_name_string); }();                                                      \
-        constexpr static auto ShouldLog = (should_log);                                                                                         \
-        explicit event_name(Callback func) noexcept : Event(std::move(func)) { }                                                                \
-                                                                                                                                                \
-        static EventManager::EventList::iterator subscribe(Event::Callback function) { return EventManager::subscribe<event_name>(function); }  \
-        static void subscribe(void *token, Event::Callback function) { EventManager::subscribe<event_name>(token, function); }                  \
-        static void unsubscribe(const EventManager::EventList::iterator &token) noexcept { EventManager::unsubscribe(token); }                  \
-        static void unsubscribe(void *token) noexcept { EventManager::unsubscribe<event_name>(token); }                                         \
-        static void post(auto &&...args) { EventManager::post<event_name>(std::forward<decltype(args)>(args)...); }                    \
-    };
+#define EVENT_DEF_IMPL(event_name, event_name_string, should_log, ...)                                                                                      \
+    struct event_name final : public hex::impl::Event<__VA_ARGS__> {                                                                                        \
+        constexpr static auto Id = [] { return hex::impl::EventId(event_name_string); }();                                                                  \
+        constexpr static auto ShouldLog = (should_log);                                                                                                     \
+        explicit event_name(Callback func) noexcept : Event(std::move(func)) { }                                                                            \
+                                                                                                                                                            \
+        static EventManager::EventList::iterator subscribe(Event::Callback function) { return EventManager::subscribe<event_name>(std::move(function)); }   \
+        static void subscribe(void *token, Event::Callback function) { EventManager::subscribe<event_name>(token, std::move(function)); }                   \
+        static void unsubscribe(const EventManager::EventList::iterator &token) noexcept { EventManager::unsubscribe(token); }                              \
+        static void unsubscribe(void *token) noexcept { EventManager::unsubscribe<event_name>(token); }                                                     \
+        static void post(auto &&...args) { EventManager::post<event_name>(std::forward<decltype(args)>(args)...); }                                         \
+    }
 
 #define EVENT_DEF(event_name, ...)          EVENT_DEF_IMPL(event_name, #event_name, true, __VA_ARGS__)
 #define EVENT_DEF_NO_LOG(event_name, ...)   EVENT_DEF_IMPL(event_name, #event_name, false, __VA_ARGS__)
@@ -58,6 +58,10 @@ namespace hex {
                 return m_hash == other.m_hash;
             }
 
+            constexpr auto operator<=>(const EventId &other) const {
+                return m_hash <=> other.m_hash;
+            }
+
         private:
             u32 m_hash;
         };
@@ -73,11 +77,12 @@ namespace hex {
 
             explicit Event(Callback func) noexcept : m_func(std::move(func)) { }
 
-            void operator()(std::string_view eventName, Params... params) const {
+            template<typename E>
+            void call(Params... params) const {
                 try {
                     m_func(params...);
                 } catch (const std::exception &e) {
-                    log::error("An exception occurred while handling event {}: {}", eventName, e.what());
+                    log::error("An exception occurred while handling event {}: {}", wolv::type::getTypeName<E>(), e.what());
                     throw;
                 }
             }
@@ -98,7 +103,7 @@ namespace hex {
      */
     class EventManager {
     public:
-        using EventList = std::list<std::pair<impl::EventId, std::unique_ptr<impl::EventBase>>>;
+        using EventList = std::multimap<impl::EventId, std::unique_ptr<impl::EventBase>>;
 
         /**
          * @brief Subscribes to an event
@@ -111,7 +116,7 @@ namespace hex {
             std::scoped_lock lock(getEventMutex());
 
             auto &events = getEvents();
-            return events.insert(events.end(), std::make_pair(E::Id, std::make_unique<E>(function)));
+            return events.insert({ E::Id, std::make_unique<E>(function) });
         }
 
         /**
@@ -163,7 +168,7 @@ namespace hex {
             });
 
             if (iter != tokenStore.end()) {
-                getEvents().remove(*iter->second);
+                getEvents().erase(iter->second);
                 tokenStore.erase(iter);
             }
 
@@ -178,14 +183,14 @@ namespace hex {
         static void post(auto && ...args) {
             std::scoped_lock lock(getEventMutex());
 
-            for (const auto &[id, event] : getEvents()) {
-                if (id == E::Id) {
-                    (*static_cast<E *const>(event.get()))(wolv::type::getTypeName<E>(), std::forward<decltype(args)>(args)...);
-                }
+            auto [begin, end] = getEvents().equal_range(E::Id);
+            for (auto it = begin; it != end; ++it) {
+                const auto &[id, event] = *it;
+                (*static_cast<E *const>(event.get())).template call<E>(std::forward<decltype(args)>(args)...);
             }
 
             #if defined (DEBUG)
-                if (E::ShouldLog)
+                if constexpr (E::ShouldLog)
                     log::debug("Event posted: '{}'", wolv::type::getTypeName<E>());
             #endif
         }
@@ -265,6 +270,7 @@ namespace hex {
     EVENT_DEF(EventProviderDataModified, prv::Provider *, u64, u64, const u8*);
     EVENT_DEF(EventProviderDataInserted, prv::Provider *, u64, u64);
     EVENT_DEF(EventProviderDataRemoved, prv::Provider *, u64, u64);
+    EVENT_DEF(EventProviderDirtied, prv::Provider *);
 
     /**
      * @brief Called when a project has been loaded
@@ -274,6 +280,7 @@ namespace hex {
     EVENT_DEF_NO_LOG(EventFrameBegin);
     EVENT_DEF_NO_LOG(EventFrameEnd);
     EVENT_DEF_NO_LOG(EventSetTaskBarIconState, u32, u32, u32);
+    EVENT_DEF_NO_LOG(EventImGuiElementRendered, ImGuiID, const std::array<float, 4>&);
 
     EVENT_DEF(RequestAddInitTask, std::string, bool, std::function<bool()>);
     EVENT_DEF(RequestAddExitTask, std::string, std::function<bool()>);

lib/libimhex/include/hex/api/imhex_api.hpp

@@ -75,7 +75,7 @@ namespace hex {
             namespace impl {
 
                 using HighlightingFunction = std::function<std::optional<color_t>(u64, const u8*, size_t, bool)>;
-                using HoveringFunction = std::function<bool(const prv::Provider *, u64, const u8*, size_t)>;
+                using HoveringFunction = std::function<std::set<Region>(const prv::Provider *, u64, size_t)>;
 
                 const std::map<u32, Highlighting>& getBackgroundHighlights();
                 const std::map<u32, HighlightingFunction>& getBackgroundHighlightingFunctions();
@@ -293,7 +293,7 @@ namespace hex {
             namespace impl {
 
                 void resetClosingProvider();
-                const std::set<prv::Provider*>& getClosingProviders();
+                std::set<prv::Provider*> getClosingProviders();
 
             }
 
@@ -434,6 +434,7 @@ namespace hex {
                 void setInitialWindowProperties(InitialWindowProperties properties);
 
                 void setGPUVendor(const std::string &vendor);
+                void setGLRenderer(const std::string &renderer);
 
                 void addInitArgument(const std::string &key, const std::string &value = { });
 
@@ -573,6 +574,12 @@ namespace hex {
              */
             const std::string& getGPUVendor();
 
+            /**
+             * @brief Gets the current GPU vendor
+             * @return The current GPU vendor
+             */
+            const std::string& getGLRenderer();
+
             /**
              * @brief Checks if ImHex is running in portable mode
              * @return Whether ImHex is running in portable mode
@@ -597,6 +604,16 @@ namespace hex {
              */
             std::string getArchitecture();
 
+
+            struct LinuxDistro {
+                std::string name;
+                std::string version;
+            };
+            /**
+             * @brief Gets information related to the Linux distribution, if running on Linux
+             */
+            std::optional<LinuxDistro> getLinuxDistro();
+
             /**
              * @brief Gets the current ImHex version
              * @return ImHex version
@@ -622,6 +639,12 @@ namespace hex {
              */
             bool isDebugBuild();
 
+            /**
+             * @brief Checks if this version of ImHex is a nightly build
+             * @return True if this version is a nightly, false if it's a release
+             */
+            bool isNightlyBuild();
+
             enum class UpdateType {
                 Stable,
                 Nightly

lib/libimhex/include/hex/api/localization_manager.hpp

@@ -102,12 +102,9 @@ namespace hex {
         std::string m_unlocalizedString;
     };
 
-}
-
-template<>
-struct fmt::formatter<hex::Lang> : fmt::formatter<std::string_view> {
-    template<typename FormatContext>
-    auto format(const hex::Lang &entry, FormatContext &ctx) {
-        return fmt::formatter<std::string_view>::format(entry.get(), ctx);
+    // {fmt} formatter for hex::Lang
+    inline auto format_as(const hex::Lang &entry) {
+        return entry.get();
     }
-};
+
+}

lib/libimhex/include/hex/api/tutorial_manager.hpp

@@ -119,6 +119,8 @@ namespace hex {
             decltype(m_steps)::iterator m_currentStep, m_latestStep;
         };
 
+        static void init();
+
         /**
          * @brief Gets a list of all tutorials
          * @return List of all tutorials
@@ -145,6 +147,10 @@ namespace hex {
          */
         static void startTutorial(const UnlocalizedString &unlocalizedName);
 
+        static void startHelpHover();
+        static void addInteractiveHelpText(std::initializer_list<std::variant<Lang, std::string, int>> &&ids, UnlocalizedString unlocalizedString);
+        static void addInteractiveHelpLink(std::initializer_list<std::variant<Lang, std::string, int>> &&ids, std::string link);
+
 
         /**
          * @brief Draws the tutorial

lib/libimhex/include/hex/helpers/default_paths.hpp

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <hex/helpers/fs.hpp>
+
+#include <vector>
+
+namespace hex::paths {
+
+    namespace impl {
+
+        class DefaultPath {
+        protected:
+            constexpr DefaultPath() = default;
+            virtual ~DefaultPath() = default;
+
+        public:
+            DefaultPath(const DefaultPath&) = delete;
+            DefaultPath(DefaultPath&&) = delete;
+            DefaultPath& operator=(const DefaultPath&) = delete;
+            DefaultPath& operator=(DefaultPath&&) = delete;
+
+            virtual std::vector<std::fs::path> all() const = 0;
+            virtual std::vector<std::fs::path> read() const;
+            virtual std::vector<std::fs::path> write() const;
+        };
+
+        class ConfigPath : public DefaultPath {
+        public:
+            explicit ConfigPath(std::fs::path postfix) : m_postfix(std::move(postfix)) {}
+
+            std::vector<std::fs::path> all() const override;
+
+        private:
+            std::fs::path m_postfix;
+        };
+
+        class DataPath : public DefaultPath {
+        public:
+            explicit DataPath(std::fs::path postfix) : m_postfix(std::move(postfix)) {}
+
+            std::vector<std::fs::path> all() const override;
+            std::vector<std::fs::path> write() const override;
+
+        private:
+            std::fs::path m_postfix;
+        };
+
+        class PluginPath : public DefaultPath {
+        public:
+            explicit PluginPath(std::fs::path postfix) : m_postfix(std::move(postfix)) {}
+
+            std::vector<std::fs::path> all() const override;
+
+        private:
+            std::fs::path m_postfix;
+        };
+
+    }
+
+    std::vector<std::fs::path> getDataPaths(bool includeSystemFolders);
+    std::vector<std::fs::path> getConfigPaths(bool includeSystemFolders);
+
+    const static inline impl::ConfigPath Config("config");
+    const static inline impl::ConfigPath Recent("recent");
+
+    const static inline impl::PluginPath Libraries("lib");
+    const static inline impl::PluginPath Plugins("plugins");
+
+    const static inline impl::DataPath Patterns("patterns");
+    const static inline impl::DataPath PatternsInclude("includes");
+    const static inline impl::DataPath Magic("magic");
+    const static inline impl::DataPath Yara("yara");
+    const static inline impl::DataPath YaraAdvancedAnalysis("yara/advanced_analysis");
+    const static inline impl::DataPath Backups("backups");
+    const static inline impl::DataPath Resources("resources");
+    const static inline impl::DataPath Constants("constants");
+    const static inline impl::DataPath Encodings("encodings");
+    const static inline impl::DataPath Logs("logs");
+    const static inline impl::DataPath Scripts("scripts");
+    const static inline impl::DataPath Inspectors("scripts/inspectors");
+    const static inline impl::DataPath Themes("themes");
+    const static inline impl::DataPath Nodes("scripts/nodes");
+    const static inline impl::DataPath Layouts("layouts");
+    const static inline impl::DataPath Workspaces("workspaces");
+
+    constexpr static inline std::array<const impl::DefaultPath*, 20> All = {
+        &Config,
+        &Recent,
+
+        &Libraries,
+        &Plugins,
+
+        &Patterns,
+        &PatternsInclude,
+        &Magic,
+        &Yara,
+        &YaraAdvancedAnalysis,
+        &Backups,
+        &Resources,
+        &Constants,
+        &Encodings,
+        &Logs,
+        &Scripts,
+        &Inspectors,
+        &Themes,
+        &Nodes,
+        &Layouts,
+        &Workspaces,
+    };
+
+}

lib/libimhex/include/hex/helpers/fmt.hpp

@@ -2,6 +2,7 @@
 
 #include <string_view>
 #include <fmt/format.h>
+#include <fmt/ranges.h>
 
 namespace hex {
 

lib/libimhex/include/hex/helpers/fs.hpp

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <hex.hpp>
-
 #include <string>
 #include <vector>
 #include <filesystem>
@@ -31,36 +29,7 @@ namespace hex::fs {
     void openFolderExternal(const std::fs::path &dirPath);
     void openFolderWithSelectionExternal(const std::fs::path &selectedFilePath);
 
-    enum class ImHexPath : u32 {
-        Patterns = 0,
-        PatternsInclude,
-        Magic,
-        Plugins,
-        Yara,
-        YaraAdvancedAnalysis,
-        Config,
-        Backups,
-        Resources,
-        Constants,
-        Encodings,
-        Logs,
-        Recent,
-        Scripts,
-        Inspectors,
-        Themes,
-        Libraries,
-        Nodes,
-        Layouts,
-        Workspaces,
-
-        END
-    };
 
     bool isPathWritable(const std::fs::path &path);
 
-    std::vector<std::fs::path> getDefaultPaths(ImHexPath path, bool listNonExisting = false);
-
-    // Temporarily expose these for the migration function
-    std::vector<std::fs::path> getDataPaths();
-    std::vector<std::fs::path> appendPath(std::vector<std::fs::path> paths, const std::fs::path &folder);
 }

lib/libimhex/include/hex/helpers/types.hpp

@@ -61,6 +61,10 @@ namespace hex {
         constexpr static Region Invalid() {
             return { 0, 0 };
         }
+
+        constexpr bool operator<(const Region &other) const {
+            return this->address < other.address;
+        }
     };
 
 

lib/libimhex/include/hex/helpers/utils.hpp

@@ -298,31 +298,7 @@ namespace hex {
 
     [[nodiscard]] std::optional<std::string> getEnvironmentVariable(const std::string &env);
 
-    [[nodiscard]] inline std::string limitStringLength(const std::string &string, size_t maxLength) {
-        // If the string is shorter than the max length, return it as is
-        if (string.size() < maxLength)
-            return string;
-
-        // If the string is longer than the max length, find the last space before the max length
-        auto it = string.begin() + maxLength;
-        while (it != string.begin() && !std::isspace(*it)) --it;
-
-        // If there's no space before the max length, just cut the string
-        if (it == string.begin()) {
-            it = string.begin() + maxLength;
-
-            // Try to find a UTF-8 character boundary
-            while (it != string.begin() && (*it & 0x80) != 0x00) --it;
-            ++it;
-        }
-
-        // If we still didn't find a valid boundary, just return the string as is
-        if (it == string.begin())
-            return string;
-
-        // Append
-        return std::string(string.begin(), it) + "…";
-    }
+    [[nodiscard]] std::string limitStringLength(const std::string &string, size_t maxLength);
 
     [[nodiscard]] std::optional<std::fs::path> getInitialFilePath();
 

lib/libimhex/include/hex/helpers/utils_macos.hpp

@@ -18,6 +18,7 @@
     
         void macosHandleTitlebarDoubleClickGesture(GLFWwindow *window);
         bool macosIsWindowBeingResizedByUser(GLFWwindow *window);
+        void macosMarkContentEdited(GLFWwindow *window, bool edited = true);
     }
 
 #endif

lib/libimhex/include/hex/plugin.hpp

@@ -37,15 +37,34 @@ void* PluginSubCommandsFunctionHelper<T>::getSubCommands() {
     return nullptr;
 }
 
+[[maybe_unused]] static auto& getFeaturesImpl() {
+    static std::vector<hex::Feature> features;
+    return features;
+}
+
 #if defined (IMHEX_STATIC_LINK_PLUGINS)
     #define IMHEX_PLUGIN_VISIBILITY_PREFIX static
 #else
     #define IMHEX_PLUGIN_VISIBILITY_PREFIX extern "C" [[gnu::visibility("default")]]
 #endif
 
+#define IMHEX_FEATURE_ENABLED(feature) WOLV_TOKEN_CONCAT(WOLV_TOKEN_CONCAT(WOLV_TOKEN_CONCAT(IMHEX_PLUGIN_, IMHEX_PLUGIN_NAME), _FEATURE_), feature)
+#define IMHEX_DEFINE_PLUGIN_FEATURES() IMHEX_DEFINE_PLUGIN_FEATURES_IMPL()
+#define IMHEX_DEFINE_PLUGIN_FEATURES_IMPL()                                                 \
+    template<>                                                                              \
+    struct PluginFeatureFunctionHelper<PluginFunctionHelperInstantiation> {                 \
+        static void* getFeatures();                                                         \
+    };                                                                                      \
+    void* PluginFeatureFunctionHelper<PluginFunctionHelperInstantiation>::getFeatures() {   \
+        return &getFeaturesImpl();                                                          \
+    }                                                                                       \
+    static auto initFeatures = [] { getFeaturesImpl() = std::vector<hex::Feature>({ IMHEX_PLUGIN_FEATURES_CONTENT }); return 0; }()
+
+#define IMHEX_PLUGIN_FEATURES ::getFeaturesImpl()
+
 /**
  * This macro is used to define all the required entry points for a plugin.
- * Name, Author and Description will be displayed in the in the plugin list on the Welcome screen.
+ * Name, Author and Description will be displayed in the plugin list on the Welcome screen.
  */
 #define IMHEX_PLUGIN_SETUP(name, author, description) IMHEX_PLUGIN_SETUP_IMPL(name, author, description)
 #define IMHEX_LIBRARY_SETUP(name) IMHEX_LIBRARY_SETUP_IMPL(name)
@@ -85,6 +104,7 @@ void* PluginSubCommandsFunctionHelper<T>::getSubCommands() {
         ImGui::SetCurrentContext(ctx);                                                                                          \
         GImGui = ctx;                                                                                                           \
     }                                                                                                                           \
+    IMHEX_DEFINE_PLUGIN_FEATURES();                                                                                             \
     IMHEX_PLUGIN_VISIBILITY_PREFIX void* getFeatures() {                                                                        \
         return PluginFeatureFunctionHelper<PluginFunctionHelperInstantiation>::getFeatures();                                   \
     }                                                                                                                           \
@@ -129,18 +149,3 @@ void* PluginSubCommandsFunctionHelper<T>::getSubCommands() {
         return &g_subCommands;                                                                      \
     }                                                                                               \
     std::vector<hex::SubCommand> g_subCommands
-
-#define IMHEX_FEATURE_ENABLED(feature) WOLV_TOKEN_CONCAT(WOLV_TOKEN_CONCAT(WOLV_TOKEN_CONCAT(IMHEX_PLUGIN_, IMHEX_PLUGIN_NAME), _FEATURE_), feature)
-#define IMHEX_DEFINE_PLUGIN_FEATURES() IMHEX_DEFINE_PLUGIN_FEATURES_IMPL()
-#define IMHEX_DEFINE_PLUGIN_FEATURES_IMPL()                                                 \
-    extern std::vector<hex::Feature> g_features;                                            \
-    template<>                                                                              \
-    struct PluginFeatureFunctionHelper<PluginFunctionHelperInstantiation> {                 \
-        static void* getFeatures();                                                         \
-    };                                                                                      \
-    void* PluginFeatureFunctionHelper<PluginFunctionHelperInstantiation>::getFeatures() {   \
-        return &g_features;                                                                 \
-    }                                                                                       \
-    std::vector<hex::Feature> g_features
-
-#define IMHEX_PLUGIN_FEATURES g_features

lib/libimhex/include/hex/ui/imgui_imhex_extensions.h

@@ -123,6 +123,8 @@ namespace ImGuiExt {
         int m_width = 0, m_height = 0;
     };
 
+    float GetTextWrapPos();
+
     int UpdateStringSizeCallback(ImGuiInputTextCallbackData *data);
 
     bool IconHyperlink(const char *icon, const char *label, const ImVec2 &size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);
@@ -186,7 +188,12 @@ namespace ImGuiExt {
     void SmallProgressBar(float fraction, float yOffset = 0.0F);
 
     inline void TextFormatted(std::string_view fmt, auto &&...args) {
-        ImGui::TextUnformatted(hex::format(fmt, std::forward<decltype(args)>(args)...).c_str());
+        if constexpr (sizeof...(args) == 0) {
+            ImGui::TextUnformatted(fmt.data(), fmt.data() + fmt.size());
+        } else {
+            const auto string = hex::format(fmt, std::forward<decltype(args)>(args)...);
+            ImGui::TextUnformatted(string.c_str(), string.c_str() + string.size());
+        }
     }
 
     inline void TextFormattedSelectable(std::string_view fmt, auto &&...args) {
@@ -208,15 +215,24 @@ namespace ImGuiExt {
     }
 
     inline void TextFormattedColored(ImColor color, std::string_view fmt, auto &&...args) {
-        ImGui::TextColored(color, "%s", hex::format(fmt, std::forward<decltype(args)>(args)...).c_str());
+        ImGui::PushStyleColor(ImGuiCol_Text, color.Value);
+        ImGuiExt::TextFormatted(fmt, std::forward<decltype(args)>(args)...);
+        ImGui::PopStyleColor();
     }
 
     inline void TextFormattedDisabled(std::string_view fmt, auto &&...args) {
-        ImGui::TextDisabled("%s", hex::format(fmt, std::forward<decltype(args)>(args)...).c_str());
+        ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetStyle().Colors[ImGuiCol_TextDisabled]);
+        ImGuiExt::TextFormatted(fmt, std::forward<decltype(args)>(args)...);
+        ImGui::PopStyleColor();
     }
 
     inline void TextFormattedWrapped(std::string_view fmt, auto &&...args) {
-        ImGui::TextWrapped("%s", hex::format(fmt, std::forward<decltype(args)>(args)...).c_str());
+        const bool need_backup = ImGuiExt::GetTextWrapPos() < 0.0F;  // Keep existing wrap position if one is already set
+        if (need_backup)
+            ImGui::PushTextWrapPos(0.0F);
+        ImGuiExt::TextFormatted(fmt, std::forward<decltype(args)>(args)...);
+        if (need_backup)
+            ImGui::PopTextWrapPos();
     }
 
     inline void TextFormattedWrappedSelectable(std::string_view fmt, auto &&...args) {
@@ -286,7 +302,7 @@ namespace ImGuiExt {
     bool BeginBox();
     void EndBox();
 
-    void BeginSubWindow(const char *label, ImVec2 size = ImVec2(0, 0), ImGuiChildFlags flags = ImGuiChildFlags_None);
+    bool BeginSubWindow(const char *label, bool *collapsed = nullptr, ImVec2 size = ImVec2(0, 0), ImGuiChildFlags flags = ImGuiChildFlags_None);
     void EndSubWindow();
 
     void ConfirmButtons(const char *textLeft, const char *textRight, const auto &leftButtonCallback, const auto &rightButtonCallback) {

lib/libimhex/include/hex/ui/view.hpp

@@ -158,6 +158,7 @@ namespace hex {
         explicit Floating(UnlocalizedString unlocalizedName) : Window(std::move(unlocalizedName), "") {}
 
         [[nodiscard]] ImGuiWindowFlags getWindowFlags() const override { return ImGuiWindowFlags_NoDocking; }
+        [[nodiscard]] bool shouldStoreWindowState() const override { return false; }
     };
 
     /**

lib/libimhex/source/api/achievement_manager.cpp

@@ -2,6 +2,7 @@
 #include <hex/api/event_manager.hpp>
 
 #include <hex/helpers/auto_reset.hpp>
+#include <hex/helpers/default_paths.hpp>
 
 #include <nlohmann/json.hpp>
 
@@ -197,7 +198,7 @@ namespace hex {
     constexpr static auto AchievementsFile = "achievements.json";
 
     void AchievementManager::loadProgress() {
-        for (const auto &directory : fs::getDefaultPaths(fs::ImHexPath::Config)) {
+        for (const auto &directory : paths::Config.read()) {
             auto path = directory / AchievementsFile;
 
             if (!wolv::io::fs::exists(path)) {
@@ -246,7 +247,7 @@ namespace hex {
         if (json.empty())
             return;
 
-        for (const auto &directory : fs::getDefaultPaths(fs::ImHexPath::Config)) {
+        for (const auto &directory : paths::Config.write()) {
             auto path = directory / AchievementsFile;
 
             wolv::io::File file(path, wolv::io::File::Mode::Create);

lib/libimhex/source/api/content_registry.cpp

@@ -4,6 +4,7 @@
 #include <hex/helpers/fs.hpp>
 #include <hex/helpers/logger.hpp>
 #include <hex/helpers/auto_reset.hpp>
+#include <hex/helpers/default_paths.hpp>
 
 #include <hex/ui/view.hpp>
 #include <hex/data_processor/node.hpp>
@@ -101,7 +102,7 @@ namespace hex {
 
                 void load() {
                     bool loaded = false;
-                    for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Config)) {
+                    for (const auto &dir : paths::Config.read()) {
                         wolv::io::File file(dir / SettingsFile, wolv::io::File::Mode::Read);
 
                         if (file.isValid()) {
@@ -142,7 +143,7 @@ namespace hex {
                     if (result.empty()) {
                         return;
                     }
-                    for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Config)) {
+                    for (const auto &dir : paths::Config.write()) {
                         wolv::io::File file(dir / SettingsFile, wolv::io::File::Mode::Create);
 
                         if (file.isValid()) {
@@ -153,7 +154,7 @@ namespace hex {
                 }
 
                 void clear() {
-                    for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Config)) {
+                    for (const auto &dir : paths::Config.write()) {
                         wolv::io::fs::remove(dir / SettingsFile);
                     }
                 }
@@ -595,7 +596,7 @@ namespace hex {
                 );
             }
 
-            runtime.setIncludePaths(fs::getDefaultPaths(fs::ImHexPath::PatternsInclude) | fs::getDefaultPaths(fs::ImHexPath::Patterns));
+            runtime.setIncludePaths(paths::PatternsInclude.read() | paths::Patterns.read());
 
             for (const auto &[ns, name, paramCount, callback, dangerous] : impl::getFunctions()) {
                 if (dangerous)
@@ -820,6 +821,12 @@ namespace hex {
                 return *s_menuItems;
             }
 
+            static AutoReset<std::vector<MenuItem*>> s_toolbarMenuItems;
+            const std::vector<MenuItem*>& getToolbarMenuItems() {
+                return s_toolbarMenuItems;
+            }
+
+
             std::multimap<u32, MenuItem>& getMenuItemsMutable() {
                 return *s_menuItems;
             }
@@ -929,11 +936,35 @@ namespace hex {
                 if (menuItem.unlocalizedNames.back() == unlocalizedName) {
                     menuItem.toolbarIndex = maxIndex + 1;
                     menuItem.icon.color = color;
+                    updateToolbarItems();
+
                     break;
                 }
             }
         }
 
+        struct MenuItemSorter {
+            bool operator()(const auto *a, const auto *b) const {
+                return a->toolbarIndex < b->toolbarIndex;
+            }
+        };
+
+        void updateToolbarItems() {
+            std::set<ContentRegistry::Interface::impl::MenuItem*, MenuItemSorter> menuItems;
+
+            for (auto &[priority, menuItem] : impl::getMenuItemsMutable()) {
+                if (menuItem.toolbarIndex != -1) {
+                    menuItems.insert(&menuItem);
+                }
+            }
+
+            impl::s_toolbarMenuItems->clear();
+            for (auto menuItem : menuItems) {
+                impl::s_toolbarMenuItems->push_back(menuItem);
+            }
+        }
+
+
 
         void addSidebarItem(const std::string &icon, const impl::DrawCallback &function, const impl::EnabledCallback &enabledCallback) {
             impl::s_sidebarItems->push_back({ icon, function, enabledCallback });
@@ -982,17 +1013,28 @@ namespace hex {
 
         namespace impl {
 
-            static AutoReset<std::vector<Entry>> s_entries;
-            const std::vector<Entry>& getEntries() {
-                return *s_entries;
+            static AutoReset<std::vector<ExportMenuEntry>> s_exportMenuEntries;
+            const std::vector<ExportMenuEntry>& getExportMenuEntries() {
+                return *s_exportMenuEntries;
+            }
+
+            static AutoReset<std::vector<FindExporterEntry>> s_findExportEntries;
+            const std::vector<FindExporterEntry>& getFindExporterEntries() {
+                return *s_findExportEntries;
             }
 
         }
 
-        void add(const UnlocalizedString &unlocalizedName, const impl::Callback &callback) {
+        void addExportMenuEntry(const UnlocalizedString &unlocalizedName, const impl::Callback &callback) {
             log::debug("Registered new data formatter: {}", unlocalizedName.get());
 
-            impl::s_entries->push_back({ unlocalizedName, callback });
+            impl::s_exportMenuEntries->push_back({ unlocalizedName, callback });
+        }
+
+        void addFindExportFormatter(const UnlocalizedString &unlocalizedName, const std::string fileExtension, const impl::FindExporterCallback &callback) {
+            log::debug("Registered new export formatter: {}", unlocalizedName.get());
+
+            impl::s_findExportEntries->push_back({ unlocalizedName, fileExtension, callback });
         }
 
     }

lib/libimhex/source/api/imhex_api.cpp

@@ -15,6 +15,7 @@
 #include <imgui.h>
 #include <imgui_internal.h>
 #include <set>
+#include <algorithm>
 #include <GLFW/glfw3.h>
 
 #if defined(OS_WINDOWS)
@@ -183,24 +184,24 @@ namespace hex {
             impl::s_hoveringFunctions->erase(id);
         }
 
-        static u32 tooltipId = 0;
+        static u32 s_tooltipId = 0;
         u32 addTooltip(Region region, std::string value, color_t color) {
-            tooltipId++;
-            impl::s_tooltips->insert({ tooltipId, { region, std::move(value), color } });
+            s_tooltipId++;
+            impl::s_tooltips->insert({ s_tooltipId, { region, std::move(value), color } });
 
-            return tooltipId;
+            return s_tooltipId;
         }
 
         void removeTooltip(u32 id) {
             impl::s_tooltips->erase(id);
         }
 
-        static u32 tooltipFunctionId;
+        static u32 s_tooltipFunctionId;
         u32 addTooltipProvider(TooltipFunction function) {
-            tooltipFunctionId++;
-            impl::s_tooltipFunctions->insert({ tooltipFunctionId, std::move(function) });
+            s_tooltipFunctionId++;
+            impl::s_tooltipFunctions->insert({ s_tooltipFunctionId, std::move(function) });
 
-            return tooltipFunctionId;
+            return s_tooltipFunctionId;
         }
 
         void removeTooltipProvider(u32 id) {
@@ -267,6 +268,7 @@ namespace hex {
 
         static i64 s_currentProvider = -1;
         static AutoReset<std::vector<std::unique_ptr<prv::Provider>>> s_providers;
+        static AutoReset<std::list<std::unique_ptr<prv::Provider>>> s_providersToRemove;
 
         namespace impl {
 
@@ -275,7 +277,7 @@ namespace hex {
                 s_closingProviders.clear();
             }
 
-            const std::set<prv::Provider*>& getClosingProviders() {
+            std::set<prv::Provider*> getClosingProviders() {
                 return s_closingProviders;
             }
 
@@ -336,6 +338,7 @@ namespace hex {
 
         void markDirty() {
             get()->markDirty();
+            EventProviderDirtied::post(get());
         }
 
         void resetDirty() {
@@ -423,20 +426,37 @@ namespace hex {
                 }
             }
 
-            provider->close();
-            EventProviderClosed::post(provider);
+            static std::mutex eraseMutex;
+
+            // Move provider over to a list of providers to delete
+            eraseMutex.lock();
+            auto removeIt = s_providersToRemove->emplace(s_providersToRemove->end(), std::move(*it));
+            eraseMutex.unlock();
+
+            // Remove left over references from the main provider list
+            s_providers->erase(it);
+            impl::s_closingProviders.erase(provider);
+
+            if (s_currentProvider >= i64(s_providers->size()) && !s_providers->empty())
+                setCurrentProvider(s_providers->size() - 1);
+
+            if (s_providers->empty())
+                EventProviderChanged::post(provider, nullptr);
+
+            EventProviderClosed::post(removeIt->get());
             RequestUpdateWindowTitle::post();
 
-            TaskManager::runWhenTasksFinished([it, provider] {
-                EventProviderDeleted::post(provider);
-                impl::s_closingProviders.erase(provider);
+            // Do the destruction of the provider in the background once all tasks have finished
+            TaskManager::runWhenTasksFinished([removeIt] {
+                EventProviderDeleted::post(removeIt->get());
+                TaskManager::createBackgroundTask("Closing Provider", [removeIt](Task &) {
+                    eraseMutex.lock();
+                    auto provider = std::move(*removeIt);
+                    s_providersToRemove->erase(removeIt);
+                    eraseMutex.unlock();
 
-                s_providers->erase(it);
-                if (s_currentProvider >= i64(s_providers->size()))
-                    setCurrentProvider(0);
-
-                if (s_providers->empty())
-                    EventProviderChanged::post(provider, nullptr);
+                    provider->close();
+                });
             });
         }
 
@@ -512,6 +532,11 @@ namespace hex {
                 s_gpuVendor = vendor;
             }
 
+            static AutoReset<std::string> s_glRenderer;
+            void setGLRenderer(const std::string &renderer) {
+                s_glRenderer = renderer;
+            }
+
             static AutoReset<std::map<std::string, std::string>> s_initArguments;
             void addInitArgument(const std::string &key, const std::string &value) {
                 static std::mutex initArgumentsMutex;
@@ -613,7 +638,7 @@ namespace hex {
         }
 
         void* getLibImHexModuleHandle() {
-            return hex::getContainingModule((void*)&getLibImHexModuleHandle);
+            return hex::getContainingModule(reinterpret_cast<void*>(&getLibImHexModuleHandle));
         }
 
 
@@ -656,6 +681,10 @@ namespace hex {
             return impl::s_gpuVendor;
         }
 
+        const std::string &getGLRenderer() {
+            return impl::s_glRenderer;
+        }
+
         bool isPortableVersion() {
             static std::optional<bool> portable;
             if (portable.has_value())
@@ -742,6 +771,25 @@ namespace hex {
             #endif
         }
 
+        std::optional<LinuxDistro> getLinuxDistro() {
+            wolv::io::File file("/etc/os-release", wolv::io::File::Mode::Read);
+            std::string name;
+            std::string version;
+
+            auto fileContent = file.readString();
+            for (const auto &line : wolv::util::splitString(fileContent, "\n")) {
+                if (line.find("PRETTY_NAME=") != std::string::npos) {
+                    name = line.substr(line.find("=") + 1);
+                    std::erase(name, '\"');
+                } else if (line.find("VERSION_ID=") != std::string::npos) {
+                    version = line.substr(line.find("=") + 1);
+                    std::erase(version, '\"');
+                }
+            }
+
+            return { { name, version } };
+        }
+
         std::string getImHexVersion(bool withBuildType) {
             #if defined IMHEX_VERSION
                 if (withBuildType) {
@@ -784,6 +832,10 @@ namespace hex {
             #endif
         }
 
+        bool isNightlyBuild() {
+            return getImHexVersion(false).ends_with("WIP");
+        }
+
         bool updateImHex(UpdateType updateType) {
             // Get the path of the updater executable
             std::fs::path executablePath;
@@ -810,7 +862,7 @@ namespace hex {
 
             EventImHexClosing::subscribe([executablePath, updateTypeString] {
                 hex::executeCommand(
-                        hex::format("{} {}",
+                        hex::format("\"{}\" \"{}\"",
                                     wolv::util::toUTF8String(executablePath),
                                     updateTypeString
                                     )
@@ -889,9 +941,9 @@ namespace hex {
                 s_fontSize = size;
             }
 
-            static AutoReset<std::shared_ptr<ImFontAtlas>> s_fontAtlas;
+            static AutoReset<ImFontAtlas*> s_fontAtlas;
             void setFontAtlas(ImFontAtlas* fontAtlas) {
-                s_fontAtlas = std::unique_ptr<ImFontAtlas, void(*)(ImFontAtlas*)>(fontAtlas, IM_DELETE);
+                s_fontAtlas = fontAtlas;
             }
 
             static ImFont *s_boldFont = nullptr;
@@ -974,7 +1026,7 @@ namespace hex {
         }
 
         ImFontAtlas* getFontAtlas() {
-            return impl::s_fontAtlas->get();
+            return impl::s_fontAtlas;
         }
 
         ImFont* Bold() {

lib/libimhex/source/api/layout_manager.cpp

@@ -1,13 +1,15 @@
 #include <hex/api/layout_manager.hpp>
 
+#include <hex/api/content_registry.hpp>
+#include <hex/ui/view.hpp>
 #include <hex/helpers/fs.hpp>
 #include <hex/helpers/logger.hpp>
 #include <hex/helpers/auto_reset.hpp>
+#include <hex/helpers/default_paths.hpp>
+
 #include <wolv/utils/string.hpp>
 
 #include <imgui.h>
-#include <hex/api/content_registry.hpp>
-#include <hex/ui/view.hpp>
 
 namespace hex {
 
@@ -40,10 +42,7 @@ namespace hex {
         fileName += ".hexlyt";
 
         std::fs::path layoutPath;
-        for (const auto &path : hex::fs::getDefaultPaths(fs::ImHexPath::Layouts)) {
-            if (!hex::fs::isPathWritable(layoutPath))
-                continue;
-
+        for (const auto &path : paths::Layouts.write()) {
             layoutPath = path / fileName;
         }
 
@@ -109,7 +108,7 @@ namespace hex {
     void LayoutManager::reload() {
         s_layouts->clear();
 
-        for (const auto &directory : hex::fs::getDefaultPaths(fs::ImHexPath::Layouts)) {
+        for (const auto &directory : paths::Layouts.read()) {
             for (const auto &entry : std::fs::directory_iterator(directory)) {
                 const auto &path = entry.path();
 

lib/libimhex/source/api/plugin_manager.cpp

@@ -5,6 +5,7 @@
 #include <hex/helpers/fmt.hpp>
 #include <hex/helpers/auto_reset.hpp>
 #include <hex/helpers/utils.hpp>
+#include <hex/helpers/default_paths.hpp>
 
 #include <wolv/utils/string.hpp>
 
@@ -306,7 +307,7 @@ namespace hex {
 
     bool PluginManager::loadLibraries() {
         bool success = true;
-        for (const auto &loadPath : fs::getDefaultPaths(fs::ImHexPath::Libraries))
+        for (const auto &loadPath : paths::Libraries.read())
             success = PluginManager::loadLibraries(loadPath) && success;
 
         return success;

lib/libimhex/source/api/task_manager.cpp

@@ -443,7 +443,7 @@ namespace hex {
             static auto setThreadDescription = reinterpret_cast<SetThreadDescriptionFunc>(
                 reinterpret_cast<uintptr_t>(
                     ::GetProcAddress(
-                        ::GetModuleHandle("Kernel32.dll"),
+                        ::GetModuleHandleW(L"Kernel32.dll"),
                         "SetThreadDescription"
                     )
                 )

lib/libimhex/source/api/tutorial_manager.cpp

@@ -21,6 +21,11 @@ namespace hex {
         AutoReset<std::map<ImGuiID, std::string>> s_highlights;
         AutoReset<std::vector<std::pair<ImRect, std::string>>> s_highlightDisplays;
 
+        AutoReset<std::map<ImGuiID, std::function<void()>>> s_interactiveHelpItems;
+        ImRect s_hoveredRect;
+        ImGuiID s_hoveredId;
+        bool s_helpHoverActive = false;
+
 
         class IDStack {
         public:
@@ -56,8 +61,42 @@ namespace hex {
             ImVector<ImGuiID> idStack;
         };
 
+        ImGuiID calculateId(const auto &ids) {
+            IDStack idStack;
+
+            for (const auto &id : ids) {
+                std::visit(wolv::util::overloaded {
+                        [&idStack](const Lang &id) {
+                            idStack.add(id.get());
+                        },
+                        [&idStack](const auto &id) {
+                            idStack.add(id);
+                        }
+                }, id);
+            }
+
+            return idStack.get();
+        }
+
     }
 
+    void TutorialManager::init() {
+        EventImGuiElementRendered::subscribe([](ImGuiID id, const std::array<float, 4> bb){
+            const auto boundingBox = ImRect(bb[0], bb[1], bb[2], bb[3]);
+
+            const auto element = hex::s_highlights->find(id);
+            if (element != hex::s_highlights->end()) {
+                hex::s_highlightDisplays->emplace_back(boundingBox, element->second);
+            }
+
+            if (id != 0 && boundingBox.Contains(ImGui::GetMousePos())) {
+                if ((s_hoveredRect.GetArea() == 0 || boundingBox.GetArea() < s_hoveredRect.GetArea()) && s_interactiveHelpItems->contains(id)) {
+                    s_hoveredRect = boundingBox;
+                    s_hoveredId = id;
+                }
+            }
+        });
+    }
 
     const std::map<std::string, TutorialManager::Tutorial>& TutorialManager::getTutorials() {
         return s_tutorials;
@@ -72,6 +111,28 @@ namespace hex {
         return s_tutorials->try_emplace(unlocalizedName, Tutorial(unlocalizedName, unlocalizedDescription)).first->second;
     }
 
+    void TutorialManager::startHelpHover() {
+        TaskManager::doLater([]{
+            s_helpHoverActive = true;
+        });
+    }
+
+    void TutorialManager::addInteractiveHelpText(std::initializer_list<std::variant<Lang, std::string, int>> &&ids, UnlocalizedString text) {
+        auto id = calculateId(ids);
+
+        s_interactiveHelpItems->emplace(id, [text = std::move(text)]{
+            log::info("{}", Lang(text).get());
+        });
+    }
+
+    void TutorialManager::addInteractiveHelpLink(std::initializer_list<std::variant<Lang, std::string, int>> &&ids, std::string link) {
+        auto id = calculateId(ids);
+
+        s_interactiveHelpItems->emplace(id, [link = std::move(link)]{
+            hex::openWebpage(link);
+        });
+    }
+
     void TutorialManager::startTutorial(const UnlocalizedString &unlocalizedName) {
         s_currentTutorial = s_tutorials->find(unlocalizedName);
         if (s_currentTutorial == s_tutorials->end())
@@ -81,6 +142,30 @@ namespace hex {
     }
 
     void TutorialManager::drawHighlights() {
+        if (s_helpHoverActive) {
+            const auto &drawList = ImGui::GetForegroundDrawList();
+            drawList->AddText(ImGui::GetMousePos() + scaled({ 10, -5, }), ImGui::GetColorU32(ImGuiCol_Text), "?");
+
+            const bool mouseClicked = ImGui::IsMouseClicked(ImGuiMouseButton_Left);
+            if (s_hoveredId != 0) {
+                drawList->AddRectFilled(s_hoveredRect.Min, s_hoveredRect.Max, 0x30FFFFFF);
+
+                if (mouseClicked) {
+                    auto it = s_interactiveHelpItems->find(s_hoveredId);
+                    if (it != s_interactiveHelpItems->end()) {
+                        it->second();
+                    }
+                }
+
+                s_hoveredId = 0;
+                s_hoveredRect = {};
+            }
+
+            if (mouseClicked || ImGui::IsKeyPressed(ImGuiKey_Escape)) {
+                s_helpHoverActive = false;
+            }
+        }
+
         for (const auto &[rect, unlocalizedText] : *s_highlightDisplays) {
             const auto drawList = ImGui::GetForegroundDrawList();
 
@@ -241,39 +326,13 @@ namespace hex {
             m_onAppear();
 
         for (const auto &[text, ids] : m_highlights) {
-            IDStack idStack;
-
-            for (const auto &id : ids) {
-                std::visit(wolv::util::overloaded {
-                    [&idStack](const Lang &id) {
-                        idStack.add(id.get());
-                    },
-                    [&idStack](const auto &id) {
-                        idStack.add(id);
-                    }
-                }, id);
-            }
-
-            s_highlights->emplace(idStack.get(), text);
+            s_highlights->emplace(calculateId(ids), text);
         }
     }
 
     void TutorialManager::Tutorial::Step::removeHighlights() const {
         for (const auto &[text, ids] : m_highlights) {
-            IDStack idStack;
-
-            for (const auto &id : ids) {
-                std::visit(wolv::util::overloaded {
-                    [&idStack](const Lang &id) {
-                        idStack.add(id.get());
-                    },
-                    [&idStack](const auto &id) {
-                        idStack.add(id);
-                    }
-                }, id);
-            }
-
-            s_highlights->erase(idStack.get());
+            s_highlights->erase(calculateId(ids));
         }
     }
 
@@ -368,15 +427,4 @@ namespace hex {
         }
     }
 
-}
-
-void ImGuiTestEngineHook_ItemAdd(ImGuiContext*, ImGuiID id, const ImRect& bb, const ImGuiLastItemData*) {
-    const auto element = hex::s_highlights->find(id);
-    if (element != hex::s_highlights->end()) {
-        hex::s_highlightDisplays->emplace_back(bb, element->second);
-    }
-}
-
-void ImGuiTestEngineHook_ItemInfo(ImGuiContext*, ImGuiID, const char*, ImGuiItemStatusFlags) {}
-void ImGuiTestEngineHook_Log(ImGuiContext*, const char*, ...) {}
-const char* ImGuiTestEngine_FindItemDebugLabel(ImGuiContext*, ImGuiID) { return nullptr; }
+}

lib/libimhex/source/api/workspace_manager.cpp

@@ -3,6 +3,7 @@
 
 #include <hex/helpers/logger.hpp>
 #include <hex/helpers/auto_reset.hpp>
+#include <hex/helpers/default_paths.hpp>
 
 #include <wolv/io/file.hpp>
 
@@ -25,7 +26,7 @@ namespace hex {
             .builtin = false
         }).first;
 
-        for (const auto &workspaceFolder : fs::getDefaultPaths(fs::ImHexPath::Workspaces)) {
+        for (const auto &workspaceFolder : paths::Workspaces.write()) {
             const auto workspacePath = workspaceFolder / (name + ".hexws");
             if (exportToFile(workspacePath)) {
                 s_currentWorkspace->second.path = workspacePath;
@@ -157,7 +158,7 @@ namespace hex {
     void WorkspaceManager::reload() {
         WorkspaceManager::reset();
 
-        for (const auto &defaultPath : fs::getDefaultPaths(fs::ImHexPath::Workspaces)) {
+        for (const auto &defaultPath : paths::Workspaces.read()) {
             for (const auto &entry : std::fs::directory_iterator(defaultPath)) {
                 if (!entry.is_regular_file()) {
                     continue;

lib/libimhex/source/helpers/default_paths.cpp

@@ -0,0 +1,153 @@
+#include <hex/helpers/default_paths.hpp>
+
+#include <hex/api/imhex_api.hpp>
+#include <hex/api/project_file_manager.hpp>
+
+#if defined(OS_WINDOWS)
+    #include <windows.h>
+    #include <shlobj.h>
+#elif defined(OS_LINUX) || defined(OS_WEB)
+    #include <xdg.hpp>
+# endif
+
+namespace hex::paths {
+
+    std::vector<std::fs::path> getDataPaths(bool includeSystemFolders) {
+        std::vector<std::fs::path> paths;
+
+        #if defined(OS_WINDOWS)
+
+            // In the portable Windows version, we just use the executable directory
+            // Prevent the use of the AppData folder here
+            if (!ImHexApi::System::isPortableVersion()) {
+                PWSTR wAppDataPath = nullptr;
+                if (SUCCEEDED(SHGetKnownFolderPath(FOLDERID_LocalAppData, KF_FLAG_CREATE, nullptr, &wAppDataPath))) {
+                    paths.emplace_back(wAppDataPath);
+                    CoTaskMemFree(wAppDataPath);
+                }
+            }
+
+        #elif defined(OS_MACOS)
+
+            paths.push_back(wolv::io::fs::getApplicationSupportDirectoryPath());
+
+        #elif defined(OS_LINUX) || defined(OS_WEB)
+
+            paths.push_back(xdg::DataHomeDir());
+
+            auto dataDirs = xdg::DataDirs();
+            std::copy(dataDirs.begin(), dataDirs.end(), std::back_inserter(paths));
+
+        #endif
+
+        #if defined(OS_MACOS)
+
+            if (includeSystemFolders) {
+                if (auto executablePath = wolv::io::fs::getExecutablePath(); executablePath.has_value()) {
+                    paths.push_back(*executablePath);
+                }
+            }
+
+        #else
+
+            for (auto &path : paths)
+                path = path / "imhex";
+
+            if (ImHexApi::System::isPortableVersion() || includeSystemFolders) {
+                if (auto executablePath = wolv::io::fs::getExecutablePath(); executablePath.has_value())
+                    paths.push_back(executablePath->parent_path());
+            }
+
+        #endif
+
+
+        // Add additional data directories to the path
+        auto additionalDirs = ImHexApi::System::getAdditionalFolderPaths();
+        std::ranges::copy(additionalDirs, std::back_inserter(paths));
+
+        // Add the project file directory to the path, if one is loaded
+        if (ProjectFile::hasPath()) {
+            paths.push_back(ProjectFile::getPath().parent_path());
+        }
+
+        return paths;
+    }
+
+    std::vector<std::fs::path> getConfigPaths(bool includeSystemFolders) {
+        #if defined(OS_WINDOWS)
+            return getDataPaths(includeSystemFolders);
+        #elif defined(OS_MACOS)
+            return getDataPaths(includeSystemFolders);
+        #elif defined(OS_LINUX) || defined(OS_WEB)
+            hex::unused(includeSystemFolders);
+            return {xdg::ConfigHomeDir() / "imhex"};
+        #endif
+    }
+
+    static std::vector<std::fs::path> appendPath(std::vector<std::fs::path> paths, std::fs::path folder) {
+        folder.make_preferred();
+        
+        for (auto &path : paths)
+            path = path / folder;
+
+        return paths;
+    }
+
+    static std::vector<std::fs::path> getPluginPaths() {
+        std::vector<std::fs::path> paths = getDataPaths(true);
+
+        // Add the system plugin directory to the path if one was provided at compile time
+        #if defined(OS_LINUX) && defined(SYSTEM_PLUGINS_LOCATION)
+            paths.push_back(SYSTEM_PLUGINS_LOCATION);
+        #endif
+
+        return paths;
+    }
+
+    namespace impl {
+
+        std::vector<std::fs::path> DefaultPath::read() const {
+            auto result = this->all();
+
+            std::erase_if(result, [](const auto &entryPath) {
+                return !wolv::io::fs::isDirectory(entryPath);
+            });
+
+            return result;
+        }
+
+        std::vector<std::fs::path> DefaultPath::write() const {
+            auto result = this->read();
+
+            std::erase_if(result, [](const auto &entryPath) {
+                return !hex::fs::isPathWritable(entryPath);
+            });
+
+            return result;
+        }
+
+        std::vector<std::fs::path> ConfigPath::all() const {
+            return appendPath(getConfigPaths(false), m_postfix);
+        }
+
+        std::vector<std::fs::path> DataPath::all() const {
+            return appendPath(getDataPaths(true), m_postfix);
+        }
+
+        std::vector<std::fs::path> DataPath::write() const {
+            auto result = appendPath(getDataPaths(false), m_postfix);
+
+            std::erase_if(result, [](const auto &entryPath) {
+                return !hex::fs::isPathWritable(entryPath);
+            });
+
+            return result;
+        }
+
+        std::vector<std::fs::path> PluginPath::all() const {
+            return appendPath(getPluginPaths(), m_postfix);
+        }
+
+    }
+
+}

lib/libimhex/source/helpers/fs.cpp

@@ -24,6 +24,37 @@
     #include <emscripten.h>
 #else
     #include <nfd.hpp>
+    #if defined(OS_WINDOWS)
+        #define GLFW_EXPOSE_NATIVE_WIN32
+    #endif
+    #if defined(OS_MACOS)
+        // macOS platform headers can't be compiled with gcc
+        #define GLFW_NATIVE_INCLUDE_NONE
+        typedef uint32_t CGDirectDisplayID;
+        typedef void *id;
+        typedef void NSWindow;
+        #define GLFW_EXPOSE_NATIVE_COCOA
+    #endif
+    #if defined(OS_LINUX)
+        #define GLFW_EXPOSE_NATIVE_X11
+    #endif
+    #if defined(OS_LINUX) && defined(GLFW_WAYLAND_APP_ID)
+        #define GLFW_EXPOSE_NATIVE_WAYLAND
+    #endif
+    #include <nfd_glfw3.h>
+    #if defined(OS_LINUX) && defined(GLFW_WAYLAND_APP_ID)
+        #undef GLFW_EXPOSE_NATIVE_WAYLAND
+    #endif
+    #if defined(OS_LINUX)
+        #undef GLFW_EXPOSE_NATIVE_X11
+    #endif
+    #if defined(OS_MACOS)
+        #undef GLFW_EXPOSE_NATIVE_COCOA
+        #undef GLFW_NATIVE_INCLUDE_NONE
+    #endif
+    #if defined(OS_WINDOWS)
+        #undef GLFW_EXPOSE_NATIVE_WIN32
+    #endif
 #endif
 
 #include <filesystem>
@@ -32,6 +63,9 @@
 #include <wolv/io/fs.hpp>
 #include <wolv/utils/string.hpp>
 
+#include <fmt/format.h>
+#include <fmt/xchar.h>
+
 namespace hex::fs {
 
     static AutoReset<std::function<void(const std::string&)>> s_fileBrowserErrorCallback;
@@ -48,7 +82,7 @@ namespace hex::fs {
 
         #if defined(OS_WINDOWS)
             hex::unused(
-                ShellExecute(nullptr, "open", wolv::util::toUTF8String(filePath).c_str(), nullptr, nullptr, SW_SHOWNORMAL)
+                ShellExecuteW(nullptr, L"open", filePath.c_str(), nullptr, nullptr, SW_SHOWNORMAL)
             );
         #elif defined(OS_MACOS)
             hex::unused(system(
@@ -66,9 +100,8 @@ namespace hex::fs {
         }
 
         #if defined(OS_WINDOWS)
-            hex::unused(system(
-                hex::format("explorer.exe {}", wolv::util::toUTF8String(dirPath)).c_str()
-            ));
+            auto args = fmt::format(L"\"{}\"", dirPath.c_str());
+            ShellExecuteW(nullptr, L"open", L"explorer.exe", args.c_str(), nullptr, SW_SHOWNORMAL);
         #elif defined(OS_MACOS)
             hex::unused(system(
                 hex::format("open {}", wolv::util::toUTF8String(dirPath)).c_str()
@@ -85,9 +118,8 @@ namespace hex::fs {
         }
 
         #if defined(OS_WINDOWS)
-            hex::unused(system(
-                hex::format(R"(explorer.exe /select,"{}")", wolv::util::toUTF8String(selectedFilePath)).c_str()
-            ));
+            auto args = fmt::format(L"/select,\"{}\"", selectedFilePath.c_str());
+            ShellExecuteW(nullptr, L"open", L"explorer.exe", args.c_str(), nullptr, SW_SHOWNORMAL);
         #elif defined(OS_MACOS)
             hex::unused(system(
                 hex::format(
@@ -232,20 +264,22 @@ namespace hex::fs {
             NFD::UniquePathU8 outPath;
             NFD::UniquePathSet outPaths;
             nfdresult_t result = NFD_ERROR;
+            nfdwindowhandle_t nativeWindow{};
+            NFD_GetNativeWindowFromGLFWWindow(ImHexApi::System::getMainWindowHandle(), &nativeWindow);
 
             // Open the correct file dialog based on the mode
             switch (mode) {
                 case DialogMode::Open:
                     if (multiple)
-                        result = NFD::OpenDialogMultiple(outPaths, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str());
+                        result = NFD::OpenDialogMultiple(outPaths, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str(), nativeWindow);
                     else
-                        result = NFD::OpenDialog(outPath, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str());
+                        result = NFD::OpenDialog(outPath, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str(), nativeWindow);
                     break;
                 case DialogMode::Save:
-                    result = NFD::SaveDialog(outPath, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str());
+                    result = NFD::SaveDialog(outPath, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str(), nullptr, nativeWindow);
                     break;
                 case DialogMode::Folder:
-                    result = NFD::PickFolder(outPath, defaultPath.empty() ? nullptr : defaultPath.c_str());
+                    result = NFD::PickFolder(outPath, defaultPath.empty() ? nullptr : defaultPath.c_str(), nativeWindow);
                     break;
             }
 
@@ -286,170 +320,6 @@ namespace hex::fs {
 
     #endif
 
-    std::vector<std::fs::path> getDataPaths() {
-        std::vector<std::fs::path> paths;
-
-        #if defined(OS_WINDOWS)
-
-            // In the portable Windows version, we just use the executable directory
-            // Prevent the use of the AppData folder here
-            if (!ImHexApi::System::isPortableVersion()) {
-                PWSTR wAppDataPath = nullptr;
-                if (SUCCEEDED(SHGetKnownFolderPath(FOLDERID_LocalAppData, KF_FLAG_CREATE, nullptr, &wAppDataPath))) {
-                    paths.emplace_back(wAppDataPath);
-                    CoTaskMemFree(wAppDataPath);
-                }
-            }
-
-        #elif defined(OS_MACOS)
-
-            paths.push_back(wolv::io::fs::getApplicationSupportDirectoryPath());
-
-        #elif defined(OS_LINUX) || defined(OS_WEB)
-
-            paths.push_back(xdg::DataHomeDir());
-
-            auto dataDirs = xdg::DataDirs();
-            std::copy(dataDirs.begin(), dataDirs.end(), std::back_inserter(paths));
-
-        #endif
-
-        #if defined(OS_MACOS)
-
-            if (auto executablePath = wolv::io::fs::getExecutablePath(); executablePath.has_value())
-                paths.push_back(*executablePath);
-
-        #else
-
-            for (auto &path : paths)
-                path = path / "imhex";
-
-            if (auto executablePath = wolv::io::fs::getExecutablePath(); executablePath.has_value())
-                paths.push_back(executablePath->parent_path());
-
-        #endif
-
-
-        // Add additional data directories to the path
-        auto additionalDirs = ImHexApi::System::getAdditionalFolderPaths();
-        std::ranges::copy(additionalDirs, std::back_inserter(paths));
-
-        // Add the project file directory to the path, if one is loaded
-        if (ProjectFile::hasPath()) {
-            paths.push_back(ProjectFile::getPath().parent_path());
-        }
-
-        return paths;
-    }
-
-    static std::vector<std::fs::path> getConfigPaths() {
-        #if defined(OS_WINDOWS)
-            return getDataPaths();
-        #elif defined(OS_MACOS)
-            return getDataPaths();
-        #elif defined(OS_LINUX) || defined(OS_WEB)
-            return {xdg::ConfigHomeDir() / "imhex"};
-        #endif
-    }
-
-    std::vector<std::fs::path> appendPath(std::vector<std::fs::path> paths, const std::fs::path &folder) {
-        for (auto &path : paths)
-            path = path / folder;
-
-        return paths;
-    }
-
-    std::vector<std::fs::path> getPluginPaths() {
-        std::vector<std::fs::path> paths = getDataPaths();
-
-        // Add the system plugin directory to the path if one was provided at compile time
-        #if defined(OS_LINUX) && defined(SYSTEM_PLUGINS_LOCATION)
-            paths.push_back(SYSTEM_PLUGINS_LOCATION);
-        #endif
-
-        return paths;
-    }
-
-
-    std::vector<std::fs::path> getDefaultPaths(ImHexPath path, bool listNonExisting) {
-        std::vector<std::fs::path> result;
-
-        // Return the correct path based on the ImHexPath enum
-        switch (path) {
-            case ImHexPath::END:
-                return { };
-            case ImHexPath::Constants:
-                result = appendPath(getDataPaths(), "constants");
-                break;
-            case ImHexPath::Config:
-                result = appendPath(getConfigPaths(), "config");
-                break;
-            case ImHexPath::Backups:
-                result = appendPath(getDataPaths(), "backups");
-                break;
-            case ImHexPath::Encodings:
-                result = appendPath(getDataPaths(), "encodings");
-                break;
-            case ImHexPath::Logs:
-                result = appendPath(getDataPaths(), "logs");
-                break;
-            case ImHexPath::Plugins:
-                result = appendPath(getPluginPaths(), "plugins");
-                break;
-            case ImHexPath::Libraries:
-                result = appendPath(getPluginPaths(), "lib");
-                break;
-            case ImHexPath::Resources:
-                result = appendPath(getDataPaths(), "resources");
-                break;
-            case ImHexPath::Magic:
-                result = appendPath(getDataPaths(), "magic");
-                break;
-            case ImHexPath::Patterns:
-                result = appendPath(getDataPaths(), "patterns");
-                break;
-            case ImHexPath::PatternsInclude:
-                result = appendPath(getDataPaths(), "includes");
-                break;
-            case ImHexPath::Yara:
-                result = appendPath(getDataPaths(), "yara");
-                break;
-            case ImHexPath::YaraAdvancedAnalysis:
-                result = appendPath(getDefaultPaths(ImHexPath::Yara), "advanced_analysis");
-                break;
-            case ImHexPath::Recent:
-                result = appendPath(getConfigPaths(), "recent");
-                break;
-            case ImHexPath::Scripts:
-                result = appendPath(getDataPaths(), "scripts");
-                break;
-            case ImHexPath::Inspectors:
-                result = appendPath(getDefaultPaths(ImHexPath::Scripts), "inspectors");
-                break;
-            case ImHexPath::Nodes:
-                result = appendPath(getDefaultPaths(ImHexPath::Scripts), "nodes");
-                break;
-            case ImHexPath::Themes:
-                result = appendPath(getDataPaths(), "themes");
-                break;
-            case ImHexPath::Layouts:
-                result = appendPath(getDataPaths(), "layouts");
-                break;
-            case ImHexPath::Workspaces:
-                result = appendPath(getDataPaths(), "workspaces");
-                break;
-        }
-
-        // Remove all paths that don't exist if requested
-        if (!listNonExisting) {
-            std::erase_if(result, [](const auto &entryPath) {
-                return !wolv::io::fs::isDirectory(entryPath);
-            });
-        }
-
-        return result;
-    }
-
     bool isPathWritable(const std::fs::path &path) {
         constexpr static auto TestFileName = "__imhex__tmp__";
 

lib/libimhex/source/helpers/imgui_hooks.cpp

@@ -0,0 +1,15 @@
+#include <hex/api/event_manager.hpp>
+
+#include <imgui.h>
+#include <imgui_internal.h>
+
+#include <array>
+
+void ImGuiTestEngineHook_ItemAdd(ImGuiContext*, ImGuiID id, const ImRect& bb, const ImGuiLastItemData*) {
+    std::array<float, 4> boundingBox = { bb.Min.x, bb.Min.y, bb.Max.x, bb.Max.y };
+    hex::EventImGuiElementRendered::post(id, boundingBox);
+}
+
+void ImGuiTestEngineHook_ItemInfo(ImGuiContext*, ImGuiID, const char*, ImGuiItemStatusFlags) {}
+void ImGuiTestEngineHook_Log(ImGuiContext*, const char*, ...) {}
+const char* ImGuiTestEngine_FindItemDebugLabel(ImGuiContext*, ImGuiID) { return nullptr; }

lib/libimhex/source/helpers/logger.cpp

@@ -2,8 +2,10 @@
 
 #include <hex/api/task_manager.hpp>
 #include <hex/api/event_manager.hpp>
+
 #include <hex/helpers/fs.hpp>
 #include <hex/helpers/fmt.hpp>
+#include <hex/helpers/default_paths.hpp>
 
 #include <wolv/io/file.hpp>
 
@@ -80,7 +82,7 @@ namespace hex::log {
         void redirectToFile() {
             if (s_loggerFile.isValid()) return;
 
-            for (const auto &path : fs::getDefaultPaths(fs::ImHexPath::Logs, true)) {
+            for (const auto &path : paths::Logs.all()) {
                 wolv::io::fs::createDirectories(path);
                 s_loggerFile = wolv::io::File(path / hex::format("{0:%Y%m%d_%H%M%S}.log", fmt::localtime(std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()))), wolv::io::File::Mode::Create);
                 s_loggerFile.disableBuffering();
@@ -142,14 +144,12 @@ namespace hex::log {
             fmt::print(dest, "{0}", std::string(projectNameLength > MaxTagLength ? 0 : MaxTagLength - projectNameLength, ' '));
         }
 
-        void assertionHandler(bool expr, const char* exprString, const char* file, int line) {
-            if (!expr) {
-                log::error("Assertion failed: {} at {}:{}", exprString, file, line);
+        void assertionHandler(const char* exprString, const char* file, int line) {
+            log::error("Assertion failed: {} at {}:{}", exprString, file, line);
 
-                #if defined (DEBUG)
-                    std::abort();
-                #endif
-            }
+            #if defined (DEBUG)
+                std::abort();
+            #endif
         }
 
         namespace color {

lib/libimhex/source/helpers/magic.cpp

@@ -3,6 +3,7 @@
 #include <hex/helpers/utils.hpp>
 #include <hex/helpers/fs.hpp>
 #include <hex/helpers/logger.hpp>
+#include <hex/helpers/default_paths.hpp>
 
 #include <wolv/utils/guards.hpp>
 #include <wolv/utils/string.hpp>
@@ -29,7 +30,7 @@ namespace hex::magic {
         std::string magicFiles;
 
         std::error_code error;
-        for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Magic)) {
+        for (const auto &dir : paths::Magic.read()) {
             for (const auto &entry : std::fs::directory_iterator(dir, error)) {
                 auto path = std::fs::absolute(entry.path());
 
@@ -64,12 +65,12 @@ namespace hex::magic {
         if (magicFiles->empty())
             return true;
 
-        std::array<char, 1024> cwd = { 0x00 };
+        std::array<char, 1024> cwd = { };
         if (getcwd(cwd.data(), cwd.size()) == nullptr)
             return false;
 
         std::optional<std::fs::path> magicFolder;
-        for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Magic)) {
+        for (const auto &dir : paths::Magic.write()) {
             if (std::fs::exists(dir) && fs::isPathWritable(dir)) {
                 magicFolder = dir;
                 break;

lib/libimhex/source/helpers/utils.cpp

@@ -355,7 +355,7 @@ namespace hex {
             url = "https://" + url;
 
         #if defined(OS_WINDOWS)
-            ShellExecute(nullptr, "open", url.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
+            ShellExecuteA(nullptr, "open", url.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
         #elif defined(OS_MACOS)
             openWebpageMacos(url.c_str());
         #elif defined(OS_LINUX)
@@ -679,6 +679,44 @@ namespace hex {
             return value;
     }
 
+    [[nodiscard]] std::string limitStringLength(const std::string &string, size_t maxLength) {
+        // If the string is shorter than the max length, return it as is
+        if (string.size() < maxLength)
+            return string;
+
+        // If the string is longer than the max length, find the last space before the max length
+        auto it = string.begin() + maxLength / 2;
+        while (it != string.begin() && !std::isspace(*it)) --it;
+
+        // If there's no space before the max length, just cut the string
+        if (it == string.begin()) {
+            it = string.begin() + maxLength / 2;
+
+            // Try to find a UTF-8 character boundary
+            while (it != string.begin() && (*it & 0xC0) == 0x80) --it;
+        }
+
+        // If we still didn't find a valid boundary, just return the string as is
+        if (it == string.begin())
+            return string;
+
+        auto result = std::string(string.begin(), it) + "…";
+
+        // If the string is longer than the max length, find the last space before the max length
+        it = string.end() - 1 - maxLength / 2;
+        while (it != string.end() && !std::isspace(*it)) ++it;
+
+        // If there's no space before the max length, just cut the string
+        if (it == string.end()) {
+            it = string.end() - 1 - maxLength / 2;
+
+            // Try to find a UTF-8 character boundary
+            while (it != string.end() && (*it & 0xC0) == 0x80) ++it;
+        }
+
+        return result + std::string(it, string.end());
+    }
+
     static std::optional<std::fs::path> s_fileToOpen;
     extern "C" void openFile(const char *path) {
         log::info("Opening file: {0}", path);

lib/libimhex/source/helpers/utils_macos.m

@@ -118,6 +118,12 @@
         return cocoaWindow.inLiveResize;
     }
 
+    void macosMarkContentEdited(GLFWwindow *window, bool edited) {
+        NSWindow* cocoaWindow = glfwGetCocoaWindow(window);
+
+        [cocoaWindow setDocumentEdited:edited];
+    }
+
     @interface HexDocument : NSDocument
 
     @end

lib/libimhex/source/subcommands/subcommands.cpp

@@ -20,6 +20,7 @@ namespace hex::subcommands {
                 }
             }
         }
+
         return std::nullopt;
     }
 
@@ -27,7 +28,8 @@ namespace hex::subcommands {
         // If no arguments, do not even try to process arguments
         // (important because this function will exit ImHex if an instance is already opened,
         // and we don't want that if no arguments were provided)
-        if (args.empty()) return;
+        if (args.empty())
+            return;
 
         std::vector<std::pair<SubCommand, std::vector<std::string>>> subCommands;
 
@@ -76,18 +78,18 @@ namespace hex::subcommands {
         }
 
         // Save last command to run
-        if (currentSubCommand) {
+        if (currentSubCommand.has_value()) {
             subCommands.emplace_back(*currentSubCommand, currentSubCommandArgs);
         }
 
         // Run the subcommands
-        for (auto& subCommandPair : subCommands) {
-            subCommandPair.first.callback(subCommandPair.second);
+        for (auto &[subcommand, args] : subCommands) {
+            subcommand.callback(args);
         }
 
-        // Exit the process if its not the main instance (the commands have been forwarded to another instance)
+        // Exit the process if it's not the main instance (the commands have been forwarded to another instance)
         if (!ImHexApi::System::isMainInstance()) {
-            exit(0);
+            std::exit(0);
         }
     }
 
@@ -95,12 +97,15 @@ namespace hex::subcommands {
         log::debug("Forwarding subcommand {} (maybe to us)", cmdName);
 
         std::vector<u8> data;
-        for (const auto &arg: args) {
-            data.insert(data.end(), arg.begin(), arg.end());
-            data.push_back('\0');
+        if (!args.empty()) {
+            for (const auto &arg: args) {
+                data.insert(data.end(), arg.begin(), arg.end());
+                data.push_back('\0');
+            }
+
+            data.pop_back();
         }
-        data.erase(data.end()-1);
-        
+
         SendMessageToMainInstance::post(hex::format("command/{}", cmdName), data);
     }
 

lib/libimhex/source/ui/imgui_imhex_extensions.cpp

@@ -285,6 +285,10 @@ namespace ImGuiExt {
         glDeleteTextures(1, reinterpret_cast<GLuint*>(&m_textureId));
     }
 
+    float GetTextWrapPos() {
+        return GImGui->CurrentWindow->DC.TextWrapPos;
+    }
+
     int UpdateStringSizeCallback(ImGuiInputTextCallbackData *data) {
         if (data->EventFlag == ImGuiInputTextFlags_CallbackResize) {
             auto &string = *static_cast<std::string *>(data->UserData);
@@ -514,7 +518,7 @@ namespace ImGuiExt {
         PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
         PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0, 0, 0, 0));
         PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0, 0, 0, 0));
-        PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, GetStyle().FramePadding.y));
+        PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
         PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0F);
 
         PushStyleColor(ImGuiCol_Text, iconColor);
@@ -522,7 +526,7 @@ namespace ImGuiExt {
         PopStyleColor();
 
         if (IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
-            SetNextWindowSizeConstraints(ImVec2(GetTextLineHeight() * 25, 0), ImVec2(GetTextLineHeight() * 25, FLT_MAX));
+            SetNextWindowSizeConstraints(ImVec2(GetTextLineHeight() * 25, 0), ImVec2(GetTextLineHeight() * 35, FLT_MAX));
             BeginTooltip();
             TextFormattedWrapped("{}", text);
             EndTooltip();
@@ -571,15 +575,27 @@ namespace ImGuiExt {
         ImGuiID hoveredID = GetHoveredID();
 
         bool result = false;
-        if (IsItemHovered() && (currTime - lastMoveTime) >= 0.5 && hoveredID == lastHoveredID) {
+        if (IsItemHovered(ImGuiHoveredFlags_DelayNormal) && (currTime - lastMoveTime) >= 0.5 && hoveredID == lastHoveredID) {
             if (!std::string_view(text).empty()) {
-                const auto width = 300 * hex::ImHexApi::System::getGlobalScale();
-                ImGui::SetNextWindowSizeConstraints(ImVec2(width, 0), ImVec2(width, FLT_MAX));
+                const auto textWidth = CalcTextSize(text).x;
+
+                const auto maxWidth = 300 * hex::ImHexApi::System::getGlobalScale();
+                const bool wrapping = textWidth > maxWidth;
+
+                if (wrapping)
+                    ImGui::SetNextWindowSizeConstraints(ImVec2(maxWidth, 0), ImVec2(maxWidth, FLT_MAX));
+                else
+                    ImGui::SetNextWindowSize(ImVec2(textWidth + GetStyle().WindowPadding.x * 2, 0));
+
                 if (BeginTooltip()) {
                     if (isSeparator)
                         SeparatorText(text);
-                    else
-                        TextFormattedWrapped("{}", text);
+                    else {
+                        if (wrapping)
+                            TextFormattedWrapped("{}", text);
+                        else
+                            TextFormatted("{}", text);
+                    }
 
                     EndTooltip();
                 }
@@ -752,7 +768,9 @@ namespace ImGuiExt {
 
         ImVec2 pos = window->DC.CursorPos;
 
-        ImVec2 size = CalcItemSize(ImVec2(1, 1) * GetCurrentWindow()->MenuBarHeight(), label_size.x + style.FramePadding.x * 2.0F, label_size.y + style.FramePadding.y * 2.0F);
+        ImVec2 size = CalcItemSize(ImVec2(1, 1) * GetCurrentWindow()->MenuBarHeight, label_size.x + style.FramePadding.x * 2.0F, label_size.y + style.FramePadding.y * 2.0F);
+
+        ImVec2 padding = (size - label_size) / 2;
 
         const ImRect bb(pos, pos + size);
         ItemSize(size, style.FramePadding.y);
@@ -769,7 +787,7 @@ namespace ImGuiExt {
                                                                                                  : ImGuiCol_MenuBarBg);
         RenderNavHighlight(bb, id);
         RenderFrame(bb.Min, bb.Max, col, false, style.FrameRounding);
-        RenderTextClipped(bb.Min + style.FramePadding, bb.Max - style.FramePadding, symbol, nullptr, &label_size, style.ButtonTextAlign, &bb);
+        RenderTextClipped(bb.Min + padding, bb.Max - padding, symbol, nullptr, &size, style.ButtonTextAlign, &bb);
 
         PopStyleColor();
 
@@ -945,7 +963,7 @@ namespace ImGuiExt {
 
         SetCursorPosX(GetCursorPosX() + frame_size.x);
 
-        bool value_changed = InputTextEx(label, nullptr, buffer.data(), buffer.size() + 1, ImVec2(CalcItemWidth() - icon_frame_size.x, label_size.y + style.FramePadding.y * 2.0F), ImGuiInputTextFlags_CallbackResize | flags, UpdateStringSizeCallback, &buffer);
+        bool value_changed = InputTextEx(label, nullptr, buffer.data(), buffer.size() + 1, ImVec2(CalcItemWidth(), label_size.y + style.FramePadding.y * 2.0F), ImGuiInputTextFlags_CallbackResize | flags, UpdateStringSizeCallback, &buffer);
 
         if (value_changed)
             MarkItemEdited(GImGui->LastItemData.ID);
@@ -1156,17 +1174,37 @@ namespace ImGuiExt {
         PopStyleVar();
     }
 
-    void BeginSubWindow(const char *label, ImVec2 size, ImGuiChildFlags flags) {
+    bool BeginSubWindow(const char *label, bool *collapsed, ImVec2 size, ImGuiChildFlags flags) {
         const bool hasMenuBar = !std::string_view(label).empty();
 
+        bool result = false;
         ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 5.0F);
         if (ImGui::BeginChild(hex::format("{}##SubWindow", label).c_str(), size, ImGuiChildFlags_Border | ImGuiChildFlags_AutoResizeY | flags, hasMenuBar ? ImGuiWindowFlags_MenuBar : ImGuiWindowFlags_None)) {
+            result = true;
+
             if (hasMenuBar && ImGui::BeginMenuBar()) {
-                ImGui::TextUnformatted(label);
+                if (collapsed == nullptr)
+                    ImGui::TextUnformatted(label);
+                else {
+                    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, ImGui::GetStyle().FramePadding.y));
+                    ImGui::PushStyleColor(ImGuiCol_Button, 0x00);
+                    if (ImGui::Button(label))
+                        *collapsed = !*collapsed;
+                    ImGui::PopStyleColor();
+                    ImGui::PopStyleVar();
+                }
                 ImGui::EndMenuBar();
             }
+
+            if (collapsed != nullptr && *collapsed) {
+                ImGui::SetCursorPosY(ImGui::GetCursorPosY() - (ImGui::GetStyle().FramePadding.y * 2));
+                ImGuiExt::TextFormattedDisabled("...");
+                result = false;
+            }
         }
         ImGui::PopStyleVar();
+
+        return result;
     }
 
     void EndSubWindow() {

lib/libimhex/source/ui/view.cpp

@@ -71,7 +71,7 @@ namespace hex {
     }
 
     std::string View::toWindowName(const UnlocalizedString &unlocalizedName) {
-        return Lang(unlocalizedName) + "###" + unlocalizedName.get();
+        return fmt::format("{}###{}", Lang(unlocalizedName), unlocalizedName.get());
     }
 
 }

lib/third_party/boost/CMakeLists.txt

@@ -0,0 +1,3 @@
+project(boost)
+
+add_subdirectory(regex)

lib/third_party/boost/regex/CMakeLists.txt

@@ -0,0 +1,10 @@
+project(boost-regex)
+
+add_library(boost-regex INTERFACE)
+
+target_include_directories(boost-regex INTERFACE
+    include
+)
+target_compile_definitions(boost-regex INTERFACE BOOST_REGEX_STANDALONE)
+
+add_library(boost::regex ALIAS boost-regex)

lib/third_party/boost/regex/include/boost/cregex.hpp

@@ -0,0 +1,43 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org/libs/regex for most recent version.
+  *   FILE         cregex.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares POSIX API functions
+  *                + boost::RegEx high level wrapper.
+  */
+
+#ifndef BOOST_RE_CREGEX_HPP
+#define BOOST_RE_CREGEX_HPP
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+
+#ifdef BOOST_REGEX_CXX03
+#include <boost/regex/v4/cregex.hpp>
+#else
+#include <boost/regex/v5/cregex.hpp>
+#endif
+
+#endif /* include guard */
+
+
+
+
+
+
+
+
+
+

lib/third_party/boost/regex/include/boost/regex.h

@@ -0,0 +1,100 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org/libs/regex for documentation.
+  *   FILE         regex.h
+  *   VERSION      3.12
+  *   DESCRIPTION: Declares POSIX API functions
+  */
+
+#ifndef BOOST_RE_REGEX_H
+#define BOOST_RE_REGEX_H
+
+#include <boost/cregex.hpp>
+
+/*
+*  add using declarations to bring POSIX API functions into
+* global scope, only if this is C++ (and not C).
+*/
+#ifdef __cplusplus
+
+using boost::regoff_t;
+using boost::regex_tA;
+using boost::regmatch_t;
+using boost::REG_BASIC;
+using boost::REG_EXTENDED;
+using boost::REG_ICASE;
+using boost::REG_NOSUB;
+using boost::REG_NEWLINE;
+using boost::REG_NOSPEC;
+using boost::REG_PEND;
+using boost::REG_DUMP;
+using boost::REG_NOCOLLATE;
+using boost::REG_ESCAPE_IN_LISTS;
+using boost::REG_NEWLINE_ALT;
+using boost::REG_PERL;
+using boost::REG_AWK;
+using boost::REG_GREP;
+using boost::REG_EGREP;
+using boost::REG_ASSERT;
+using boost::REG_INVARG;
+using boost::REG_ATOI;
+using boost::REG_ITOA;
+
+using boost::REG_NOTBOL;
+using boost::REG_NOTEOL;
+using boost::REG_STARTEND;
+
+using boost::reg_comp_flags;
+using boost::reg_exec_flags;
+using boost::regcompA;
+using boost::regerrorA;
+using boost::regexecA;
+using boost::regfreeA;
+
+#ifndef BOOST_NO_WREGEX
+using boost::regcompW;
+using boost::regerrorW;
+using boost::regexecW;
+using boost::regfreeW;
+using boost::regex_tW;
+#endif
+
+using boost::REG_NOERROR;
+using boost::REG_NOMATCH;
+using boost::REG_BADPAT;
+using boost::REG_ECOLLATE;
+using boost::REG_ECTYPE;
+using boost::REG_EESCAPE;
+using boost::REG_ESUBREG;
+using boost::REG_EBRACK;
+using boost::REG_EPAREN;
+using boost::REG_EBRACE;
+using boost::REG_BADBR;
+using boost::REG_ERANGE;
+using boost::REG_ESPACE;
+using boost::REG_BADRPT;
+using boost::REG_EEND;
+using boost::REG_ESIZE;
+using boost::REG_ERPAREN;
+using boost::REG_EMPTY;
+using boost::REG_E_MEMORY;
+using boost::REG_E_UNKNOWN;
+using boost::reg_errcode_t;
+
+#endif /* __cplusplus */
+
+#endif /* BOOST_RE_REGEX_H */
+
+
+
+

lib/third_party/boost/regex/include/boost/regex.hpp

@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org/libs/regex for documentation.
+  *   FILE         regex.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares boost::basic_regex<> and associated
+  *                functions and classes. This header is the main
+  *                entry point for the template regex code.
+  */
+
+
+/* start with C compatibility API */
+
+#ifndef BOOST_RE_REGEX_HPP
+#define BOOST_RE_REGEX_HPP
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+
+#ifdef BOOST_REGEX_CXX03
+#include <boost/regex/v4/regex.hpp>
+#else
+#include <boost/regex/v5/regex.hpp>
+#endif
+
+#endif  // include
+
+
+
+

lib/third_party/boost/regex/include/boost/regex/config.hpp

@@ -0,0 +1,480 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the
+ * Boost Software License, Version 1.0. (See accompanying file
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         config.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: regex extended config setup.
+  */
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#define BOOST_REGEX_CONFIG_HPP
+
+#if !((__cplusplus >= 201103L) || (defined(_MSC_VER) && (_MSC_VER >= 1600)) || defined(BOOST_REGEX_CXX03))
+#  define BOOST_REGEX_CXX03
+#endif
+
+#if defined(BOOST_REGEX_RECURSIVE) && !defined(BOOST_REGEX_CXX03)
+#  define BOOST_REGEX_CXX03
+#endif
+
+#if defined(__has_include)
+#if !defined(BOOST_REGEX_STANDALONE) && !__has_include(<boost/version.hpp>)
+#define BOOST_REGEX_STANDALONE
+#endif
+#endif
+
+/*
+ * Borland C++ Fix/error check
+ * this has to go *before* we include any std lib headers:
+ */
+#if defined(__BORLANDC__) && !defined(__clang__)
+#  include <boost/regex/config/borland.hpp>
+#endif
+#ifndef BOOST_REGEX_STANDALONE
+#include <boost/version.hpp>
+#endif
+
+/*************************************************************************
+*
+* Asserts:
+*
+*************************************************************************/
+
+#ifdef BOOST_REGEX_STANDALONE
+#include <cassert>
+#  define BOOST_REGEX_ASSERT(x) assert(x)
+#else
+#include <boost/assert.hpp>
+#  define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x)
+#endif
+
+/*****************************************************************************
+ *
+ *  Include all the headers we need here:
+ *
+ ****************************************************************************/
+
+#ifdef __cplusplus
+
+#  ifndef BOOST_REGEX_USER_CONFIG
+#     define BOOST_REGEX_USER_CONFIG <boost/regex/user.hpp>
+#  endif
+
+#  include BOOST_REGEX_USER_CONFIG
+
+#ifndef BOOST_REGEX_STANDALONE
+#  include <boost/config.hpp>
+#  include <boost/predef.h>
+#endif
+
+#else
+   /*
+    * C build,
+    * don't include <boost/config.hpp> because that may
+    * do C++ specific things in future...
+    */
+#  include <stdlib.h>
+#  include <stddef.h>
+#  ifdef _MSC_VER
+#     define BOOST_MSVC _MSC_VER
+#  endif
+#endif
+
+
+/****************************************************************************
+*
+* Legacy support:
+*
+*******************************************************************************/
+
+#if defined(BOOST_NO_STD_LOCALE) || defined(BOOST_NO_CXX11_HDR_MUTEX) || defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) \
+   || defined(BOOST_NO_CXX11_HDR_ATOMIC) || defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_CXX11_SMART_PTR) \
+   || defined(BOOST_NO_CXX11_STATIC_ASSERT) || defined(BOOST_NO_NOEXCEPT)
+#ifndef BOOST_REGEX_CXX03
+#  define BOOST_REGEX_CXX03
+#endif
+#endif
+
+/*****************************************************************************
+ *
+ *  Boilerplate regex config options:
+ *
+ ****************************************************************************/
+
+/* Obsolete macro, use BOOST_VERSION instead: */
+#define BOOST_RE_VERSION 500
+
+/* fix: */
+#if defined(_UNICODE) && !defined(UNICODE)
+#define UNICODE
+#endif
+
+#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y)
+#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y)
+#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y
+
+#ifdef BOOST_FALLTHROUGH
+#  define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH
+#else
+
+#if defined(__clang__) && (__cplusplus >= 201103L) && defined(__has_warning)
+#  if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+#    define BOOST_REGEX_FALLTHROUGH [[clang::fallthrough]]
+#  endif
+#endif
+#if !defined(BOOST_REGEX_FALLTHROUGH) && defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1800) && (__cplusplus >= 201703)
+#  define BOOST_REGEX_FALLTHROUGH [[fallthrough]]
+#endif
+#if !defined(BOOST_REGEX_FALLTHROUGH) && defined(__GNUC__) && (__GNUC__ >= 7)
+#  define BOOST_REGEX_FALLTHROUGH __attribute__((fallthrough))
+#endif
+
+#if !defined(BOOST_REGEX_FALLTHROUGH)
+#  define BOOST_REGEX_FALLTHROUGH
+#endif
+#endif
+
+#ifdef BOOST_NORETURN
+#  define BOOST_REGEX_NORETURN BOOST_NORETURN
+#else
+#  define BOOST_REGEX_NORETURN
+#endif
+
+
+/*
+* Define a macro for the namespace that details are placed in, this includes the Boost
+* version number to avoid mismatched header and library versions:
+*/
+#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION)
+
+/*
+ * Fix for gcc prior to 3.4: std::ctype<wchar_t> doesn't allow
+ * masks to be combined, for example:
+ * std::use_facet<std::ctype<wchar_t> >.is(std::ctype_base::lower|std::ctype_base::upper, L'a');
+ * returns *false*.
+ */
+#if defined(__GLIBCPP__) && defined(BOOST_REGEX_CXX03)
+#  define BOOST_REGEX_BUGGY_CTYPE_FACET
+#endif
+
+/*
+ * If there isn't good enough wide character support then there will
+ * be no wide character regular expressions:
+ */
+#if (defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_CWCTYPE) || defined(BOOST_NO_STD_WSTRING))
+#  if !defined(BOOST_NO_WREGEX)
+#     define BOOST_NO_WREGEX
+#  endif
+#else
+#  if defined(__sgi) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
+      /* STLPort on IRIX is misconfigured: <cwctype> does not compile
+       * as a temporary fix include <wctype.h> instead and prevent inclusion
+       * of STLPort version of <cwctype> */
+#     include <wctype.h>
+#     define __STLPORT_CWCTYPE
+#     define _STLP_CWCTYPE
+#  endif
+
+#if defined(__cplusplus) && defined(BOOST_REGEX_CXX03)
+#  include <boost/regex/config/cwchar.hpp>
+#endif
+
+#endif
+
+/*
+ * If Win32 support has been disabled for boost in general, then
+ * it is for regex in particular:
+ */
+#if defined(BOOST_DISABLE_WIN32) && !defined(BOOST_REGEX_NO_W32)
+#  define BOOST_REGEX_NO_W32
+#endif
+
+/* disable our own file-iterators and mapfiles if we can't
+ * support them: */
+#if defined(_WIN32)
+#  if defined(BOOST_REGEX_NO_W32) || BOOST_PLAT_WINDOWS_RUNTIME
+#    define BOOST_REGEX_NO_FILEITER
+#  endif
+#else /* defined(_WIN32) */
+#  if !defined(BOOST_HAS_DIRENT_H)
+#    define BOOST_REGEX_NO_FILEITER
+#  endif
+#endif
+
+/* backwards compatibitity: */
+#if defined(BOOST_RE_NO_LIB)
+#  define BOOST_REGEX_NO_LIB
+#endif
+
+#if defined(__GNUC__) && !defined(_MSC_VER) && (defined(_WIN32) || defined(__CYGWIN__))
+/* gcc on win32 has problems if you include <windows.h>
+   (sporadically generates bad code). */
+#  define BOOST_REGEX_NO_W32
+#endif
+#if defined(__COMO__) && !defined(BOOST_REGEX_NO_W32) && !defined(_MSC_EXTENSIONS)
+#  define BOOST_REGEX_NO_W32
+#endif
+
+#ifdef BOOST_REGEX_STANDALONE
+#  if defined(_MSC_VER) && !defined(__clang__) && !defined(__GNUC__)
+#     define BOOST_REGEX_MSVC _MSC_VER
+#endif
+#elif defined(BOOST_MSVC)
+#  define BOOST_REGEX_MSVC BOOST_MSVC
+#endif
+
+
+/*****************************************************************************
+ *
+ *  Set up dll import/export options:
+ *
+ ****************************************************************************/
+
+#if (defined(BOOST_REGEX_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) && !defined(BOOST_REGEX_STATIC_LINK) && defined(BOOST_SYMBOL_IMPORT)
+#  if defined(BOOST_REGEX_SOURCE)
+#     define BOOST_REGEX_BUILD_DLL
+#     define BOOST_REGEX_DECL BOOST_SYMBOL_EXPORT
+#  else
+#     define BOOST_REGEX_DECL BOOST_SYMBOL_IMPORT
+#  endif
+#else
+#  define BOOST_REGEX_DECL
+#endif
+
+#ifdef BOOST_REGEX_CXX03
+#if !defined(BOOST_REGEX_NO_LIB) && !defined(BOOST_REGEX_SOURCE) && !defined(BOOST_ALL_NO_LIB) && defined(__cplusplus)
+#  define BOOST_LIB_NAME boost_regex
+#  if defined(BOOST_REGEX_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)
+#     define BOOST_DYN_LINK
+#  endif
+#  ifdef BOOST_REGEX_DIAG
+#     define BOOST_LIB_DIAGNOSTIC
+#  endif
+#  include <boost/config/auto_link.hpp>
+#endif
+#endif
+
+/*****************************************************************************
+ *
+ *  Set up function call type:
+ *
+ ****************************************************************************/
+
+#if defined(_MSC_VER) && defined(_MSC_EXTENSIONS)
+#if defined(_DEBUG) || defined(__MSVC_RUNTIME_CHECKS) || defined(_MANAGED) || defined(BOOST_REGEX_NO_FASTCALL)
+#  define BOOST_REGEX_CALL __cdecl
+#else
+#  define BOOST_REGEX_CALL __fastcall
+#endif
+#  define BOOST_REGEX_CCALL __cdecl
+#endif
+
+#if defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32)
+#if defined(__clang__)
+#  define BOOST_REGEX_CALL __cdecl
+#  define BOOST_REGEX_CCALL __cdecl
+#else
+#  define BOOST_REGEX_CALL __fastcall
+#  define BOOST_REGEX_CCALL __stdcall
+#endif
+#endif
+
+#ifndef BOOST_REGEX_CALL
+#  define BOOST_REGEX_CALL
+#endif
+#ifndef BOOST_REGEX_CCALL
+#define BOOST_REGEX_CCALL
+#endif
+
+/*****************************************************************************
+ *
+ *  Set up localisation model:
+ *
+ ****************************************************************************/
+
+/* backwards compatibility: */
+#ifdef BOOST_RE_LOCALE_C
+#  define BOOST_REGEX_USE_C_LOCALE
+#endif
+
+#ifdef BOOST_RE_LOCALE_CPP
+#  define BOOST_REGEX_USE_CPP_LOCALE
+#endif
+
+#if defined(__CYGWIN__)
+#  define BOOST_REGEX_USE_C_LOCALE
+#endif
+
+/* use C++ locale when targeting windows store */
+#if BOOST_PLAT_WINDOWS_RUNTIME
+#  define BOOST_REGEX_USE_CPP_LOCALE
+#  define BOOST_REGEX_NO_WIN32_LOCALE
+#endif
+
+/* Win32 defaults to native Win32 locale: */
+#if defined(_WIN32) && \
+    !defined(BOOST_REGEX_USE_WIN32_LOCALE) && \
+    !defined(BOOST_REGEX_USE_C_LOCALE) && \
+    !defined(BOOST_REGEX_USE_CPP_LOCALE) && \
+    !defined(BOOST_REGEX_NO_W32) && \
+    !defined(BOOST_REGEX_NO_WIN32_LOCALE)
+#  define BOOST_REGEX_USE_WIN32_LOCALE
+#endif
+/* otherwise use C++ locale if supported: */
+#if !defined(BOOST_REGEX_USE_WIN32_LOCALE) && !defined(BOOST_REGEX_USE_C_LOCALE) && !defined(BOOST_REGEX_USE_CPP_LOCALE) && !defined(BOOST_NO_STD_LOCALE)
+#  define BOOST_REGEX_USE_CPP_LOCALE
+#endif
+/* otherwise use C locale: */
+#if !defined(BOOST_REGEX_USE_WIN32_LOCALE) && !defined(BOOST_REGEX_USE_C_LOCALE) && !defined(BOOST_REGEX_USE_CPP_LOCALE)
+#  define BOOST_REGEX_USE_C_LOCALE
+#endif
+
+#ifndef BOOST_REGEX_MAX_STATE_COUNT
+#  define BOOST_REGEX_MAX_STATE_COUNT 100000000
+#endif
+
+
+/*****************************************************************************
+ *
+ *  Error Handling for exception free compilers:
+ *
+ ****************************************************************************/
+
+#ifdef BOOST_NO_EXCEPTIONS
+/*
+ * If there are no exceptions then we must report critical-errors
+ * the only way we know how; by terminating.
+ */
+#include <stdexcept>
+#include <string>
+#include <boost/throw_exception.hpp>
+
+#  define BOOST_REGEX_NOEH_ASSERT(x)\
+if(0 == (x))\
+{\
+   std::string s("Error: critical regex++ failure in: ");\
+   s.append(#x);\
+   std::runtime_error e(s);\
+   boost::throw_exception(e);\
+}
+#else
+/*
+ * With exceptions then error handling is taken care of and
+ * there is no need for these checks:
+ */
+#  define BOOST_REGEX_NOEH_ASSERT(x)
+#endif
+
+
+/*****************************************************************************
+ *
+ *  Stack protection under MS Windows:
+ *
+ ****************************************************************************/
+
+#if !defined(BOOST_REGEX_NO_W32) && !defined(BOOST_REGEX_V3)
+#  if(defined(_WIN32) || defined(_WIN64) || defined(_WINCE)) \
+        && !(defined(__GNUC__) || defined(__BORLANDC__) && defined(__clang__)) \
+        && !(defined(__BORLANDC__) && (__BORLANDC__ >= 0x600)) \
+        && !(defined(__MWERKS__) && (__MWERKS__ <= 0x3003))
+#     define BOOST_REGEX_HAS_MS_STACK_GUARD
+#  endif
+#elif defined(BOOST_REGEX_HAS_MS_STACK_GUARD)
+#  undef BOOST_REGEX_HAS_MS_STACK_GUARD
+#endif
+
+#if defined(__cplusplus) && defined(BOOST_REGEX_HAS_MS_STACK_GUARD)
+
+namespace boost{
+namespace BOOST_REGEX_DETAIL_NS{
+
+BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page();
+
+}
+}
+
+#endif
+
+
+/*****************************************************************************
+ *
+ *  Algorithm selection and configuration.
+ *  These options are now obsolete for C++11 and later (regex v5).
+ *
+ ****************************************************************************/
+
+#if !defined(BOOST_REGEX_RECURSIVE) && !defined(BOOST_REGEX_NON_RECURSIVE)
+#  if defined(BOOST_REGEX_HAS_MS_STACK_GUARD) && !defined(_STLP_DEBUG) && !defined(__STL_DEBUG) && !(defined(_MSC_VER) && (_MSC_VER >= 1400)) && defined(BOOST_REGEX_CXX03)
+#     define BOOST_REGEX_RECURSIVE
+#  else
+#     define BOOST_REGEX_NON_RECURSIVE
+#  endif
+#endif
+
+#ifdef BOOST_REGEX_NON_RECURSIVE
+#  ifdef BOOST_REGEX_RECURSIVE
+#     error "Can't set both BOOST_REGEX_RECURSIVE and BOOST_REGEX_NON_RECURSIVE"
+#  endif
+#  ifndef BOOST_REGEX_BLOCKSIZE
+#     define BOOST_REGEX_BLOCKSIZE 4096
+#  endif
+#  if BOOST_REGEX_BLOCKSIZE < 512
+#     error "BOOST_REGEX_BLOCKSIZE must be at least 512"
+#  endif
+#  ifndef BOOST_REGEX_MAX_BLOCKS
+#     define BOOST_REGEX_MAX_BLOCKS 1024
+#  endif
+#  ifdef BOOST_REGEX_HAS_MS_STACK_GUARD
+#     undef BOOST_REGEX_HAS_MS_STACK_GUARD
+#  endif
+#  ifndef BOOST_REGEX_MAX_CACHE_BLOCKS
+#     define BOOST_REGEX_MAX_CACHE_BLOCKS 16
+#  endif
+#endif
+
+
+/*****************************************************************************
+ *
+ *  Diagnostics:
+ *
+ ****************************************************************************/
+
+#ifdef BOOST_REGEX_CONFIG_INFO
+BOOST_REGEX_DECL void BOOST_REGEX_CALL print_regex_library_info();
+#endif
+
+#if defined(BOOST_REGEX_DIAG)
+#  pragma message ("BOOST_REGEX_DECL" BOOST_STRINGIZE(=BOOST_REGEX_DECL))
+#  pragma message ("BOOST_REGEX_CALL" BOOST_STRINGIZE(=BOOST_REGEX_CALL))
+#  pragma message ("BOOST_REGEX_CCALL" BOOST_STRINGIZE(=BOOST_REGEX_CCALL))
+#ifdef BOOST_REGEX_USE_C_LOCALE
+#  pragma message ("Using C locale in regex traits class")
+#elif BOOST_REGEX_USE_CPP_LOCALE
+#  pragma message ("Using C++ locale in regex traits class")
+#else
+#  pragma message ("Using Win32 locale in regex traits class")
+#endif
+#if defined(BOOST_REGEX_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)
+#  pragma message ("Dynamic linking enabled")
+#endif
+#if defined(BOOST_REGEX_NO_LIB) || defined(BOOST_ALL_NO_LIB)
+#  pragma message ("Auto-linking disabled")
+#endif
+#ifdef BOOST_REGEX_NO_EXTERNAL_TEMPLATES
+#  pragma message ("Extern templates disabled")
+#endif
+
+#endif
+
+#endif
+

lib/third_party/boost/regex/include/boost/regex/config/borland.hpp

@@ -0,0 +1,72 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         boost/regex/config/borland.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: regex borland-specific config setup.
+  */
+
+
+#if defined(__BORLANDC__) && !defined(__clang__)
+#  if (__BORLANDC__ == 0x550) || (__BORLANDC__ == 0x551)
+      // problems with std::basic_string and dll RTL:
+#     if defined(_RTLDLL) && defined(_RWSTD_COMPILE_INSTANTIATE)
+#        ifdef BOOST_REGEX_BUILD_DLL
+#           error _RWSTD_COMPILE_INSTANTIATE must not be defined when building regex++ as a DLL
+#        else
+#           pragma message("Defining _RWSTD_COMPILE_INSTANTIATE when linking to the DLL version of the RTL may produce memory corruption problems in std::basic_string, as a result of separate versions of basic_string's static data in the RTL and you're exe/dll: be warned!!")
+#        endif
+#     endif
+#     ifndef _RTLDLL
+         // this is harmless for a staic link:
+#        define _RWSTD_COMPILE_INSTANTIATE
+#     endif
+      // external templates cause problems for some reason:
+#     define BOOST_REGEX_NO_EXTERNAL_TEMPLATES
+#  endif
+#  if (__BORLANDC__ <= 0x540) && !defined(BOOST_REGEX_NO_LIB) && !defined(_NO_VCL)
+      // C++ Builder 4 and earlier, we can't tell whether we should be using
+      // the VCL runtime or not, do a static link instead:
+#     define BOOST_REGEX_STATIC_LINK
+#  endif
+   //
+   // VCL support:
+   // if we're building a console app then there can't be any VCL (can there?)
+#  if !defined(__CONSOLE__) && !defined(_NO_VCL)
+#     define BOOST_REGEX_USE_VCL
+#  endif
+   //
+   // if this isn't Win32 then don't automatically select link
+   // libraries:
+   //
+#  ifndef _Windows
+#     ifndef BOOST_REGEX_NO_LIB
+#        define BOOST_REGEX_NO_LIB
+#     endif
+#     ifndef BOOST_REGEX_STATIC_LINK
+#        define BOOST_REGEX_STATIC_LINK
+#     endif
+#  endif
+
+#if __BORLANDC__ < 0x600
+//
+// string workarounds:
+//
+#include <cstring>
+#undef strcmp
+#undef strcpy
+#endif
+
+#endif
+
+

lib/third_party/boost/regex/include/boost/regex/config/cwchar.hpp

@@ -0,0 +1,207 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         boost/regex/config/cwchar.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: regex wide character string fixes.
+  */
+
+#ifndef BOOST_REGEX_CONFIG_CWCHAR_HPP
+#define BOOST_REGEX_CONFIG_CWCHAR_HPP
+
+#include <cwchar>
+#include <cwctype>
+#include <boost/config.hpp>
+
+#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+// apparently this is required for the RW STL on Linux:
+#undef iswalnum
+#undef iswalpha
+#undef iswblank
+#undef iswcntrl
+#undef iswdigit
+#undef iswgraph
+#undef iswlower
+#undef iswprint
+#undef iswprint
+#undef iswpunct
+#undef iswspace
+#undef iswupper
+#undef iswxdigit
+#undef iswctype
+#undef towlower
+#undef towupper
+#undef towctrans
+#undef wctrans
+#undef wctype
+#endif
+
+namespace std{
+
+#ifndef BOOST_NO_STDC_NAMESPACE
+extern "C"{
+#endif
+
+#ifdef iswalnum
+inline int (iswalnum)(wint_t i)
+{ return iswalnum(i); }
+#undef iswalnum
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswalnum;
+#endif
+
+#ifdef iswalpha
+inline int (iswalpha)(wint_t i)
+{ return iswalpha(i); }
+#undef iswalpha
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswalpha;
+#endif
+
+#ifdef iswcntrl
+inline int (iswcntrl)(wint_t i)
+{ return iswcntrl(i); }
+#undef iswcntrl
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswcntrl;
+#endif
+
+#ifdef iswdigit
+inline int (iswdigit)(wint_t i)
+{ return iswdigit(i); }
+#undef iswdigit
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswdigit;
+#endif
+
+#ifdef iswgraph
+inline int (iswgraph)(wint_t i)
+{ return iswgraph(i); }
+#undef iswgraph
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswgraph;
+#endif
+
+#ifdef iswlower
+inline int (iswlower)(wint_t i)
+{ return iswlower(i); }
+#undef iswlower
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswlower;
+#endif
+
+#ifdef iswprint
+inline int (iswprint)(wint_t i)
+{ return iswprint(i); }
+#undef iswprint
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswprint;
+#endif
+
+#ifdef iswpunct
+inline int (iswpunct)(wint_t i)
+{ return iswpunct(i); }
+#undef iswpunct
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswpunct;
+#endif
+
+#ifdef iswspace
+inline int (iswspace)(wint_t i)
+{ return iswspace(i); }
+#undef iswspace
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswspace;
+#endif
+
+#ifdef iswupper
+inline int (iswupper)(wint_t i)
+{ return iswupper(i); }
+#undef iswupper
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswupper;
+#endif
+
+#ifdef iswxdigit
+inline int (iswxdigit)(wint_t i)
+{ return iswxdigit(i); }
+#undef iswxdigit
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::iswxdigit;
+#endif
+
+#ifdef towlower
+inline wint_t (towlower)(wint_t i)
+{ return towlower(i); }
+#undef towlower
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::towlower;
+#endif
+
+#ifdef towupper
+inline wint_t (towupper)(wint_t i)
+{ return towupper(i); }
+#undef towupper
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using :: towupper;
+#endif
+
+#ifdef wcscmp
+inline int (wcscmp)(const wchar_t *p1, const wchar_t *p2)
+{ return wcscmp(p1,p2); }
+#undef wcscmp
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::wcscmp;
+#endif
+
+#ifdef wcscoll
+inline int (wcscoll)(const wchar_t *p1, const wchar_t *p2)
+{ return wcscoll(p1,p2); }
+#undef wcscoll
+#elif defined(BOOST_NO_STDC_NAMESPACE) && !defined(UNDER_CE)
+using ::wcscoll;
+#endif
+
+#ifdef wcscpy
+inline wchar_t *(wcscpy)(wchar_t *p1, const wchar_t *p2)
+{ return wcscpy(p1,p2); }
+#undef wcscpy
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::wcscpy;
+#endif
+
+#ifdef wcslen
+inline size_t (wcslen)(const wchar_t *p)
+{ return wcslen(p); }
+#undef wcslen
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::wcslen;
+#endif
+
+#ifdef wcsxfrm
+size_t wcsxfrm(wchar_t *p1, const wchar_t *p2, size_t s)
+{ return wcsxfrm(p1,p2,s); }
+#undef wcsxfrm
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+using ::wcsxfrm;
+#endif
+
+
+#ifndef BOOST_NO_STDC_NAMESPACE
+} // extern "C"
+#endif
+
+} // namespace std
+
+#endif
+

lib/third_party/boost/regex/include/boost/regex/icu.hpp

@@ -0,0 +1,30 @@
+/*
+ *
+ * Copyright (c) 2020
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         icu.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Unicode regular expressions on top of the ICU Library.
+  */
+
+#ifndef BOOST_REGEX_ICU_HPP
+#define BOOST_REGEX_ICU_HPP
+
+#include <boost/regex/config.hpp>
+
+#ifdef BOOST_REGEX_CXX03
+#include <boost/regex/v4/icu.hpp>
+#else
+#include <boost/regex/v5/icu.hpp>
+#endif
+
+#endif

lib/third_party/boost/regex/include/boost/regex/mfc.hpp

@@ -0,0 +1,186 @@
+/*
+ *
+ * Copyright (c) 2004
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         mfc.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Overloads and helpers for using MFC/ATL string types with Boost.Regex.
+  */
+
+#ifndef BOOST_REGEX_MFC_HPP
+#define BOOST_REGEX_MFC_HPP
+
+#include <atlsimpstr.h>
+#include <boost/regex.hpp>
+
+namespace boost{
+
+//
+// define the types used for TCHAR's:
+typedef basic_regex<TCHAR> tregex;
+typedef match_results<TCHAR const*> tmatch;
+typedef regex_iterator<TCHAR const*> tregex_iterator;
+typedef regex_token_iterator<TCHAR const*> tregex_token_iterator;
+
+// Obsolete. Remove
+#define SIMPLE_STRING_PARAM class B, bool b
+#define SIMPLE_STRING_ARG_LIST B, b
+
+//
+// define regex creation functions:
+//
+template <class B, bool b>
+inline basic_regex<B> 
+make_regex(const ATL::CSimpleStringT<B, b>& s, ::boost::regex_constants::syntax_option_type f = boost::regex_constants::normal)
+{
+   basic_regex<B> result(s.GetString(), s.GetString() + s.GetLength(), f);
+   return result;
+}
+//
+// regex_match overloads:
+//
+template <class B, bool b, class A, class T>
+inline bool regex_match(const ATL::CSimpleStringT<B, b>& s,
+                 match_results<const B*, A>& what,
+                 const basic_regex<B, T>& e,
+                 boost::regex_constants::match_flag_type f = boost::regex_constants::match_default)
+{
+   return ::boost::regex_match(s.GetString(),
+                               s.GetString() + s.GetLength(),
+                               what,
+                               e,
+                               f);
+}
+
+template <class B, bool b, class T>
+inline bool regex_match(const ATL::CSimpleStringT<B, b>& s,
+                 const basic_regex<B, T>& e,
+                 boost::regex_constants::match_flag_type f = boost::regex_constants::match_default)
+{
+   return ::boost::regex_match(s.GetString(),
+                               s.GetString() + s.GetLength(),
+                               e,
+                               f);
+}
+//
+// regex_search overloads:
+//
+template <class B, bool b, class A, class T>
+inline bool regex_search(const ATL::CSimpleStringT<B, b>& s,
+                 match_results<const B*, A>& what,
+                 const basic_regex<B, T>& e,
+                 boost::regex_constants::match_flag_type f = boost::regex_constants::match_default)
+{
+   return ::boost::regex_search(s.GetString(),
+                               s.GetString() + s.GetLength(),
+                               what,
+                               e,
+                               f);
+}
+
+template <class B, bool b, class T>
+inline bool regex_search(const ATL::CSimpleStringT<B, b>& s,
+                 const basic_regex<B, T>& e,
+                 boost::regex_constants::match_flag_type f = boost::regex_constants::match_default)
+{
+   return ::boost::regex_search(s.GetString(),
+                               s.GetString() + s.GetLength(),
+                               e,
+                               f);
+}
+//
+// regex_iterator creation:
+//
+template <class B, bool b>
+inline regex_iterator<B const*> 
+make_regex_iterator(const ATL::CSimpleStringT<B, b>& s, const basic_regex<B>& e, ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default)
+{
+   regex_iterator<B const*> result(s.GetString(), s.GetString() + s.GetLength(), e, f);
+   return result;
+}
+
+template <class B, bool b>
+inline regex_token_iterator<B const*> 
+   make_regex_token_iterator(const ATL::CSimpleStringT<B, b>& s, const basic_regex<B>& e, int sub = 0, ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default)
+{
+   regex_token_iterator<B const*> result(s.GetString(), s.GetString() + s.GetLength(), e, sub, f);
+   return result;
+}
+
+template <class B, bool b>
+inline regex_token_iterator<B const*> 
+make_regex_token_iterator(const ATL::CSimpleStringT<B, b>& s, const basic_regex<B>& e, const std::vector<int>& subs, ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default)
+{
+   regex_token_iterator<B const*> result(s.GetString(), s.GetString() + s.GetLength(), e, subs, f);
+   return result;
+}
+
+template <class B, bool b, std::size_t N>
+inline regex_token_iterator<B const*> 
+make_regex_token_iterator(const ATL::CSimpleStringT<B, b>& s, const basic_regex<B>& e, const int (& subs)[N], ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default)
+{
+   regex_token_iterator<B const*> result(s.GetString(), s.GetString() + s.GetLength(), e, subs, f);
+   return result;
+}
+
+template <class OutputIterator, class BidirectionalIterator, class traits,
+          class B, bool b>
+OutputIterator regex_replace(OutputIterator out,
+                           BidirectionalIterator first,
+                           BidirectionalIterator last,
+                           const basic_regex<B, traits>& e,
+                           const ATL::CSimpleStringT<B, b>& fmt,
+                           match_flag_type flags = match_default)
+{
+   return ::boost::regex_replace(out, first, last, e, fmt.GetString(), flags);
+}
+
+namespace BOOST_REGEX_DETAIL_NS{
+
+template <class B, bool b>
+class mfc_string_out_iterator
+{
+   ATL::CSimpleStringT<B, b>* out;
+public:
+   mfc_string_out_iterator(ATL::CSimpleStringT<B, b>& s) : out(&s) {}
+   mfc_string_out_iterator& operator++() { return *this; }
+   mfc_string_out_iterator& operator++(int) { return *this; }
+   mfc_string_out_iterator& operator*() { return *this; }
+   mfc_string_out_iterator& operator=(B v) 
+   { 
+      out->AppendChar(v); 
+      return *this; 
+   }
+   typedef std::ptrdiff_t difference_type;
+   typedef B value_type;
+   typedef value_type* pointer;
+   typedef value_type& reference;
+   typedef std::output_iterator_tag iterator_category;
+};
+
+}
+
+template <class traits, class B, bool b>
+ATL::CSimpleStringT<B, b> regex_replace(const ATL::CSimpleStringT<B, b>& s,
+                            const basic_regex<B, traits>& e,
+                            const ATL::CSimpleStringT<B, b>& fmt,
+                            match_flag_type flags = match_default)
+{
+   ATL::CSimpleStringT<B, b> result(s.GetManager());
+   BOOST_REGEX_DETAIL_NS::mfc_string_out_iterator<B, b> i(result);
+   regex_replace(i, s.GetString(), s.GetString() + s.GetLength(), e, fmt.GetString(), flags);
+   return result;
+}
+
+} // namespace boost.
+
+#endif

lib/third_party/boost/regex/include/boost/regex/pattern_except.hpp

@@ -0,0 +1,32 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         pattern_except.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares pattern-matching exception classes.
+  */
+
+#ifndef BOOST_RE_PAT_EXCEPT_HPP
+#define BOOST_RE_PAT_EXCEPT_HPP
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+
+#ifdef BOOST_REGEX_CXX03
+#include <boost/regex/v4/pattern_except.hpp>
+#else
+#include <boost/regex/v5/pattern_except.hpp>
+#endif
+
+#endif

lib/third_party/boost/regex/include/boost/regex/pending/object_cache.hpp

@@ -0,0 +1,29 @@
+/*
+ *
+ * Copyright (c) 2004
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         object_cache.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Implements a generic object cache.
+  */
+
+#ifndef BOOST_REGEX_OBJECT_CACHE_HPP
+#define BOOST_REGEX_OBJECT_CACHE_HPP
+
+#include <boost/regex/config.hpp>
+#ifdef BOOST_REGEX_CXX03
+#include <boost/regex/v4/object_cache.hpp>
+#else
+#include <boost/regex/v5/object_cache.hpp>
+#endif
+
+#endif

lib/third_party/boost/regex/include/boost/regex/pending/static_mutex.hpp

@@ -0,0 +1,182 @@
+/*
+ *
+ * Copyright (c) 2004
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         static_mutex.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares static_mutex lock type, there are three different
+  *                implementations: POSIX pthreads, WIN32 threads, and portable,
+  *                these are described in more detail below.
+  */
+
+#ifndef BOOST_REGEX_STATIC_MUTEX_HPP
+#define BOOST_REGEX_STATIC_MUTEX_HPP
+
+#include <boost/config.hpp>
+#include <boost/regex/config.hpp> // dll import/export options.
+
+#ifdef BOOST_HAS_PTHREADS
+#include <pthread.h>
+#endif
+
+#if defined(BOOST_HAS_PTHREADS) && defined(PTHREAD_MUTEX_INITIALIZER)
+//
+// pthreads version:
+// simple wrap around a pthread_mutex_t initialized with
+// PTHREAD_MUTEX_INITIALIZER.
+//
+namespace boost{
+
+class static_mutex;
+
+#define BOOST_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER, }
+
+class BOOST_REGEX_DECL scoped_static_mutex_lock
+{
+public:
+   scoped_static_mutex_lock(static_mutex& mut, bool lk = true);
+   ~scoped_static_mutex_lock();
+   inline bool locked()const
+   {
+      return m_have_lock;
+   }
+   inline operator void const*()const
+   {
+      return locked() ? this : 0;
+   }
+   void lock();
+   void unlock();
+private:
+   static_mutex& m_mutex;
+   bool m_have_lock;
+};
+
+class static_mutex
+{
+public:
+   typedef scoped_static_mutex_lock scoped_lock;
+   pthread_mutex_t m_mutex;
+};
+
+} // namespace boost
+#elif defined(BOOST_HAS_WINTHREADS)
+//
+// Win32 version:
+// Use a 32-bit int as a lock, along with a test-and-set
+// implementation using InterlockedCompareExchange.
+//
+
+#include <boost/cstdint.hpp>
+
+namespace boost{
+
+class BOOST_REGEX_DECL scoped_static_mutex_lock;
+
+class static_mutex
+{
+public:
+   typedef scoped_static_mutex_lock scoped_lock;
+   boost::int32_t m_mutex;
+};
+
+#define BOOST_STATIC_MUTEX_INIT { 0, }
+
+class BOOST_REGEX_DECL scoped_static_mutex_lock
+{
+public:
+   scoped_static_mutex_lock(static_mutex& mut, bool lk = true);
+   ~scoped_static_mutex_lock();
+   operator void const*()const
+   {
+      return locked() ? this : 0;
+   }
+   bool locked()const
+   {
+      return m_have_lock;
+   }
+   void lock();
+   void unlock();
+private:
+   static_mutex& m_mutex;
+   bool m_have_lock;
+   scoped_static_mutex_lock(const scoped_static_mutex_lock&);
+   scoped_static_mutex_lock& operator=(const scoped_static_mutex_lock&);
+};
+
+} // namespace
+
+#else
+//
+// Portable version of a static mutex based on Boost.Thread library:
+// This has to use a single mutex shared by all instances of static_mutex
+// because boost::call_once doesn't alow us to pass instance information
+// down to the initialisation proceedure.  In fact the initialisation routine
+// may need to be called more than once - but only once per instance.
+//
+// Since this preprocessor path is almost never taken, we hide these header
+// dependencies so that build tools don't find them.
+//
+#define BOOST_REGEX_H1 <boost/thread/once.hpp>
+#define BOOST_REGEX_H2 <boost/thread/recursive_mutex.hpp>
+#define BOOST_REGEX_H3 <boost/thread/lock_types.hpp>
+#include BOOST_REGEX_H1
+#include BOOST_REGEX_H2
+#include BOOST_REGEX_H3
+#undef BOOST_REGEX_H1
+#undef BOOST_REGEX_H2
+#undef BOOST_REGEX_H3
+
+namespace boost{
+
+class BOOST_REGEX_DECL scoped_static_mutex_lock;
+extern "C" BOOST_REGEX_DECL void boost_regex_free_static_mutex();
+
+class BOOST_REGEX_DECL static_mutex
+{
+public:
+   typedef scoped_static_mutex_lock scoped_lock;
+   static void init();
+   static boost::recursive_mutex* m_pmutex;
+   static boost::once_flag m_once;
+};
+
+#define BOOST_STATIC_MUTEX_INIT {  }
+
+class BOOST_REGEX_DECL scoped_static_mutex_lock
+{
+public:
+   scoped_static_mutex_lock(static_mutex& mut, bool lk = true);
+   ~scoped_static_mutex_lock();
+   operator void const*()const;
+   bool locked()const;
+   void lock();
+   void unlock();
+private:
+   boost::unique_lock<boost::recursive_mutex>* m_plock;
+   bool m_have_lock;
+};
+
+inline scoped_static_mutex_lock::operator void const*()const
+{
+   return locked() ? this : 0;
+}
+
+inline bool scoped_static_mutex_lock::locked()const
+{
+   return m_have_lock;
+}
+
+} // namespace
+
+#endif
+
+#endif

lib/third_party/boost/regex/include/boost/regex/pending/unicode_iterator.hpp

@@ -0,0 +1,32 @@
+/*
+ *
+ * Copyright (c) 2020
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         unicode_iterator.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Iterator adapters for converting between different Unicode encodings.
+  */
+
+#ifndef BOOST_REGEX_PENDING_UNICODE_ITERATOR_HPP
+#define BOOST_REGEX_PENDING_UNICODE_ITERATOR_HPP
+
+#include <boost/regex/config.hpp>
+
+#if defined(BOOST_REGEX_CXX03)
+#include <boost/regex/v4/unicode_iterator.hpp>
+#else
+#include <boost/regex/v5/unicode_iterator.hpp>
+#endif
+
+
+#endif // BOOST_REGEX_PENDING_UNICODE_ITERATOR_HPP
+

lib/third_party/boost/regex/include/boost/regex/regex_traits.hpp

@@ -0,0 +1,39 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_traits.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares regular expression traits classes.
+  */
+
+#ifndef BOOST_REGEX_TRAITS_HPP
+#define BOOST_REGEX_TRAITS_HPP
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#  include <boost/regex/config.hpp>
+#endif
+
+#  ifndef BOOST_REGEX_TRAITS_HPP_INCLUDED
+#ifdef BOOST_REGEX_CXX03
+#     include <boost/regex/v4/regex_traits.hpp>
+#else
+#     include <boost/regex/v5/regex_traits.hpp>
+#endif
+#  endif
+
+#endif // include
+
+
+
+
+

lib/third_party/boost/regex/include/boost/regex/user.hpp

@@ -0,0 +1,95 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         user.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: User settable options.
+  */
+
+// define if you want the regex library to use the C locale
+// even on Win32:
+// #define BOOST_REGEX_USE_C_LOCALE
+
+// define this is you want the regex library to use the C++
+// locale:
+// #define BOOST_REGEX_USE_CPP_LOCALE
+
+// define this if the runtime library is a dll, and you
+// want BOOST_REGEX_DYN_LINK to set up dll exports/imports
+// with __declspec(dllexport)/__declspec(dllimport.)
+// #define BOOST_REGEX_HAS_DLL_RUNTIME
+
+// define this if you want to dynamically link to regex,
+// if the runtime library is also a dll (Probably Win32 specific,
+// and has no effect unless BOOST_REGEX_HAS_DLL_RUNTIME is set):
+// #define BOOST_REGEX_DYN_LINK
+
+// define this if you don't want the lib to automatically
+// select its link libraries:
+// #define BOOST_REGEX_NO_LIB
+
+// define this if templates with switch statements cause problems:
+// #define BOOST_REGEX_NO_TEMPLATE_SWITCH_MERGE
+ 
+// define this to disable Win32 support when available:
+// #define BOOST_REGEX_NO_W32
+
+// define this if bool is not a real type:
+// #define BOOST_REGEX_NO_BOOL
+
+// define this if no template instances are to be placed in
+// the library rather than users object files:
+// #define BOOST_REGEX_NO_EXTERNAL_TEMPLATES
+
+// define this if the forward declarations in regex_fwd.hpp
+// cause more problems than they are worth:
+// #define BOOST_REGEX_NO_FWD
+
+// define this if your compiler supports MS Windows structured
+// exception handling.
+// #define BOOST_REGEX_HAS_MS_STACK_GUARD
+
+// define this if you want to use the recursive algorithm
+// even if BOOST_REGEX_HAS_MS_STACK_GUARD is not defined.
+// NOTE: OBSOLETE!!
+// #define BOOST_REGEX_RECURSIVE
+
+// define this if you want to use the non-recursive
+// algorithm, even if the recursive version would be the default.
+// NOTE: OBSOLETE!!
+// #define BOOST_REGEX_NON_RECURSIVE
+
+// define this if you want to set the size of the memory blocks
+// used by the non-recursive algorithm.
+// #define BOOST_REGEX_BLOCKSIZE 4096
+
+// define this if you want to set the maximum number of memory blocks
+// used by the non-recursive algorithm.
+// #define BOOST_REGEX_MAX_BLOCKS 1024
+
+// define this if you want to set the maximum number of memory blocks
+// cached by the non-recursive algorithm: Normally this is 16, but can be 
+// higher if you have multiple threads all using boost.regex, or lower 
+// if you don't want boost.regex to cache memory.
+// #define BOOST_REGEX_MAX_CACHE_BLOCKS 16
+
+// define this if you want to be able to access extended capture
+// information in your sub_match's (caution this will slow things
+// down quite a bit).
+// #define BOOST_REGEX_MATCH_EXTRA
+
+// define this if you want to enable support for Unicode via ICU.
+// #define BOOST_HAS_ICU
+
+// define this if you want regex to use __cdecl calling convensions, even when __fastcall is available:
+// #define BOOST_REGEX_NO_FASTCALL

lib/third_party/boost/regex/include/boost/regex/v4/basic_regex.hpp

@@ -0,0 +1,797 @@
+/*
+ *
+ * Copyright (c) 1998-2004 John Maddock
+ * Copyright 2011 Garmin Ltd. or its subsidiaries
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org/ for most recent version.
+  *   FILE         basic_regex.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares template class basic_regex.
+  */
+
+#ifndef BOOST_REGEX_V4_BASIC_REGEX_HPP
+#define BOOST_REGEX_V4_BASIC_REGEX_HPP
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/container_hash/hash.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+namespace boost{
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#if BOOST_MSVC < 1700
+#     pragma warning(disable : 4231)
+#endif
+#if BOOST_MSVC < 1600
+#pragma warning(disable : 4660)
+#endif
+#if BOOST_MSVC < 1910
+#pragma warning(disable:4800)
+#endif
+#endif
+
+namespace BOOST_REGEX_DETAIL_NS{
+
+//
+// forward declaration, we will need this one later:
+//
+template <class charT, class traits>
+class basic_regex_parser;
+
+template <class I>
+void bubble_down_one(I first, I last)
+{
+   if(first != last)
+   {
+      I next = last - 1;
+      while((next != first) && (*next < *(next-1)))
+      {
+         (next-1)->swap(*next);
+         --next;
+      }
+   }
+}
+
+static const int hash_value_mask = 1 << (std::numeric_limits<int>::digits - 1);
+
+template <class Iterator>
+inline int hash_value_from_capture_name(Iterator i, Iterator j)
+{
+   std::size_t r = boost::hash_range(i, j);
+   r %= ((std::numeric_limits<int>::max)());
+   return static_cast<int>(r) | hash_value_mask;
+}
+
+class named_subexpressions
+{
+public:
+   struct name
+   {
+      template <class charT>
+      name(const charT* i, const charT* j, int idx)
+         : index(idx) 
+      { 
+         hash = hash_value_from_capture_name(i, j); 
+      }
+      name(int h, int idx)
+         : index(idx), hash(h)
+      { 
+      }
+      int index;
+      int hash;
+      bool operator < (const name& other)const
+      {
+         return hash < other.hash;
+      }
+      bool operator == (const name& other)const
+      {
+         return hash == other.hash; 
+      }
+      void swap(name& other)
+      {
+         std::swap(index, other.index);
+         std::swap(hash, other.hash);
+      }
+   };
+
+   typedef std::vector<name>::const_iterator const_iterator;
+   typedef std::pair<const_iterator, const_iterator> range_type;
+
+   named_subexpressions(){}
+
+   template <class charT>
+   void set_name(const charT* i, const charT* j, int index)
+   {
+      m_sub_names.push_back(name(i, j, index));
+      bubble_down_one(m_sub_names.begin(), m_sub_names.end());
+   }
+   template <class charT>
+   int get_id(const charT* i, const charT* j)const
+   {
+      name t(i, j, 0);
+      typename std::vector<name>::const_iterator pos = std::lower_bound(m_sub_names.begin(), m_sub_names.end(), t);
+      if((pos != m_sub_names.end()) && (*pos == t))
+      {
+         return pos->index;
+      }
+      return -1;
+   }
+   template <class charT>
+   range_type equal_range(const charT* i, const charT* j)const
+   {
+      name t(i, j, 0);
+      return std::equal_range(m_sub_names.begin(), m_sub_names.end(), t);
+   }
+   int get_id(int h)const
+   {
+      name t(h, 0);
+      std::vector<name>::const_iterator pos = std::lower_bound(m_sub_names.begin(), m_sub_names.end(), t);
+      if((pos != m_sub_names.end()) && (*pos == t))
+      {
+         return pos->index;
+      }
+      return -1;
+   }
+   range_type equal_range(int h)const
+   {
+      name t(h, 0);
+      return std::equal_range(m_sub_names.begin(), m_sub_names.end(), t);
+   }
+private:
+   std::vector<name> m_sub_names;
+};
+
+//
+// class regex_data:
+// represents the data we wish to expose to the matching algorithms.
+//
+template <class charT, class traits>
+struct regex_data : public named_subexpressions
+{
+   typedef regex_constants::syntax_option_type   flag_type;
+   typedef std::size_t                           size_type;  
+
+   regex_data(const ::boost::shared_ptr<
+      ::boost::regex_traits_wrapper<traits> >& t) 
+      : m_ptraits(t), m_flags(0), m_status(0), m_expression(0), m_expression_len(0),
+         m_mark_count(0), m_first_state(0), m_restart_type(0),
+#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !(defined(BOOST_MSVC) && (BOOST_MSVC < 1900))
+         m_startmap{ 0 },
+#endif
+         m_can_be_null(0), m_word_mask(0), m_has_recursions(false), m_disable_match_any(false) {}
+   regex_data() 
+      : m_ptraits(new ::boost::regex_traits_wrapper<traits>()), m_flags(0), m_status(0), m_expression(0), m_expression_len(0), 
+         m_mark_count(0), m_first_state(0), m_restart_type(0), 
+#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !(defined(BOOST_MSVC) && (BOOST_MSVC < 1900))
+      m_startmap{ 0 },
+#endif
+         m_can_be_null(0), m_word_mask(0), m_has_recursions(false), m_disable_match_any(false) {}
+
+   ::boost::shared_ptr<
+      ::boost::regex_traits_wrapper<traits>
+      >                        m_ptraits;                 // traits class instance
+   flag_type                   m_flags;                   // flags with which we were compiled
+   int                         m_status;                  // error code (0 implies OK).
+   const charT*                m_expression;              // the original expression
+   std::ptrdiff_t              m_expression_len;          // the length of the original expression
+   size_type                   m_mark_count;              // the number of marked sub-expressions
+   BOOST_REGEX_DETAIL_NS::re_syntax_base*  m_first_state;             // the first state of the machine
+   unsigned                    m_restart_type;            // search optimisation type
+   unsigned char               m_startmap[1 << CHAR_BIT]; // which characters can start a match
+   unsigned int                m_can_be_null;             // whether we can match a null string
+   BOOST_REGEX_DETAIL_NS::raw_storage      m_data;                    // the buffer in which our states are constructed
+   typename traits::char_class_type    m_word_mask;       // mask used to determine if a character is a word character
+   std::vector<
+      std::pair<
+      std::size_t, std::size_t> > m_subs;                 // Position of sub-expressions within the *string*.
+   bool                        m_has_recursions;          // whether we have recursive expressions;
+   bool                        m_disable_match_any;       // when set we need to disable the match_any flag as it causes different/buggy behaviour.
+};
+//
+// class basic_regex_implementation
+// pimpl implementation class for basic_regex.
+//
+template <class charT, class traits>
+class basic_regex_implementation
+   : public regex_data<charT, traits>
+{
+public:
+   typedef regex_constants::syntax_option_type   flag_type;
+   typedef std::ptrdiff_t                        difference_type;
+   typedef std::size_t                           size_type; 
+   typedef typename traits::locale_type          locale_type;
+   typedef const charT*                          const_iterator;
+
+   basic_regex_implementation(){}
+   basic_regex_implementation(const ::boost::shared_ptr<
+      ::boost::regex_traits_wrapper<traits> >& t)
+      : regex_data<charT, traits>(t) {}
+   void assign(const charT* arg_first,
+                          const charT* arg_last,
+                          flag_type f)
+   {
+      regex_data<charT, traits>* pdat = this;
+      basic_regex_parser<charT, traits> parser(pdat);
+      parser.parse(arg_first, arg_last, f);
+   }
+
+   locale_type BOOST_REGEX_CALL imbue(locale_type l)
+   { 
+      return this->m_ptraits->imbue(l); 
+   }
+   locale_type BOOST_REGEX_CALL getloc()const
+   { 
+      return this->m_ptraits->getloc(); 
+   }
+   std::basic_string<charT> BOOST_REGEX_CALL str()const
+   {
+      std::basic_string<charT> result;
+      if(this->m_status == 0)
+         result = std::basic_string<charT>(this->m_expression, this->m_expression_len);
+      return result;
+   }
+   const_iterator BOOST_REGEX_CALL expression()const
+   {
+      return this->m_expression;
+   }
+   std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const
+   {
+      const std::pair<std::size_t, std::size_t>& pi = this->m_subs.at(n);
+      std::pair<const_iterator, const_iterator> p(expression() + pi.first, expression() + pi.second);
+      return p;
+   }
+   //
+   // begin, end:
+   const_iterator BOOST_REGEX_CALL begin()const
+   { 
+      return (this->m_status ? 0 : this->m_expression); 
+   }
+   const_iterator BOOST_REGEX_CALL end()const
+   { 
+      return (this->m_status ? 0 : this->m_expression + this->m_expression_len); 
+   }
+   flag_type BOOST_REGEX_CALL flags()const
+   {
+      return this->m_flags;
+   }
+   size_type BOOST_REGEX_CALL size()const
+   {
+      return this->m_expression_len;
+   }
+   int BOOST_REGEX_CALL status()const
+   {
+      return this->m_status;
+   }
+   size_type BOOST_REGEX_CALL mark_count()const
+   {
+      return this->m_mark_count - 1;
+   }
+   const BOOST_REGEX_DETAIL_NS::re_syntax_base* get_first_state()const
+   {
+      return this->m_first_state;
+   }
+   unsigned get_restart_type()const
+   {
+      return this->m_restart_type;
+   }
+   const unsigned char* get_map()const
+   {
+      return this->m_startmap;
+   }
+   const ::boost::regex_traits_wrapper<traits>& get_traits()const
+   {
+      return *(this->m_ptraits);
+   }
+   bool can_be_null()const
+   {
+      return this->m_can_be_null;
+   }
+   const regex_data<charT, traits>& get_data()const
+   {
+      basic_regex_implementation<charT, traits> const* p = this;
+      return *static_cast<const regex_data<charT, traits>*>(p);
+   }
+};
+
+} // namespace BOOST_REGEX_DETAIL_NS
+//
+// class basic_regex:
+// represents the compiled
+// regular expression:
+//
+
+#ifdef BOOST_REGEX_NO_FWD
+template <class charT, class traits = regex_traits<charT> >
+#else
+template <class charT, class traits >
+#endif
+class basic_regex : public regbase
+{
+public:
+   // typedefs:
+   typedef std::size_t                           traits_size_type;
+   typedef typename traits::string_type          traits_string_type;
+   typedef charT                                 char_type;
+   typedef traits                                traits_type;
+
+   typedef charT                                 value_type;
+   typedef charT&                                reference;
+   typedef const charT&                          const_reference;
+   typedef const charT*                          const_iterator;
+   typedef const_iterator                        iterator;
+   typedef std::ptrdiff_t                        difference_type;
+   typedef std::size_t                           size_type;   
+   typedef regex_constants::syntax_option_type   flag_type;
+   // locale_type
+   // placeholder for actual locale type used by the
+   // traits class to localise *this.
+   typedef typename traits::locale_type          locale_type;
+   
+public:
+   explicit basic_regex(){}
+   explicit basic_regex(const charT* p, flag_type f = regex_constants::normal)
+   {
+      assign(p, f);
+   }
+   basic_regex(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)
+   {
+      assign(p1, p2, f);
+   }
+   basic_regex(const charT* p, size_type len, flag_type f)
+   {
+      assign(p, len, f);
+   }
+   basic_regex(const basic_regex& that)
+      : m_pimpl(that.m_pimpl) {}
+   ~basic_regex(){}
+   basic_regex& BOOST_REGEX_CALL operator=(const basic_regex& that)
+   {
+      return assign(that);
+   }
+   basic_regex& BOOST_REGEX_CALL operator=(const charT* ptr)
+   {
+      return assign(ptr);
+   }
+
+   //
+   // assign:
+   basic_regex& assign(const basic_regex& that)
+   { 
+      m_pimpl = that.m_pimpl;
+      return *this; 
+   }
+   basic_regex& assign(const charT* p, flag_type f = regex_constants::normal)
+   {
+      return assign(p, p + traits::length(p), f);
+   }
+   basic_regex& assign(const charT* p, size_type len, flag_type f)
+   {
+      return assign(p, p + len, f);
+   }
+private:
+   basic_regex& do_assign(const charT* p1,
+                          const charT* p2,
+                          flag_type f);
+public:
+   basic_regex& assign(const charT* p1,
+                          const charT* p2,
+                          flag_type f = regex_constants::normal)
+   {
+      return do_assign(p1, p2, f);
+   }
+#if !defined(BOOST_NO_MEMBER_TEMPLATES)
+
+   template <class ST, class SA>
+   unsigned int BOOST_REGEX_CALL set_expression(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)
+   { 
+      return set_expression(p.data(), p.data() + p.size(), f); 
+   }
+
+   template <class ST, class SA>
+   explicit basic_regex(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)
+   { 
+      assign(p, f); 
+   }
+
+   template <class InputIterator>
+   basic_regex(InputIterator arg_first, InputIterator arg_last, flag_type f = regex_constants::normal)
+   {
+      typedef typename traits::string_type seq_type;
+      seq_type a(arg_first, arg_last);
+      if(!a.empty())
+         assign(static_cast<const charT*>(&*a.begin()), static_cast<const charT*>(&*a.begin() + a.size()), f);
+      else
+         assign(static_cast<const charT*>(0), static_cast<const charT*>(0), f);
+   }
+
+   template <class ST, class SA>
+   basic_regex& BOOST_REGEX_CALL operator=(const std::basic_string<charT, ST, SA>& p)
+   {
+      return assign(p.data(), p.data() + p.size(), regex_constants::normal);
+   }
+
+   template <class string_traits, class A>
+   basic_regex& BOOST_REGEX_CALL assign(
+       const std::basic_string<charT, string_traits, A>& s,
+       flag_type f = regex_constants::normal)
+   {
+      return assign(s.data(), s.data() + s.size(), f);
+   }
+
+   template <class InputIterator>
+   basic_regex& BOOST_REGEX_CALL assign(InputIterator arg_first,
+                          InputIterator arg_last,
+                          flag_type f = regex_constants::normal)
+   {
+      typedef typename traits::string_type seq_type;
+      seq_type a(arg_first, arg_last);
+      if(a.size())
+      {
+         const charT* p1 = &*a.begin();
+         const charT* p2 = &*a.begin() + a.size();
+         return assign(p1, p2, f);
+      }
+      return assign(static_cast<const charT*>(0), static_cast<const charT*>(0), f);
+   }
+#else
+   unsigned int BOOST_REGEX_CALL set_expression(const std::basic_string<charT>& p, flag_type f = regex_constants::normal)
+   { 
+      return set_expression(p.data(), p.data() + p.size(), f); 
+   }
+
+   basic_regex(const std::basic_string<charT>& p, flag_type f = regex_constants::normal)
+   { 
+      assign(p, f); 
+   }
+
+   basic_regex& BOOST_REGEX_CALL operator=(const std::basic_string<charT>& p)
+   {
+      return assign(p.data(), p.data() + p.size(), regex_constants::normal);
+   }
+
+   basic_regex& BOOST_REGEX_CALL assign(
+       const std::basic_string<charT>& s,
+       flag_type f = regex_constants::normal)
+   {
+      return assign(s.data(), s.data() + s.size(), f);
+   }
+
+#endif
+
+   //
+   // locale:
+   locale_type BOOST_REGEX_CALL imbue(locale_type l);
+   locale_type BOOST_REGEX_CALL getloc()const
+   { 
+      return m_pimpl.get() ? m_pimpl->getloc() : locale_type(); 
+   }
+   //
+   // getflags:
+   // retained for backwards compatibility only, "flags"
+   // is now the preferred name:
+   flag_type BOOST_REGEX_CALL getflags()const
+   { 
+      return flags();
+   }
+   flag_type BOOST_REGEX_CALL flags()const
+   { 
+      return m_pimpl.get() ? m_pimpl->flags() : 0;
+   }
+   //
+   // str:
+   std::basic_string<charT> BOOST_REGEX_CALL str()const
+   {
+      return m_pimpl.get() ? m_pimpl->str() : std::basic_string<charT>();
+   }
+   //
+   // begin, end, subexpression:
+   std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const
+   {
+      if(!m_pimpl.get())
+         boost::throw_exception(std::logic_error("Can't access subexpressions in an invalid regex."));
+      return m_pimpl->subexpression(n);
+   }
+   const_iterator BOOST_REGEX_CALL begin()const
+   { 
+      return (m_pimpl.get() ? m_pimpl->begin() : 0); 
+   }
+   const_iterator BOOST_REGEX_CALL end()const
+   { 
+      return (m_pimpl.get() ? m_pimpl->end() : 0); 
+   }
+   //
+   // swap:
+   void BOOST_REGEX_CALL swap(basic_regex& that)throw()
+   {
+      m_pimpl.swap(that.m_pimpl);
+   }
+   //
+   // size:
+   size_type BOOST_REGEX_CALL size()const
+   { 
+      return (m_pimpl.get() ? m_pimpl->size() : 0); 
+   }
+   //
+   // max_size:
+   size_type BOOST_REGEX_CALL max_size()const
+   { 
+      return UINT_MAX; 
+   }
+   //
+   // empty:
+   bool BOOST_REGEX_CALL empty()const
+   { 
+      return (m_pimpl.get() ? 0 != m_pimpl->status() : true); 
+   }
+
+   size_type BOOST_REGEX_CALL mark_count()const 
+   { 
+      return (m_pimpl.get() ? m_pimpl->mark_count() : 0); 
+   }
+
+   int status()const
+   {
+      return (m_pimpl.get() ? m_pimpl->status() : regex_constants::error_empty);
+   }
+
+   int BOOST_REGEX_CALL compare(const basic_regex& that) const
+   {
+      if(m_pimpl.get() == that.m_pimpl.get())
+         return 0;
+      if(!m_pimpl.get())
+         return -1;
+      if(!that.m_pimpl.get())
+         return 1;
+      if(status() != that.status())
+         return status() - that.status();
+      if(flags() != that.flags())
+         return flags() - that.flags();
+      return str().compare(that.str());
+   }
+   bool BOOST_REGEX_CALL operator==(const basic_regex& e)const
+   { 
+      return compare(e) == 0; 
+   }
+   bool BOOST_REGEX_CALL operator != (const basic_regex& e)const
+   { 
+      return compare(e) != 0; 
+   }
+   bool BOOST_REGEX_CALL operator<(const basic_regex& e)const
+   { 
+      return compare(e) < 0; 
+   }
+   bool BOOST_REGEX_CALL operator>(const basic_regex& e)const
+   { 
+      return compare(e) > 0; 
+   }
+   bool BOOST_REGEX_CALL operator<=(const basic_regex& e)const
+   { 
+      return compare(e) <= 0; 
+   }
+   bool BOOST_REGEX_CALL operator>=(const basic_regex& e)const
+   { 
+      return compare(e) >= 0; 
+   }
+
+   //
+   // The following are deprecated as public interfaces
+   // but are available for compatibility with earlier versions.
+   const charT* BOOST_REGEX_CALL expression()const 
+   { 
+      return (m_pimpl.get() && !m_pimpl->status() ? m_pimpl->expression() : 0); 
+   }
+   unsigned int BOOST_REGEX_CALL set_expression(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)
+   {
+      assign(p1, p2, f | regex_constants::no_except);
+      return status();
+   }
+   unsigned int BOOST_REGEX_CALL set_expression(const charT* p, flag_type f = regex_constants::normal) 
+   { 
+      assign(p, f | regex_constants::no_except); 
+      return status();
+   }
+   unsigned int BOOST_REGEX_CALL error_code()const
+   {
+      return status();
+   }
+   //
+   // private access methods:
+   //
+   const BOOST_REGEX_DETAIL_NS::re_syntax_base* get_first_state()const
+   {
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
+      return m_pimpl->get_first_state();
+   }
+   unsigned get_restart_type()const
+   {
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
+      return m_pimpl->get_restart_type();
+   }
+   const unsigned char* get_map()const
+   {
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
+      return m_pimpl->get_map();
+   }
+   const ::boost::regex_traits_wrapper<traits>& get_traits()const
+   {
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
+      return m_pimpl->get_traits();
+   }
+   bool can_be_null()const
+   {
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
+      return m_pimpl->can_be_null();
+   }
+   const BOOST_REGEX_DETAIL_NS::regex_data<charT, traits>& get_data()const
+   {
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
+      return m_pimpl->get_data();
+   }
+   boost::shared_ptr<BOOST_REGEX_DETAIL_NS::named_subexpressions > get_named_subs()const
+   {
+      return m_pimpl;
+   }
+
+private:
+   shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > m_pimpl;
+};
+
+//
+// out of line members;
+// these are the only members that mutate the basic_regex object,
+// and are designed to provide the strong exception guarantee
+// (in the event of a throw, the state of the object remains unchanged).
+//
+template <class charT, class traits>
+basic_regex<charT, traits>& basic_regex<charT, traits>::do_assign(const charT* p1,
+                        const charT* p2,
+                        flag_type f)
+{
+   shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > temp;
+   if(!m_pimpl.get())
+   {
+      temp = shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>());
+   }
+   else
+   {
+      temp = shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>(m_pimpl->m_ptraits));
+   }
+   temp->assign(p1, p2, f);
+   temp.swap(m_pimpl);
+   return *this;
+}
+
+template <class charT, class traits>
+typename basic_regex<charT, traits>::locale_type BOOST_REGEX_CALL basic_regex<charT, traits>::imbue(locale_type l)
+{ 
+   shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > temp(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>());
+   locale_type result = temp->imbue(l);
+   temp.swap(m_pimpl);
+   return result;
+}
+
+//
+// non-members:
+//
+template <class charT, class traits>
+void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2)
+{
+   e1.swap(e2);
+}
+
+#ifndef BOOST_NO_STD_LOCALE
+template <class charT, class traits, class traits2>
+std::basic_ostream<charT, traits>& 
+   operator << (std::basic_ostream<charT, traits>& os, 
+                const basic_regex<charT, traits2>& e)
+{
+   return (os << e.str());
+}
+#else
+template <class traits>
+std::ostream& operator << (std::ostream& os, const basic_regex<char, traits>& e)
+{
+   return (os << e.str());
+}
+#endif
+
+//
+// class reg_expression:
+// this is provided for backwards compatibility only,
+// it is deprecated, no not use!
+//
+#ifdef BOOST_REGEX_NO_FWD
+template <class charT, class traits = regex_traits<charT> >
+#else
+template <class charT, class traits >
+#endif
+class reg_expression : public basic_regex<charT, traits>
+{
+public:
+   typedef typename basic_regex<charT, traits>::flag_type flag_type;
+   typedef typename basic_regex<charT, traits>::size_type size_type;
+   explicit reg_expression(){}
+   explicit reg_expression(const charT* p, flag_type f = regex_constants::normal)
+      : basic_regex<charT, traits>(p, f){}
+   reg_expression(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)
+      : basic_regex<charT, traits>(p1, p2, f){}
+   reg_expression(const charT* p, size_type len, flag_type f)
+      : basic_regex<charT, traits>(p, len, f){}
+   reg_expression(const reg_expression& that)
+      : basic_regex<charT, traits>(that) {}
+   ~reg_expression(){}
+   reg_expression& BOOST_REGEX_CALL operator=(const reg_expression& that)
+   {
+      return this->assign(that);
+   }
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATES)
+   template <class ST, class SA>
+   explicit reg_expression(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)
+   : basic_regex<charT, traits>(p, f)
+   { 
+   }
+
+   template <class InputIterator>
+   reg_expression(InputIterator arg_first, InputIterator arg_last, flag_type f = regex_constants::normal)
+   : basic_regex<charT, traits>(arg_first, arg_last, f)
+   {
+   }
+
+   template <class ST, class SA>
+   reg_expression& BOOST_REGEX_CALL operator=(const std::basic_string<charT, ST, SA>& p)
+   {
+      this->assign(p);
+      return *this;
+   }
+#else
+   explicit reg_expression(const std::basic_string<charT>& p, flag_type f = regex_constants::normal)
+   : basic_regex<charT, traits>(p, f)
+   { 
+   }
+
+   reg_expression& BOOST_REGEX_CALL operator=(const std::basic_string<charT>& p)
+   {
+      this->assign(p);
+      return *this;
+   }
+#endif
+
+};
+
+#ifdef BOOST_MSVC
+#pragma warning (pop)
+#endif
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif

lib/third_party/boost/regex/include/boost/regex/v4/c_regex_traits.hpp

@@ -0,0 +1,511 @@
+/*
+ *
+ * Copyright (c) 2004
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         c_regex_traits.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares regular expression traits class that wraps the global C locale.
+  */
+
+#ifndef BOOST_C_REGEX_TRAITS_HPP_INCLUDED
+#define BOOST_C_REGEX_TRAITS_HPP_INCLUDED
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+#ifndef BOOST_REGEX_WORKAROUND_HPP
+#include <boost/regex/v4/regex_workaround.hpp>
+#endif
+
+#include <cctype>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{
+   using ::strlen; using ::tolower;
+}
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103 4244)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+namespace boost{
+
+   namespace BOOST_REGEX_DETAIL_NS {
+
+      enum
+      {
+         char_class_space = 1 << 0,
+         char_class_print = 1 << 1,
+         char_class_cntrl = 1 << 2,
+         char_class_upper = 1 << 3,
+         char_class_lower = 1 << 4,
+         char_class_alpha = 1 << 5,
+         char_class_digit = 1 << 6,
+         char_class_punct = 1 << 7,
+         char_class_xdigit = 1 << 8,
+         char_class_alnum = char_class_alpha | char_class_digit,
+         char_class_graph = char_class_alnum | char_class_punct,
+         char_class_blank = 1 << 9,
+         char_class_word = 1 << 10,
+         char_class_unicode = 1 << 11,
+         char_class_horizontal = 1 << 12,
+         char_class_vertical = 1 << 13
+      };
+
+   }
+
+template <class charT>
+struct c_regex_traits;
+
+template<>
+struct c_regex_traits<char>
+{
+   c_regex_traits(){}
+   typedef char char_type;
+   typedef std::size_t size_type;
+   typedef std::string string_type;
+   struct locale_type{};
+   typedef boost::uint32_t char_class_type;
+
+   static size_type length(const char_type* p) 
+   { 
+      return (std::strlen)(p); 
+   }
+
+   char translate(char c) const 
+   { 
+      return c; 
+   }
+   char translate_nocase(char c) const 
+   { 
+      return static_cast<char>((std::tolower)(static_cast<unsigned char>(c))); 
+   }
+
+   static string_type BOOST_REGEX_CALL transform(const char* p1, const char* p2);
+   static string_type BOOST_REGEX_CALL transform_primary(const char* p1, const char* p2);
+
+   static char_class_type BOOST_REGEX_CALL lookup_classname(const char* p1, const char* p2);
+   static string_type BOOST_REGEX_CALL lookup_collatename(const char* p1, const char* p2);
+
+   static bool BOOST_REGEX_CALL isctype(char, char_class_type);
+   static int BOOST_REGEX_CALL value(char, int);
+
+   locale_type imbue(locale_type l)
+   { return l; }
+   locale_type getloc()const
+   { return locale_type(); }
+
+private:
+   // this type is not copyable:
+   c_regex_traits(const c_regex_traits&);
+   c_regex_traits& operator=(const c_regex_traits&);
+};
+
+#ifndef BOOST_NO_WREGEX
+template<>
+struct c_regex_traits<wchar_t>
+{
+   c_regex_traits(){}
+   typedef wchar_t char_type;
+   typedef std::size_t size_type;
+   typedef std::wstring string_type;
+   struct locale_type{};
+   typedef boost::uint32_t char_class_type;
+
+   static size_type length(const char_type* p) 
+   { 
+      return (std::wcslen)(p); 
+   }
+
+   wchar_t translate(wchar_t c) const 
+   { 
+      return c; 
+   }
+   wchar_t translate_nocase(wchar_t c) const 
+   { 
+      return (std::towlower)(c); 
+   }
+
+   static string_type BOOST_REGEX_CALL transform(const wchar_t* p1, const wchar_t* p2);
+   static string_type BOOST_REGEX_CALL transform_primary(const wchar_t* p1, const wchar_t* p2);
+
+   static char_class_type BOOST_REGEX_CALL lookup_classname(const wchar_t* p1, const wchar_t* p2);
+   static string_type BOOST_REGEX_CALL lookup_collatename(const wchar_t* p1, const wchar_t* p2);
+
+   static bool BOOST_REGEX_CALL isctype(wchar_t, char_class_type);
+   static int BOOST_REGEX_CALL value(wchar_t, int);
+
+   locale_type imbue(locale_type l)
+   { return l; }
+   locale_type getloc()const
+   { return locale_type(); }
+
+private:
+   // this type is not copyable:
+   c_regex_traits(const c_regex_traits&);
+   c_regex_traits& operator=(const c_regex_traits&);
+};
+
+#endif // BOOST_NO_WREGEX
+
+inline c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transform(const char* p1, const char* p2)
+{
+   std::string result(10, ' ');
+   std::size_t s = result.size();
+   std::size_t r;
+   std::string src(p1, p2);
+   while (s < (r = std::strxfrm(&*result.begin(), src.c_str(), s)))
+   {
+#if defined(_CPPLIB_VER)
+      //
+      // A bug in VC11 and 12 causes the program to hang if we pass a null-string
+      // to std::strxfrm, but only for certain locales :-(
+      // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
+      //
+      if (r == INT_MAX)
+      {
+         result.erase();
+         result.insert(result.begin(), static_cast<char>(0));
+         return result;
+      }
+#endif
+      result.append(r - s + 3, ' ');
+      s = result.size();
+   }
+   result.erase(r);
+   return result;
+}
+
+inline c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transform_primary(const char* p1, const char* p2)
+{
+   static char s_delim;
+   static const int s_collate_type = ::boost::BOOST_REGEX_DETAIL_NS::find_sort_syntax(static_cast<c_regex_traits<char>*>(0), &s_delim);
+   std::string result;
+   //
+   // What we do here depends upon the format of the sort key returned by
+   // sort key returned by this->transform:
+   //
+   switch (s_collate_type)
+   {
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_C:
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_unknown:
+      // the best we can do is translate to lower case, then get a regular sort key:
+   {
+      result.assign(p1, p2);
+      for (std::string::size_type i = 0; i < result.size(); ++i)
+         result[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(result[i])));
+      result = transform(&*result.begin(), &*result.begin() + result.size());
+      break;
+   }
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_fixed:
+   {
+      // get a regular sort key, and then truncate it:
+      result = transform(p1, p2);
+      result.erase(s_delim);
+      break;
+   }
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_delim:
+      // get a regular sort key, and then truncate everything after the delim:
+      result = transform(p1, p2);
+      if ((!result.empty()) && (result[0] == s_delim))
+         break;
+      std::size_t i;
+      for (i = 0; i < result.size(); ++i)
+      {
+         if (result[i] == s_delim)
+            break;
+      }
+      result.erase(i);
+      break;
+   }
+   if (result.empty())
+      result = std::string(1, char(0));
+   return result;
+}
+
+inline c_regex_traits<char>::char_class_type BOOST_REGEX_CALL c_regex_traits<char>::lookup_classname(const char* p1, const char* p2)
+{
+   using namespace BOOST_REGEX_DETAIL_NS;
+   static const char_class_type masks[] =
+   {
+      0,
+      char_class_alnum,
+      char_class_alpha,
+      char_class_blank,
+      char_class_cntrl,
+      char_class_digit,
+      char_class_digit,
+      char_class_graph,
+      char_class_horizontal,
+      char_class_lower,
+      char_class_lower,
+      char_class_print,
+      char_class_punct,
+      char_class_space,
+      char_class_space,
+      char_class_upper,
+      char_class_unicode,
+      char_class_upper,
+      char_class_vertical,
+      char_class_alnum | char_class_word,
+      char_class_alnum | char_class_word,
+      char_class_xdigit,
+   };
+
+   int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
+   if (idx < 0)
+   {
+      std::string s(p1, p2);
+      for (std::string::size_type i = 0; i < s.size(); ++i)
+         s[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(s[i])));
+      idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
+   }
+   BOOST_REGEX_ASSERT(std::size_t(idx) + 1u < sizeof(masks) / sizeof(masks[0]));
+   return masks[idx + 1];
+}
+
+inline bool BOOST_REGEX_CALL c_regex_traits<char>::isctype(char c, char_class_type mask)
+{
+   using namespace BOOST_REGEX_DETAIL_NS;
+   return
+      ((mask & char_class_space) && (std::isspace)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_print) && (std::isprint)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_cntrl) && (std::iscntrl)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_upper) && (std::isupper)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_lower) && (std::islower)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_alpha) && (std::isalpha)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_digit) && (std::isdigit)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_punct) && (std::ispunct)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_xdigit) && (std::isxdigit)(static_cast<unsigned char>(c)))
+      || ((mask & char_class_blank) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))
+      || ((mask & char_class_word) && (c == '_'))
+      || ((mask & char_class_vertical) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == '\v')))
+      || ((mask & char_class_horizontal) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && (c != '\v'));
+}
+
+inline c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::lookup_collatename(const char* p1, const char* p2)
+{
+   std::string s(p1, p2);
+   s = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(s);
+   if (s.empty() && (p2 - p1 == 1))
+      s.append(1, *p1);
+   return s;
+}
+
+inline int BOOST_REGEX_CALL c_regex_traits<char>::value(char c, int radix)
+{
+   char b[2] = { c, '\0', };
+   char* ep;
+   int result = std::strtol(b, &ep, radix);
+   if (ep == b)
+      return -1;
+   return result;
+}
+
+#ifndef BOOST_NO_WREGEX
+
+inline c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::transform(const wchar_t* p1, const wchar_t* p2)
+{
+   std::size_t r;
+   std::size_t s = 10;
+   std::wstring src(p1, p2);
+   std::wstring result(s, L' ');
+   while (s < (r = std::wcsxfrm(&*result.begin(), src.c_str(), s)))
+   {
+#if defined(_CPPLIB_VER)
+      //
+      // A bug in VC11 and 12 causes the program to hang if we pass a null-string
+      // to std::strxfrm, but only for certain locales :-(
+      // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
+      //
+      if (r == INT_MAX)
+      {
+         result.erase();
+         result.insert(result.begin(), static_cast<wchar_t>(0));
+         return result;
+      }
+#endif
+      result.append(r - s + 3, L' ');
+      s = result.size();
+   }
+   result.erase(r);
+   return result;
+}
+
+inline c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::transform_primary(const wchar_t* p1, const wchar_t* p2)
+{
+   static wchar_t s_delim;
+   static const int s_collate_type = ::boost::BOOST_REGEX_DETAIL_NS::find_sort_syntax(static_cast<const c_regex_traits<wchar_t>*>(0), &s_delim);
+   std::wstring result;
+   //
+   // What we do here depends upon the format of the sort key returned by
+   // sort key returned by this->transform:
+   //
+   switch (s_collate_type)
+   {
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_C:
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_unknown:
+      // the best we can do is translate to lower case, then get a regular sort key:
+   {
+      result.assign(p1, p2);
+      for (std::wstring::size_type i = 0; i < result.size(); ++i)
+         result[i] = (std::towlower)(result[i]);
+      result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
+      break;
+   }
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_fixed:
+   {
+      // get a regular sort key, and then truncate it:
+      result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
+      result.erase(s_delim);
+      break;
+   }
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_delim:
+      // get a regular sort key, and then truncate everything after the delim:
+      result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
+      if ((!result.empty()) && (result[0] == s_delim))
+         break;
+      std::size_t i;
+      for (i = 0; i < result.size(); ++i)
+      {
+         if (result[i] == s_delim)
+            break;
+      }
+      result.erase(i);
+      break;
+   }
+   if (result.empty())
+      result = std::wstring(1, char(0));
+   return result;
+}
+
+inline c_regex_traits<wchar_t>::char_class_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::lookup_classname(const wchar_t* p1, const wchar_t* p2)
+{
+   using namespace BOOST_REGEX_DETAIL_NS;
+   static const char_class_type masks[] =
+   {
+      0,
+      char_class_alnum,
+      char_class_alpha,
+      char_class_blank,
+      char_class_cntrl,
+      char_class_digit,
+      char_class_digit,
+      char_class_graph,
+      char_class_horizontal,
+      char_class_lower,
+      char_class_lower,
+      char_class_print,
+      char_class_punct,
+      char_class_space,
+      char_class_space,
+      char_class_upper,
+      char_class_unicode,
+      char_class_upper,
+      char_class_vertical,
+      char_class_alnum | char_class_word,
+      char_class_alnum | char_class_word,
+      char_class_xdigit,
+   };
+
+   int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
+   if (idx < 0)
+   {
+      std::wstring s(p1, p2);
+      for (std::wstring::size_type i = 0; i < s.size(); ++i)
+         s[i] = (std::towlower)(s[i]);
+      idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
+   }
+   BOOST_REGEX_ASSERT(idx + 1 < static_cast<int>(sizeof(masks) / sizeof(masks[0])));
+   return masks[idx + 1];
+}
+
+inline bool BOOST_REGEX_CALL c_regex_traits<wchar_t>::isctype(wchar_t c, char_class_type mask)
+{
+   using namespace BOOST_REGEX_DETAIL_NS;
+   return
+      ((mask & char_class_space) && (std::iswspace)(c))
+      || ((mask & char_class_print) && (std::iswprint)(c))
+      || ((mask & char_class_cntrl) && (std::iswcntrl)(c))
+      || ((mask & char_class_upper) && (std::iswupper)(c))
+      || ((mask & char_class_lower) && (std::iswlower)(c))
+      || ((mask & char_class_alpha) && (std::iswalpha)(c))
+      || ((mask & char_class_digit) && (std::iswdigit)(c))
+      || ((mask & char_class_punct) && (std::iswpunct)(c))
+      || ((mask & char_class_xdigit) && (std::iswxdigit)(c))
+      || ((mask & char_class_blank) && (std::iswspace)(c) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))
+      || ((mask & char_class_word) && (c == '_'))
+      || ((mask & char_class_unicode) && (c & ~static_cast<wchar_t>(0xff)))
+      || ((mask & char_class_vertical) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == L'\v')))
+      || ((mask & char_class_horizontal) && (std::iswspace)(c) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && (c != L'\v'));
+}
+
+inline c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::lookup_collatename(const wchar_t* p1, const wchar_t* p2)
+{
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4244)
+#endif
+   std::string name(p1, p2);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+   name = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(name);
+   if (!name.empty())
+      return string_type(name.begin(), name.end());
+   if (p2 - p1 == 1)
+      return string_type(1, *p1);
+   return string_type();
+}
+
+inline int BOOST_REGEX_CALL c_regex_traits<wchar_t>::value(wchar_t c, int radix)
+{
+#ifdef BOOST_BORLANDC
+   // workaround for broken wcstol:
+   if ((std::iswxdigit)(c) == 0)
+      return -1;
+#endif
+   wchar_t b[2] = { c, '\0', };
+   wchar_t* ep;
+   int result = std::wcstol(b, &ep, radix);
+   if (ep == b)
+      return -1;
+   return result;
+}
+
+#endif
+
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif
+
+
+

lib/third_party/boost/regex/include/boost/regex/v4/char_regex_traits.hpp

@@ -0,0 +1,81 @@
+/*
+ *
+ * Copyright (c) 2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the
+ * Boost Software License, Version 1.0. (See accompanying file
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         char_regex_traits.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares deprecated traits classes char_regex_traits<>.
+  */
+
+
+#ifndef BOOST_REGEX_V4_CHAR_REGEX_TRAITS_HPP
+#define BOOST_REGEX_V4_CHAR_REGEX_TRAITS_HPP
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+namespace boost{
+
+namespace deprecated{
+//
+// class char_regex_traits_i
+// provides case insensitive traits classes (deprecated):
+template <class charT>
+class char_regex_traits_i : public regex_traits<charT> {};
+
+template<>
+class char_regex_traits_i<char> : public regex_traits<char>
+{
+public:
+   typedef char char_type;
+   typedef unsigned char uchar_type;
+   typedef unsigned int size_type;
+   typedef regex_traits<char> base_type;
+
+};
+
+#ifndef BOOST_NO_WREGEX
+template<>
+class char_regex_traits_i<wchar_t> : public regex_traits<wchar_t>
+{
+public:
+   typedef wchar_t char_type;
+   typedef unsigned short uchar_type;
+   typedef unsigned int size_type;
+   typedef regex_traits<wchar_t> base_type;
+
+};
+#endif
+} // namespace deprecated
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // include
+

lib/third_party/boost/regex/include/boost/regex/v4/cregex.hpp

@@ -0,0 +1,213 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the
+ * Boost Software License, Version 1.0. (See accompanying file
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         cregex.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares POSIX API functions
+  *                + boost::RegEx high level wrapper.
+  */
+
+#ifndef BOOST_RE_CREGEX_HPP_INCLUDED
+#define BOOST_RE_CREGEX_HPP_INCLUDED
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+#include <boost/regex/v4/match_flags.hpp>
+#include <boost/regex/v4/error_type.hpp>
+
+#ifdef __cplusplus
+#include <cstddef>
+#else
+#include <stddef.h>
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+/* include these defs only for POSIX compatablity */
+#ifdef __cplusplus
+namespace boost{
+extern "C" {
+#endif
+
+#if defined(__cplusplus) && !defined(BOOST_NO_STDC_NAMESPACE)
+typedef std::ptrdiff_t regoff_t;
+typedef std::size_t regsize_t;
+#else
+typedef ptrdiff_t regoff_t;
+typedef size_t regsize_t;
+#endif
+
+typedef struct
+{
+   unsigned int re_magic;
+#ifdef __cplusplus
+   std::size_t  re_nsub;      /* number of parenthesized subexpressions */
+#else
+   size_t re_nsub; 
+#endif
+   const char*  re_endp;       /* end pointer for REG_PEND */
+   void* guts;                /* none of your business :-) */
+   match_flag_type eflags;        /* none of your business :-) */
+} regex_tA;
+
+#ifndef BOOST_NO_WREGEX
+typedef struct
+{
+   unsigned int re_magic;
+#ifdef __cplusplus
+   std::size_t  re_nsub;         /* number of parenthesized subexpressions */
+#else
+   size_t re_nsub;
+#endif
+   const wchar_t* re_endp;       /* end pointer for REG_PEND */
+   void* guts;                   /* none of your business :-) */
+   match_flag_type eflags;           /* none of your business :-) */
+} regex_tW;
+#endif
+
+typedef struct
+{
+   regoff_t rm_so;      /* start of match */
+   regoff_t rm_eo;      /* end of match */
+} regmatch_t;
+
+/* regcomp() flags */
+typedef enum{
+   REG_BASIC = 0000,
+   REG_EXTENDED = 0001,
+   REG_ICASE = 0002,
+   REG_NOSUB = 0004,
+   REG_NEWLINE = 0010,
+   REG_NOSPEC = 0020,
+   REG_PEND = 0040,
+   REG_DUMP = 0200,
+   REG_NOCOLLATE = 0400,
+   REG_ESCAPE_IN_LISTS = 01000,
+   REG_NEWLINE_ALT = 02000,
+   REG_PERLEX = 04000,
+
+   REG_PERL = REG_EXTENDED | REG_NOCOLLATE | REG_ESCAPE_IN_LISTS | REG_PERLEX,
+   REG_AWK = REG_EXTENDED | REG_ESCAPE_IN_LISTS,
+   REG_GREP = REG_BASIC | REG_NEWLINE_ALT,
+   REG_EGREP = REG_EXTENDED | REG_NEWLINE_ALT,
+
+   REG_ASSERT = 15,
+   REG_INVARG = 16,
+   REG_ATOI = 255,   /* convert name to number (!) */
+   REG_ITOA = 0400   /* convert number to name (!) */
+} reg_comp_flags;
+
+/* regexec() flags */
+typedef enum{
+   REG_NOTBOL =    00001,
+   REG_NOTEOL =    00002,
+   REG_STARTEND =  00004
+} reg_exec_flags;
+
+/*
+ * POSIX error codes:
+ */
+typedef unsigned reg_error_t;
+typedef reg_error_t reg_errcode_t;  /* backwards compatibility */
+
+static const reg_error_t REG_NOERROR = 0;   /* Success.  */
+static const reg_error_t REG_NOMATCH = 1;   /* Didn't find a match (for regexec).  */
+
+  /* POSIX regcomp return error codes.  (In the order listed in the
+     standard.)  */
+static const reg_error_t REG_BADPAT = 2;    /* Invalid pattern.  */
+static const reg_error_t REG_ECOLLATE = 3;  /* Undefined collating element.  */
+static const reg_error_t REG_ECTYPE = 4;    /* Invalid character class name.  */
+static const reg_error_t REG_EESCAPE = 5;   /* Trailing backslash.  */
+static const reg_error_t REG_ESUBREG = 6;   /* Invalid back reference.  */
+static const reg_error_t REG_EBRACK = 7;    /* Unmatched left bracket.  */
+static const reg_error_t REG_EPAREN = 8;    /* Parenthesis imbalance.  */
+static const reg_error_t REG_EBRACE = 9;    /* Unmatched \{.  */
+static const reg_error_t REG_BADBR = 10;    /* Invalid contents of \{\}.  */
+static const reg_error_t REG_ERANGE = 11;   /* Invalid range end.  */
+static const reg_error_t REG_ESPACE = 12;   /* Ran out of memory.  */
+static const reg_error_t REG_BADRPT = 13;   /* No preceding re for repetition op.  */
+static const reg_error_t REG_EEND = 14;     /* unexpected end of expression */
+static const reg_error_t REG_ESIZE = 15;    /* expression too big */
+static const reg_error_t REG_ERPAREN = 8;   /* = REG_EPAREN : unmatched right parenthesis */
+static const reg_error_t REG_EMPTY = 17;    /* empty expression */
+static const reg_error_t REG_E_MEMORY = 15; /* = REG_ESIZE : out of memory */
+static const reg_error_t REG_ECOMPLEXITY = 18; /* complexity too high */
+static const reg_error_t REG_ESTACK = 19;   /* out of stack space */
+static const reg_error_t REG_E_PERL = 20;   /* Perl (?...) error */
+static const reg_error_t REG_E_UNKNOWN = 21; /* unknown error */
+static const reg_error_t REG_ENOSYS = 21;   /* = REG_E_UNKNOWN : Reserved. */
+
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompA(regex_tA*, const char*, int);
+BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int, const regex_tA*, char*, regsize_t);
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecA(const regex_tA*, const char*, regsize_t, regmatch_t*, int);
+BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeA(regex_tA*);
+
+#ifndef BOOST_NO_WREGEX
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW*, const wchar_t*, int);
+BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int, const regex_tW*, wchar_t*, regsize_t);
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecW(const regex_tW*, const wchar_t*, regsize_t, regmatch_t*, int);
+BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeW(regex_tW*);
+#endif
+
+#ifdef UNICODE
+#define regcomp regcompW
+#define regerror regerrorW
+#define regexec regexecW
+#define regfree regfreeW
+#define regex_t regex_tW
+#else
+#define regcomp regcompA
+#define regerror regerrorA
+#define regexec regexecA
+#define regfree regfreeA
+#define regex_t regex_tA
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+} /* namespace */
+#endif
+
+#endif /* include guard */
+
+
+
+
+
+
+
+
+
+

lib/third_party/boost/regex/include/boost/regex/v4/error_type.hpp

@@ -0,0 +1,59 @@
+/*
+ *
+ * Copyright (c) 2003-2005
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the
+ * Boost Software License, Version 1.0. (See accompanying file
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         error_type.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares regular expression error type enumerator.
+  */
+
+#ifndef BOOST_REGEX_ERROR_TYPE_HPP
+#define BOOST_REGEX_ERROR_TYPE_HPP
+
+#ifdef __cplusplus
+namespace boost{
+#endif
+
+#ifdef __cplusplus
+namespace regex_constants{
+
+enum error_type{
+
+   error_ok = 0,         /* not used */
+   error_no_match = 1,   /* not used */
+   error_bad_pattern = 2,
+   error_collate = 3,
+   error_ctype = 4,
+   error_escape = 5,
+   error_backref = 6,
+   error_brack = 7,
+   error_paren = 8,
+   error_brace = 9,
+   error_badbrace = 10,
+   error_range = 11,
+   error_space = 12,
+   error_badrepeat = 13,
+   error_end = 14,    /* not used */
+   error_size = 15,
+   error_right_paren = 16,  /* not used */
+   error_empty = 17,
+   error_complexity = 18,
+   error_stack = 19,
+   error_perl_extension = 20,
+   error_unknown = 21
+};
+
+}
+}
+#endif /* __cplusplus */
+
+#endif

lib/third_party/boost/regex/include/boost/regex/v4/indexed_bit_flag.hpp

@@ -0,0 +1,54 @@
+/*
+ *
+ * Copyright (c) 2020
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         basic_regex_parser.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares template class basic_regex_parser.
+  */
+
+#include <boost/regex/config.hpp>
+#include <set>
+
+#ifndef BOOST_REGEX_V4_INDEXED_BIT_FLAG_HPP
+#define BOOST_REGEX_V4_INDEXED_BIT_FLAG_HPP
+
+namespace boost{
+namespace BOOST_REGEX_DETAIL_NS{
+
+class indexed_bit_flag
+{
+   boost::uint64_t low_mask;
+   std::set<std::size_t> mask_set;
+public:
+   indexed_bit_flag() : low_mask(0) {}
+   void set(std::size_t i)
+   {
+      if (i < std::numeric_limits<boost::uint64_t>::digits - 1)
+         low_mask |= static_cast<boost::uint64_t>(1u) << i;
+      else
+         mask_set.insert(i);
+   }
+   bool test(std::size_t i)
+   {
+      if (i < std::numeric_limits<boost::uint64_t>::digits - 1)
+         return low_mask & static_cast<boost::uint64_t>(1u) << i ? true : false;
+      else
+         return mask_set.find(i) != mask_set.end();
+   }
+};
+
+} // namespace BOOST_REGEX_DETAIL_NS
+} // namespace boost
+
+
+#endif

lib/third_party/boost/regex/include/boost/regex/v4/iterator_category.hpp

@@ -0,0 +1,91 @@
+/*
+ *
+ * Copyright (c) 2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_match.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Iterator traits for selecting an iterator type as
+  *                an integral constant expression.
+  */
+
+
+#ifndef BOOST_REGEX_ITERATOR_CATEGORY_HPP
+#define BOOST_REGEX_ITERATOR_CATEGORY_HPP
+
+#include <iterator>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+
+namespace boost{
+namespace detail{
+
+template <class I>
+struct is_random_imp
+{
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+private:
+   typedef typename std::iterator_traits<I>::iterator_category cat;
+public:
+   BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible<cat*, std::random_access_iterator_tag*>::value));
+#else
+   BOOST_STATIC_CONSTANT(bool, value = false);
+#endif
+};
+
+template <class I>
+struct is_random_pointer_imp
+{
+   BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <bool is_pointer_type>
+struct is_random_imp_selector
+{
+   template <class I>
+   struct rebind
+   {
+      typedef is_random_imp<I> type;
+   };
+};
+
+template <>
+struct is_random_imp_selector<true>
+{
+   template <class I>
+   struct rebind
+   {
+      typedef is_random_pointer_imp<I> type;
+   };
+};
+
+}
+
+template <class I>
+struct is_random_access_iterator
+{
+private:
+   typedef detail::is_random_imp_selector< ::boost::is_pointer<I>::value> selector;
+   typedef typename selector::template rebind<I> bound_type;
+   typedef typename bound_type::type answer;
+public:
+   BOOST_STATIC_CONSTANT(bool, value = answer::value);
+};
+
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+template <class I>
+const bool is_random_access_iterator<I>::value;
+#endif
+
+}
+
+#endif
+

lib/third_party/boost/regex/include/boost/regex/v4/iterator_traits.hpp

@@ -0,0 +1,135 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         iterator_traits.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares iterator traits workarounds.
+  */
+
+#ifndef BOOST_REGEX_V4_ITERATOR_TRAITS_HPP
+#define BOOST_REGEX_V4_ITERATOR_TRAITS_HPP
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+namespace boost{
+namespace BOOST_REGEX_DETAIL_NS{
+
+#if defined(BOOST_NO_STD_ITERATOR_TRAITS)
+
+template <class T>
+struct regex_iterator_traits 
+{
+  typedef typename T::iterator_category iterator_category;
+  typedef typename T::value_type        value_type;
+#if !defined(BOOST_NO_STD_ITERATOR)
+  typedef typename T::difference_type   difference_type;
+  typedef typename T::pointer           pointer;
+  typedef typename T::reference         reference;
+#else
+  typedef std::ptrdiff_t                difference_type;
+  typedef value_type*                   pointer;
+  typedef value_type&                   reference;
+#endif
+};
+
+template <class T>
+struct pointer_iterator_traits
+{
+   typedef std::ptrdiff_t difference_type;
+   typedef T value_type;
+   typedef T* pointer;
+   typedef T& reference;
+   typedef std::random_access_iterator_tag iterator_category;
+};
+template <class T>
+struct const_pointer_iterator_traits
+{
+   typedef std::ptrdiff_t difference_type;
+   typedef T value_type;
+   typedef const T* pointer;
+   typedef const T& reference;
+   typedef std::random_access_iterator_tag iterator_category;
+};
+
+template<>
+struct regex_iterator_traits<char*> : pointer_iterator_traits<char>{};
+template<>
+struct regex_iterator_traits<const char*> : const_pointer_iterator_traits<char>{};
+template<>
+struct regex_iterator_traits<wchar_t*> : pointer_iterator_traits<wchar_t>{};
+template<>
+struct regex_iterator_traits<const wchar_t*> : const_pointer_iterator_traits<wchar_t>{};
+//
+// the follwoing are needed for ICU support:
+//
+template<>
+struct regex_iterator_traits<unsigned char*> : pointer_iterator_traits<char>{};
+template<>
+struct regex_iterator_traits<const unsigned char*> : const_pointer_iterator_traits<char>{};
+template<>
+struct regex_iterator_traits<int*> : pointer_iterator_traits<int>{};
+template<>
+struct regex_iterator_traits<const int*> : const_pointer_iterator_traits<int>{};
+
+#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
+template<>
+struct regex_iterator_traits<unsigned short*> : pointer_iterator_traits<unsigned short>{};
+template<>
+struct regex_iterator_traits<const unsigned short*> : const_pointer_iterator_traits<unsigned short>{};
+#endif
+
+#if defined(__SGI_STL_PORT) && defined(__STL_DEBUG)
+template<>
+struct regex_iterator_traits<std::string::iterator> : pointer_iterator_traits<char>{};
+template<>
+struct regex_iterator_traits<std::string::const_iterator> : const_pointer_iterator_traits<char>{};
+#ifndef BOOST_NO_STD_WSTRING
+template<>
+struct regex_iterator_traits<std::wstring::iterator> : pointer_iterator_traits<wchar_t>{};
+template<>
+struct regex_iterator_traits<std::wstring::const_iterator> : const_pointer_iterator_traits<wchar_t>{};
+#endif // BOOST_NO_WSTRING
+#endif // stport
+
+#else
+
+template <class T>
+struct regex_iterator_traits : public std::iterator_traits<T> {};
+
+#endif
+
+} // namespace BOOST_REGEX_DETAIL_NS
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif
+

lib/third_party/boost/regex/include/boost/regex/v4/match_flags.hpp

@@ -0,0 +1,161 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         match_flags.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares match_flags type.
+  */
+
+#ifndef BOOST_REGEX_V4_MATCH_FLAGS
+#define BOOST_REGEX_V4_MATCH_FLAGS
+
+#ifdef __cplusplus
+#  include <boost/cstdint.hpp>
+#endif
+
+#ifdef __cplusplus
+namespace boost{
+   namespace regex_constants{
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#if BOOST_MSVC >= 1800
+#pragma warning(disable : 26812)
+#endif
+#endif
+
+typedef enum _match_flags
+{
+   match_default = 0,
+   match_not_bol = 1,                                /* first is not start of line */
+   match_not_eol = match_not_bol << 1,               /* last is not end of line */
+   match_not_bob = match_not_eol << 1,               /* first is not start of buffer */
+   match_not_eob = match_not_bob << 1,               /* last is not end of buffer */
+   match_not_bow = match_not_eob << 1,               /* first is not start of word */
+   match_not_eow = match_not_bow << 1,               /* last is not end of word */
+   match_not_dot_newline = match_not_eow << 1,       /* \n is not matched by '.' */
+   match_not_dot_null = match_not_dot_newline << 1,  /* '\0' is not matched by '.' */
+   match_prev_avail = match_not_dot_null << 1,       /* *--first is a valid expression */
+   match_init = match_prev_avail << 1,               /* internal use */
+   match_any = match_init << 1,                      /* don't care what we match */
+   match_not_null = match_any << 1,                  /* string can't be null */
+   match_continuous = match_not_null << 1,           /* each grep match must continue from */
+                                                     /* uninterrupted from the previous one */
+   match_partial = match_continuous << 1,            /* find partial matches */
+   
+   match_stop = match_partial << 1,                  /* stop after first match (grep) V3 only */
+   match_not_initial_null = match_stop,              /* don't match initial null, V4 only */
+   match_all = match_stop << 1,                      /* must find the whole of input even if match_any is set */
+   match_perl = match_all << 1,                      /* Use perl matching rules */
+   match_posix = match_perl << 1,                    /* Use POSIX matching rules */
+   match_nosubs = match_posix << 1,                  /* don't trap marked subs */
+   match_extra = match_nosubs << 1,                  /* include full capture information for repeated captures */
+   match_single_line = match_extra << 1,             /* treat text as single line and ignore any \n's when matching ^ and $. */
+   match_unused1 = match_single_line << 1,           /* unused */
+   match_unused2 = match_unused1 << 1,               /* unused */
+   match_unused3 = match_unused2 << 1,               /* unused */
+   match_max = match_unused3,
+
+   format_perl = 0,                                  /* perl style replacement */
+   format_default = 0,                               /* ditto. */
+   format_sed = match_max << 1,                      /* sed style replacement. */
+   format_all = format_sed << 1,                     /* enable all extensions to syntax. */
+   format_no_copy = format_all << 1,                 /* don't copy non-matching segments. */
+   format_first_only = format_no_copy << 1,          /* Only replace first occurrence. */
+   format_is_if = format_first_only << 1,            /* internal use only. */
+   format_literal = format_is_if << 1,               /* treat string as a literal */
+
+   match_not_any = match_not_bol | match_not_eol | match_not_bob 
+      | match_not_eob | match_not_bow | match_not_eow | match_not_dot_newline 
+      | match_not_dot_null | match_prev_avail | match_init | match_not_null
+      | match_continuous | match_partial | match_stop | match_not_initial_null 
+      | match_stop | match_all | match_perl | match_posix | match_nosubs
+      | match_extra | match_single_line | match_unused1 | match_unused2 
+      | match_unused3 | match_max | format_perl | format_default | format_sed
+      | format_all | format_no_copy | format_first_only | format_is_if
+      | format_literal
+
+
+} match_flags;
+
+#if defined(BOOST_BORLANDC) || (defined(_MSC_VER) && (_MSC_VER <= 1310))
+typedef unsigned long match_flag_type;
+#else
+typedef match_flags match_flag_type;
+
+
+#ifdef __cplusplus
+inline match_flags operator&(match_flags m1, match_flags m2)
+{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) & static_cast<boost::int32_t>(m2)); }
+inline match_flags operator|(match_flags m1, match_flags m2)
+{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) | static_cast<boost::int32_t>(m2)); }
+inline match_flags operator^(match_flags m1, match_flags m2)
+{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) ^ static_cast<boost::int32_t>(m2)); }
+inline match_flags operator~(match_flags m1)
+{ return static_cast<match_flags>(~static_cast<boost::int32_t>(m1)); }
+inline match_flags& operator&=(match_flags& m1, match_flags m2)
+{ m1 = m1&m2; return m1; }
+inline match_flags& operator|=(match_flags& m1, match_flags m2)
+{ m1 = m1|m2; return m1; }
+inline match_flags& operator^=(match_flags& m1, match_flags m2)
+{ m1 = m1^m2; return m1; }
+#endif
+#endif
+
+#ifdef __cplusplus
+} /* namespace regex_constants */
+/*
+ * import names into boost for backwards compatibility:
+ */
+using regex_constants::match_flag_type;
+using regex_constants::match_default;
+using regex_constants::match_not_bol;
+using regex_constants::match_not_eol;
+using regex_constants::match_not_bob;
+using regex_constants::match_not_eob;
+using regex_constants::match_not_bow;
+using regex_constants::match_not_eow;
+using regex_constants::match_not_dot_newline;
+using regex_constants::match_not_dot_null;
+using regex_constants::match_prev_avail;
+/* using regex_constants::match_init; */
+using regex_constants::match_any;
+using regex_constants::match_not_null;
+using regex_constants::match_continuous;
+using regex_constants::match_partial;
+/*using regex_constants::match_stop; */
+using regex_constants::match_all;
+using regex_constants::match_perl;
+using regex_constants::match_posix;
+using regex_constants::match_nosubs;
+using regex_constants::match_extra;
+using regex_constants::match_single_line;
+/*using regex_constants::match_max; */
+using regex_constants::format_all;
+using regex_constants::format_sed;
+using regex_constants::format_perl;
+using regex_constants::format_default;
+using regex_constants::format_no_copy;
+using regex_constants::format_first_only;
+/*using regex_constants::format_is_if;*/
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+
+} /* namespace boost */
+#endif /* __cplusplus */
+#endif /* include guard */
+

lib/third_party/boost/regex/include/boost/regex/v4/match_results.hpp

@@ -0,0 +1,716 @@
+/*
+ *
+ * Copyright (c) 1998-2009
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         match_results.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares template class match_results.
+  */
+
+#ifndef BOOST_REGEX_V4_MATCH_RESULTS_HPP
+#define BOOST_REGEX_V4_MATCH_RESULTS_HPP
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+namespace boost{
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#if BOOST_MSVC < 1700
+#     pragma warning(disable : 4231)
+#endif
+#  if BOOST_MSVC < 1600
+#     pragma warning(disable : 4660)
+#  endif
+#endif
+
+namespace BOOST_REGEX_DETAIL_NS{
+
+class named_subexpressions;
+
+}
+
+template <class BidiIterator, class Allocator>
+class match_results
+{ 
+private:
+#ifndef BOOST_NO_STD_ALLOCATOR
+   typedef          std::vector<sub_match<BidiIterator>, Allocator> vector_type;
+#else
+   typedef          std::vector<sub_match<BidiIterator> >           vector_type;
+#endif
+public: 
+   typedef          sub_match<BidiIterator>                         value_type;
+#ifndef BOOST_NO_CXX11_ALLOCATOR
+   typedef typename std::allocator_traits<Allocator>::value_type const &    const_reference;
+#elif  !defined(BOOST_NO_STD_ALLOCATOR) && !(defined(BOOST_MSVC) && defined(_STLPORT_VERSION))
+   typedef typename Allocator::const_reference                              const_reference;
+#else
+   typedef          const value_type&                                       const_reference;
+#endif
+   typedef          const_reference                                         reference;
+   typedef typename vector_type::const_iterator                             const_iterator;
+   typedef          const_iterator                                          iterator;
+   typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<
+                                    BidiIterator>::difference_type          difference_type;
+#ifdef BOOST_NO_CXX11_ALLOCATOR
+   typedef typename Allocator::size_type                                    size_type;
+#else
+   typedef typename std::allocator_traits<Allocator>::size_type             size_type;
+#endif
+   typedef          Allocator                                               allocator_type;
+   typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<
+                                    BidiIterator>::value_type               char_type;
+   typedef          std::basic_string<char_type>                            string_type;
+   typedef          BOOST_REGEX_DETAIL_NS::named_subexpressions                         named_sub_type;
+
+   // construct/copy/destroy:
+   explicit match_results(const Allocator& a = Allocator())
+#ifndef BOOST_NO_STD_ALLOCATOR
+      : m_subs(a), m_base(), m_null(), m_last_closed_paren(0), m_is_singular(true) {}
+#else
+      : m_subs(), m_base(), m_null(), m_last_closed_paren(0), m_is_singular(true) { (void)a; }
+#endif
+   //
+   // IMPORTANT: in the code below, the crazy looking checks around m_is_singular are
+   // all required because it is illegal to copy a singular iterator.
+   // See https://svn.boost.org/trac/boost/ticket/3632.
+   //
+   match_results(const match_results& m)
+      : m_subs(m.m_subs), m_base(), m_null(), m_named_subs(m.m_named_subs), m_last_closed_paren(m.m_last_closed_paren), m_is_singular(m.m_is_singular)
+   {
+      if(!m_is_singular)
+      {
+         m_base = m.m_base;
+         m_null = m.m_null;
+      }
+   }
+   match_results& operator=(const match_results& m)
+   {
+      m_subs = m.m_subs;
+      m_named_subs = m.m_named_subs;
+      m_last_closed_paren = m.m_last_closed_paren;
+      m_is_singular = m.m_is_singular;
+      if(!m_is_singular)
+      {
+         m_base = m.m_base;
+         m_null = m.m_null;
+      }
+      return *this;
+   }
+   ~match_results(){}
+
+   // size:
+   size_type size() const
+   { return empty() ? 0 : m_subs.size() - 2; }
+   size_type max_size() const
+   { return m_subs.max_size(); }
+   bool empty() const
+   { return m_subs.size() < 2; }
+   // element access:
+   difference_type length(int sub = 0) const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      sub += 2;
+      if((sub < (int)m_subs.size()) && (sub > 0))
+         return m_subs[sub].length();
+      return 0;
+   }
+   difference_type length(const char_type* sub) const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      const char_type* sub_end = sub;
+      while(*sub_end) ++sub_end;
+      return length(named_subexpression_index(sub, sub_end));
+   }
+   template <class charT>
+   difference_type length(const charT* sub) const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      const charT* sub_end = sub;
+      while(*sub_end) ++sub_end;
+      return length(named_subexpression_index(sub, sub_end));
+   }
+   template <class charT, class Traits, class A>
+   difference_type length(const std::basic_string<charT, Traits, A>& sub) const
+   {
+      return length(sub.c_str());
+   }
+   difference_type position(size_type sub = 0) const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      sub += 2;
+      if(sub < m_subs.size())
+      {
+         const sub_match<BidiIterator>& s = m_subs[sub];
+         if(s.matched || (sub == 2))
+         {
+            return ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)(m_base), (BidiIterator)(s.first));
+         }
+      }
+      return ~static_cast<difference_type>(0);
+   }
+   difference_type position(const char_type* sub) const
+   {
+      const char_type* sub_end = sub;
+      while(*sub_end) ++sub_end;
+      return position(named_subexpression_index(sub, sub_end));
+   }
+   template <class charT>
+   difference_type position(const charT* sub) const
+   {
+      const charT* sub_end = sub;
+      while(*sub_end) ++sub_end;
+      return position(named_subexpression_index(sub, sub_end));
+   }
+   template <class charT, class Traits, class A>
+   difference_type position(const std::basic_string<charT, Traits, A>& sub) const
+   {
+      return position(sub.c_str());
+   }
+   string_type str(int sub = 0) const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      sub += 2;
+      string_type result;
+      if(sub < (int)m_subs.size() && (sub > 0))
+      {
+         const sub_match<BidiIterator>& s = m_subs[sub];
+         if(s.matched)
+         {
+            result = s.str();
+         }
+      }
+      return result;
+   }
+   string_type str(const char_type* sub) const
+   {
+      return (*this)[sub].str();
+   }
+   template <class Traits, class A>
+   string_type str(const std::basic_string<char_type, Traits, A>& sub) const
+   {
+      return (*this)[sub].str();
+   }
+   template <class charT>
+   string_type str(const charT* sub) const
+   {
+      return (*this)[sub].str();
+   }
+   template <class charT, class Traits, class A>
+   string_type str(const std::basic_string<charT, Traits, A>& sub) const
+   {
+      return (*this)[sub].str();
+   }
+   const_reference operator[](int sub) const
+   {
+      if(m_is_singular && m_subs.empty())
+         raise_logic_error();
+      sub += 2;
+      if(sub < (int)m_subs.size() && (sub >= 0))
+      {
+         return m_subs[sub];
+      }
+      return m_null;
+   }
+   //
+   // Named sub-expressions:
+   //
+   const_reference named_subexpression(const char_type* i, const char_type* j) const
+   {
+      //
+      // Scan for the leftmost *matched* subexpression with the specified named:
+      //
+      if(m_is_singular)
+         raise_logic_error();
+      BOOST_REGEX_DETAIL_NS::named_subexpressions::range_type r = m_named_subs->equal_range(i, j);
+      while((r.first != r.second) && ((*this)[r.first->index].matched == false))
+         ++r.first;
+      return r.first != r.second ? (*this)[r.first->index] : m_null;
+   }
+   template <class charT>
+   const_reference named_subexpression(const charT* i, const charT* j) const
+   {
+      BOOST_STATIC_ASSERT(sizeof(charT) <= sizeof(char_type));
+      if(i == j)
+         return m_null;
+      std::vector<char_type> s;
+      while(i != j)
+         s.insert(s.end(), *i++);
+      return named_subexpression(&*s.begin(), &*s.begin() + s.size());
+   }
+   int named_subexpression_index(const char_type* i, const char_type* j) const
+   {
+      //
+      // Scan for the leftmost *matched* subexpression with the specified named.
+      // If none found then return the leftmost expression with that name,
+      // otherwise an invalid index:
+      //
+      if(m_is_singular)
+         raise_logic_error();
+      BOOST_REGEX_DETAIL_NS::named_subexpressions::range_type s, r;
+      s = r = m_named_subs->equal_range(i, j);
+      while((r.first != r.second) && ((*this)[r.first->index].matched == false))
+         ++r.first;
+      if(r.first == r.second)
+         r = s;
+      return r.first != r.second ? r.first->index : -20;
+   }
+   template <class charT>
+   int named_subexpression_index(const charT* i, const charT* j) const
+   {
+      BOOST_STATIC_ASSERT(sizeof(charT) <= sizeof(char_type));
+      if(i == j)
+         return -20;
+      std::vector<char_type> s;
+      while(i != j)
+         s.insert(s.end(), *i++);
+      return named_subexpression_index(&*s.begin(), &*s.begin() + s.size());
+   }
+   template <class Traits, class A>
+   const_reference operator[](const std::basic_string<char_type, Traits, A>& s) const
+   {
+      return named_subexpression(s.c_str(), s.c_str() + s.size());
+   }
+   const_reference operator[](const char_type* p) const
+   {
+      const char_type* e = p;
+      while(*e) ++e;
+      return named_subexpression(p, e);
+   }
+
+   template <class charT>
+   const_reference operator[](const charT* p) const
+   {
+      BOOST_STATIC_ASSERT(sizeof(charT) <= sizeof(char_type));
+      if(*p == 0)
+         return m_null;
+      std::vector<char_type> s;
+      while(*p)
+         s.insert(s.end(), *p++);
+      return named_subexpression(&*s.begin(), &*s.begin() + s.size());
+   }
+   template <class charT, class Traits, class A>
+   const_reference operator[](const std::basic_string<charT, Traits, A>& ns) const
+   {
+      BOOST_STATIC_ASSERT(sizeof(charT) <= sizeof(char_type));
+      if(ns.empty())
+         return m_null;
+      std::vector<char_type> s;
+      for(unsigned i = 0; i < ns.size(); ++i)
+         s.insert(s.end(), ns[i]);
+      return named_subexpression(&*s.begin(), &*s.begin() + s.size());
+   }
+
+   const_reference prefix() const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      return (*this)[-1];
+   }
+
+   const_reference suffix() const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      return (*this)[-2];
+   }
+   const_iterator begin() const
+   {
+      return (m_subs.size() > 2) ? (m_subs.begin() + 2) : m_subs.end();
+   }
+   const_iterator end() const
+   {
+      return m_subs.end();
+   }
+   // format:
+   template <class OutputIterator, class Functor>
+   OutputIterator format(OutputIterator out,
+                         Functor fmt,
+                         match_flag_type flags = format_default) const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator>::type F;
+      F func(fmt);
+      return func(*this, out, flags);
+   }
+   template <class Functor>
+   string_type format(Functor fmt, match_flag_type flags = format_default) const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      std::basic_string<char_type> result;
+      BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> > i(result);
+
+      typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> > >::type F;
+      F func(fmt);
+
+      func(*this, i, flags);
+      return result;
+   }
+   // format with locale:
+   template <class OutputIterator, class Functor, class RegexT>
+   OutputIterator format(OutputIterator out,
+                         Functor fmt,
+                         match_flag_type flags,
+                         const RegexT& re) const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      typedef ::boost::regex_traits_wrapper<typename RegexT::traits_type> traits_type;
+      typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator, traits_type>::type F;
+      F func(fmt);
+      return func(*this, out, flags, re.get_traits());
+   }
+   template <class RegexT, class Functor>
+   string_type format(Functor fmt,
+                      match_flag_type flags,
+                      const RegexT& re) const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      typedef ::boost::regex_traits_wrapper<typename RegexT::traits_type> traits_type;
+      std::basic_string<char_type> result;
+      BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> > i(result);
+
+      typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> >, traits_type >::type F;
+      F func(fmt);
+
+      func(*this, i, flags, re.get_traits());
+      return result;
+   }
+
+   const_reference get_last_closed_paren()const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      return m_last_closed_paren == 0 ? m_null : (*this)[m_last_closed_paren];
+   }
+
+   allocator_type get_allocator() const
+   {
+#ifndef BOOST_NO_STD_ALLOCATOR
+      return m_subs.get_allocator();
+#else
+     return allocator_type();
+#endif
+   }
+   void swap(match_results& that)
+   {
+      std::swap(m_subs, that.m_subs);
+      std::swap(m_named_subs, that.m_named_subs);
+      std::swap(m_last_closed_paren, that.m_last_closed_paren);
+      if(m_is_singular)
+      {
+         if(!that.m_is_singular)
+         {
+            m_base = that.m_base;
+            m_null = that.m_null;
+         }
+      }
+      else if(that.m_is_singular)
+      {
+         that.m_base = m_base;
+         that.m_null = m_null;
+      }
+      else
+      {
+         std::swap(m_base, that.m_base);
+         std::swap(m_null, that.m_null);
+      }
+      std::swap(m_is_singular, that.m_is_singular);
+   }
+   bool operator==(const match_results& that)const
+   {
+      if(m_is_singular)
+      {
+         return that.m_is_singular;
+      }
+      else if(that.m_is_singular)
+      {
+         return false;
+      }
+      return (m_subs == that.m_subs) && (m_base == that.m_base) && (m_last_closed_paren == that.m_last_closed_paren);
+   }
+   bool operator!=(const match_results& that)const
+   { return !(*this == that); }
+
+#ifdef BOOST_REGEX_MATCH_EXTRA
+   typedef typename sub_match<BidiIterator>::capture_sequence_type capture_sequence_type;
+
+   const capture_sequence_type& captures(int i)const
+   {
+      if(m_is_singular)
+         raise_logic_error();
+      return (*this)[i].captures();
+   }
+#endif
+
+   //
+   // private access functions:
+   void BOOST_REGEX_CALL set_second(BidiIterator i)
+   {
+      BOOST_REGEX_ASSERT(m_subs.size() > 2);
+      m_subs[2].second = i;
+      m_subs[2].matched = true;
+      m_subs[0].first = i;
+      m_subs[0].matched = (m_subs[0].first != m_subs[0].second);
+      m_null.first = i;
+      m_null.second = i;
+      m_null.matched = false;
+      m_is_singular = false;
+   }
+
+   void BOOST_REGEX_CALL set_second(BidiIterator i, size_type pos, bool m = true, bool escape_k = false)
+   {
+      if(pos)
+         m_last_closed_paren = static_cast<int>(pos);
+      pos += 2;
+      BOOST_REGEX_ASSERT(m_subs.size() > pos);
+      m_subs[pos].second = i;
+      m_subs[pos].matched = m;
+      if((pos == 2) && !escape_k)
+      {
+         m_subs[0].first = i;
+         m_subs[0].matched = (m_subs[0].first != m_subs[0].second);
+         m_null.first = i;
+         m_null.second = i;
+         m_null.matched = false;
+         m_is_singular = false;
+      }
+   }
+   void BOOST_REGEX_CALL set_size(size_type n, BidiIterator i, BidiIterator j)
+   {
+      value_type v(j);
+      size_type len = m_subs.size();
+      if(len > n + 2)
+      {
+         m_subs.erase(m_subs.begin()+n+2, m_subs.end());
+         std::fill(m_subs.begin(), m_subs.end(), v);
+      }
+      else
+      {
+         std::fill(m_subs.begin(), m_subs.end(), v);
+         if(n+2 != len)
+            m_subs.insert(m_subs.end(), n+2-len, v);
+      }
+      m_subs[1].first = i;
+      m_last_closed_paren = 0;
+   }
+   void BOOST_REGEX_CALL set_base(BidiIterator pos)
+   {
+      m_base = pos;
+   }
+   BidiIterator base()const
+   {
+      return m_base;
+   }
+   void BOOST_REGEX_CALL set_first(BidiIterator i)
+   {
+      BOOST_REGEX_ASSERT(m_subs.size() > 2);
+      // set up prefix:
+      m_subs[1].second = i;
+      m_subs[1].matched = (m_subs[1].first != i);
+      // set up $0:
+      m_subs[2].first = i;
+      // zero out everything else:
+      for(size_type n = 3; n < m_subs.size(); ++n)
+      {
+         m_subs[n].first = m_subs[n].second = m_subs[0].second;
+         m_subs[n].matched = false;
+      }
+   }
+   void BOOST_REGEX_CALL set_first(BidiIterator i, size_type pos, bool escape_k = false)
+   {
+      BOOST_REGEX_ASSERT(pos+2 < m_subs.size());
+      if(pos || escape_k)
+      {
+         m_subs[pos+2].first = i;
+         if(escape_k)
+         {
+            m_subs[1].second = i;
+            m_subs[1].matched = (m_subs[1].first != m_subs[1].second);
+         }
+      }
+      else
+         set_first(i);
+   }
+   void BOOST_REGEX_CALL maybe_assign(const match_results<BidiIterator, Allocator>& m);
+
+   void BOOST_REGEX_CALL set_named_subs(boost::shared_ptr<named_sub_type> subs)
+   {
+      m_named_subs = subs;
+   }
+
+private:
+   //
+   // Error handler called when an uninitialized match_results is accessed:
+   //
+   static void raise_logic_error()
+   {
+      std::logic_error e("Attempt to access an uninitialized boost::match_results<> class.");
+      boost::throw_exception(e);
+   }
+
+
+   vector_type            m_subs;                      // subexpressions
+   BidiIterator   m_base;                              // where the search started from
+   sub_match<BidiIterator> m_null;                     // a null match
+   boost::shared_ptr<named_sub_type> m_named_subs;     // Shared copy of named subs in the regex object
+   int m_last_closed_paren;                            // Last ) to be seen - used for formatting
+   bool m_is_singular;                                 // True if our stored iterators are singular
+};
+
+template <class BidiIterator, class Allocator>
+void BOOST_REGEX_CALL match_results<BidiIterator, Allocator>::maybe_assign(const match_results<BidiIterator, Allocator>& m)
+{
+   if(m_is_singular)
+   {
+      *this = m;
+      return;
+   }
+   const_iterator p1, p2;
+   p1 = begin();
+   p2 = m.begin();
+   //
+   // Distances are measured from the start of *this* match, unless this isn't
+   // a valid match in which case we use the start of the whole sequence.  Note that
+   // no subsequent match-candidate can ever be to the left of the first match found.
+   // This ensures that when we are using bidirectional iterators, that distances 
+   // measured are as short as possible, and therefore as efficient as possible
+   // to compute.  Finally note that we don't use the "matched" data member to test
+   // whether a sub-expression is a valid match, because partial matches set this
+   // to false for sub-expression 0.
+   //
+   BidiIterator l_end = this->suffix().second;
+   BidiIterator l_base = (p1->first == l_end) ? this->prefix().first : (*this)[0].first;
+   difference_type len1 = 0;
+   difference_type len2 = 0;
+   difference_type base1 = 0;
+   difference_type base2 = 0;
+   std::size_t i;
+   for(i = 0; i < size(); ++i, ++p1, ++p2)
+   {
+      //
+      // Leftmost takes priority over longest; handle special cases
+      // where distances need not be computed first (an optimisation
+      // for bidirectional iterators: ensure that we don't accidently
+      // compute the length of the whole sequence, as this can be really
+      // expensive).
+      //
+      if(p1->first == l_end)
+      {
+         if(p2->first != l_end)
+         {
+            // p2 must be better than p1, and no need to calculate
+            // actual distances:
+            base1 = 1;
+            base2 = 0;
+            break;
+         }
+         else
+         {
+            // *p1 and *p2 are either unmatched or match end-of sequence,
+            // either way no need to calculate distances:
+            if((p1->matched == false) && (p2->matched == true))
+               break;
+            if((p1->matched == true) && (p2->matched == false))
+               return;
+            continue;
+         }
+      }
+      else if(p2->first == l_end)
+      {
+         // p1 better than p2, and no need to calculate distances:
+         return;
+      }
+      base1 = ::boost::BOOST_REGEX_DETAIL_NS::distance(l_base, p1->first);
+      base2 = ::boost::BOOST_REGEX_DETAIL_NS::distance(l_base, p2->first);
+      BOOST_REGEX_ASSERT(base1 >= 0);
+      BOOST_REGEX_ASSERT(base2 >= 0);
+      if(base1 < base2) return;
+      if(base2 < base1) break;
+
+      len1 = ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)p1->first, (BidiIterator)p1->second);
+      len2 = ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)p2->first, (BidiIterator)p2->second);
+      BOOST_REGEX_ASSERT(len1 >= 0);
+      BOOST_REGEX_ASSERT(len2 >= 0);
+      if((len1 != len2) || ((p1->matched == false) && (p2->matched == true)))
+         break;
+      if((p1->matched == true) && (p2->matched == false))
+         return;
+   }
+   if(i == size())
+      return;
+   if(base2 < base1)
+      *this = m;
+   else if((len2 > len1) || ((p1->matched == false) && (p2->matched == true)) )
+      *this = m;
+}
+
+template <class BidiIterator, class Allocator>
+void swap(match_results<BidiIterator, Allocator>& a, match_results<BidiIterator, Allocator>& b)
+{
+   a.swap(b);
+}
+
+#ifndef BOOST_NO_STD_LOCALE
+template <class charT, class traits, class BidiIterator, class Allocator>
+std::basic_ostream<charT, traits>&
+   operator << (std::basic_ostream<charT, traits>& os,
+                const match_results<BidiIterator, Allocator>& s)
+{
+   return (os << s.str());
+}
+#else
+template <class BidiIterator, class Allocator>
+std::ostream& operator << (std::ostream& os,
+                           const match_results<BidiIterator, Allocator>& s)
+{
+   return (os << s.str());
+}
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif
+
+

lib/third_party/boost/regex/include/boost/regex/v4/mem_block_cache.hpp

@@ -0,0 +1,183 @@
+ /*
+ * Copyright (c) 2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         mem_block_cache.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: memory block cache used by the non-recursive matcher.
+  */
+
+#ifndef BOOST_REGEX_V4_MEM_BLOCK_CACHE_HPP
+#define BOOST_REGEX_V4_MEM_BLOCK_CACHE_HPP
+
+#include <new>
+#ifdef BOOST_HAS_THREADS
+#include <boost/regex/pending/static_mutex.hpp>
+#endif
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+#ifndef BOOST_NO_CXX11_HDR_ATOMIC
+  #include <atomic>
+  #if ATOMIC_POINTER_LOCK_FREE == 2
+    #define BOOST_REGEX_MEM_BLOCK_CACHE_LOCK_FREE
+    #define BOOST_REGEX_ATOMIC_POINTER std::atomic
+  #endif
+#endif
+
+namespace boost{
+namespace BOOST_REGEX_DETAIL_NS{
+
+#ifdef BOOST_REGEX_MEM_BLOCK_CACHE_LOCK_FREE /* lock free implementation */
+struct mem_block_cache
+{
+  std::atomic<void*> cache[BOOST_REGEX_MAX_CACHE_BLOCKS];
+
+   ~mem_block_cache()
+   {
+     for (size_t i = 0;i < BOOST_REGEX_MAX_CACHE_BLOCKS; ++i) {
+       if (cache[i].load()) ::operator delete(cache[i].load());
+     }
+   }
+   void* get()
+   {
+     for (size_t i = 0;i < BOOST_REGEX_MAX_CACHE_BLOCKS; ++i) {
+       void* p = cache[i].load();
+       if (p != NULL) {
+         if (cache[i].compare_exchange_strong(p, NULL)) return p;
+       }
+     }
+     return ::operator new(BOOST_REGEX_BLOCKSIZE);
+   }
+   void put(void* ptr)
+   {
+     for (size_t i = 0;i < BOOST_REGEX_MAX_CACHE_BLOCKS; ++i) {
+       void* p = cache[i].load();
+       if (p == NULL) {
+         if (cache[i].compare_exchange_strong(p, ptr)) return;
+       }
+     }
+     ::operator delete(ptr);
+   }
+
+   static mem_block_cache& instance()
+   {
+      static mem_block_cache block_cache = { { {nullptr} } };
+      return block_cache;
+   }
+};
+
+
+#else /* lock-based implementation */
+
+
+struct mem_block_node
+{
+   mem_block_node* next;
+};
+
+struct mem_block_cache
+{
+   // this member has to be statically initialsed:
+   mem_block_node* next;
+   unsigned cached_blocks;
+#ifdef BOOST_HAS_THREADS
+   boost::static_mutex mut;
+#endif
+
+   ~mem_block_cache()
+   {
+      while(next)
+      {
+         mem_block_node* old = next;
+         next = next->next;
+         ::operator delete(old);
+      }
+   }
+   void* get()
+   {
+#ifdef BOOST_HAS_THREADS
+      boost::static_mutex::scoped_lock g(mut);
+#endif
+     if(next)
+      {
+         mem_block_node* result = next;
+         next = next->next;
+         --cached_blocks;
+         return result;
+      }
+      return ::operator new(BOOST_REGEX_BLOCKSIZE);
+   }
+   void put(void* p)
+   {
+#ifdef BOOST_HAS_THREADS
+      boost::static_mutex::scoped_lock g(mut);
+#endif
+      if(cached_blocks >= BOOST_REGEX_MAX_CACHE_BLOCKS)
+      {
+         ::operator delete(p);
+      }
+      else
+      {
+         mem_block_node* old = static_cast<mem_block_node*>(p);
+         old->next = next;
+         next = old;
+         ++cached_blocks;
+      }
+   }
+   static mem_block_cache& instance()
+   {
+#ifdef BOOST_HAS_THREADS
+      static mem_block_cache block_cache = { 0, 0, BOOST_STATIC_MUTEX_INIT, };
+#else
+      static mem_block_cache block_cache = { 0, 0, };
+#endif
+      return block_cache;
+   }
+};
+#endif
+
+#if BOOST_REGEX_MAX_CACHE_BLOCKS == 0
+
+inline void* BOOST_REGEX_CALL get_mem_block()
+{
+   return ::operator new(BOOST_REGEX_BLOCKSIZE);
+}
+
+inline void BOOST_REGEX_CALL put_mem_block(void* p)
+{
+   ::operator delete(p);
+}
+
+#else
+
+inline void* BOOST_REGEX_CALL get_mem_block()
+{
+   return mem_block_cache::instance().get();
+}
+
+inline void BOOST_REGEX_CALL put_mem_block(void* p)
+{
+   mem_block_cache::instance().put(p);
+}
+
+#endif
+}
+} // namespace boost
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#endif
+

lib/third_party/boost/regex/include/boost/regex/v4/object_cache.hpp

@@ -0,0 +1,171 @@
+/*
+ *
+ * Copyright (c) 2004
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         object_cache.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Implements a generic object cache.
+  */
+
+#ifndef BOOST_REGEX_OBJECT_CACHE_HPP
+#define BOOST_REGEX_OBJECT_CACHE_HPP
+
+#include <boost/regex/config.hpp>
+#include <boost/shared_ptr.hpp>
+#include <map>
+#include <list>
+#include <stdexcept>
+#include <string>
+#ifdef BOOST_HAS_THREADS
+#include <boost/regex/pending/static_mutex.hpp>
+#endif
+
+namespace boost{
+
+template <class Key, class Object>
+class object_cache
+{
+public:
+   typedef std::pair< ::boost::shared_ptr<Object const>, Key const*> value_type;
+   typedef std::list<value_type> list_type;
+   typedef typename list_type::iterator list_iterator;
+   typedef std::map<Key, list_iterator> map_type;
+   typedef typename map_type::iterator map_iterator;
+   typedef typename list_type::size_type size_type;
+   static boost::shared_ptr<Object const> get(const Key& k, size_type l_max_cache_size);
+
+private:
+   static boost::shared_ptr<Object const> do_get(const Key& k, size_type l_max_cache_size);
+
+   struct data
+   {
+      list_type   cont;
+      map_type    index;
+   };
+
+   // Needed by compilers not implementing the resolution to DR45. For reference,
+   // see http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#45.
+   friend struct data;
+};
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4702)
+#endif
+template <class Key, class Object>
+boost::shared_ptr<Object const> object_cache<Key, Object>::get(const Key& k, size_type l_max_cache_size)
+{
+#ifdef BOOST_HAS_THREADS
+   static boost::static_mutex mut = BOOST_STATIC_MUTEX_INIT;
+   boost::static_mutex::scoped_lock l(mut);
+   if (l)
+   {
+      return do_get(k, l_max_cache_size);
+   }
+   //
+   // what do we do if the lock fails?
+   // for now just throw, but we should never really get here...
+   //
+   ::boost::throw_exception(std::runtime_error("Error in thread safety code: could not acquire a lock"));
+#if defined(BOOST_NO_UNREACHABLE_RETURN_DETECTION) || defined(BOOST_NO_EXCEPTIONS)
+   return boost::shared_ptr<Object>();
+#endif
+#else
+   return do_get(k, l_max_cache_size);
+#endif
+}
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+template <class Key, class Object>
+boost::shared_ptr<Object const> object_cache<Key, Object>::do_get(const Key& k, size_type l_max_cache_size)
+{
+   typedef typename object_cache<Key, Object>::data object_data;
+   typedef typename map_type::size_type map_size_type;
+   static object_data s_data;
+
+   //
+   // see if the object is already in the cache:
+   //
+   map_iterator mpos = s_data.index.find(k);
+   if(mpos != s_data.index.end())
+   {
+      //
+      // Eureka! 
+      // We have a cached item, bump it up the list and return it:
+      //
+      if(--(s_data.cont.end()) != mpos->second)
+      {
+         // splice out the item we want to move:
+         list_type temp;
+         temp.splice(temp.end(), s_data.cont, mpos->second);
+         // and now place it at the end of the list:
+         s_data.cont.splice(s_data.cont.end(), temp, temp.begin());
+         BOOST_REGEX_ASSERT(*(s_data.cont.back().second) == k);
+         // update index with new position:
+         mpos->second = --(s_data.cont.end());
+         BOOST_REGEX_ASSERT(&(mpos->first) == mpos->second->second);
+         BOOST_REGEX_ASSERT(&(mpos->first) == s_data.cont.back().second);
+      }
+      return s_data.cont.back().first;
+   }
+   //
+   // if we get here then the item is not in the cache,
+   // so create it:
+   //
+   boost::shared_ptr<Object const> result(new Object(k));
+   //
+   // Add it to the list, and index it:
+   //
+   s_data.cont.push_back(value_type(result, static_cast<Key const*>(0)));
+   s_data.index.insert(std::make_pair(k, --(s_data.cont.end())));
+   s_data.cont.back().second = &(s_data.index.find(k)->first);
+   map_size_type s = s_data.index.size();
+   BOOST_REGEX_ASSERT(s_data.index[k]->first.get() == result.get());
+   BOOST_REGEX_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second);
+   BOOST_REGEX_ASSERT(s_data.index.find(k)->first == k);
+   if(s > l_max_cache_size)
+   {
+      //
+      // We have too many items in the list, so we need to start
+      // popping them off the back of the list, but only if they're
+      // being held uniquely by us:
+      //
+      list_iterator pos = s_data.cont.begin();
+      list_iterator last = s_data.cont.end();
+      while((pos != last) && (s > l_max_cache_size))
+      {
+         if(pos->first.unique())
+         {
+            list_iterator condemmed(pos);
+            ++pos;
+            // now remove the items from our containers, 
+            // then order has to be as follows:
+            BOOST_REGEX_ASSERT(s_data.index.find(*(condemmed->second)) != s_data.index.end());
+            s_data.index.erase(*(condemmed->second));
+            s_data.cont.erase(condemmed); 
+            --s;
+         }
+         else
+            ++pos;
+      }
+      BOOST_REGEX_ASSERT(s_data.index[k]->first.get() == result.get());
+      BOOST_REGEX_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second);
+      BOOST_REGEX_ASSERT(s_data.index.find(k)->first == k);
+   }
+   return result;
+}
+
+}
+
+#endif

lib/third_party/boost/regex/include/boost/regex/v4/pattern_except.hpp

@@ -0,0 +1,128 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         pattern_except.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares pattern-matching exception classes.
+  */
+
+#ifndef BOOST_RE_V4_PAT_EXCEPT_HPP
+#define BOOST_RE_V4_PAT_EXCEPT_HPP
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+
+#include <cstddef>
+#include <stdexcept>
+#include <boost/regex/v4/error_type.hpp>
+#include <boost/regex/v4/regex_traits_defaults.hpp>
+
+namespace boost{
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4275)
+#if BOOST_MSVC >= 1800
+#pragma warning(disable : 26812)
+#endif
+#endif
+class regex_error : public std::runtime_error
+{
+public:
+   explicit regex_error(const std::string& s, regex_constants::error_type err = regex_constants::error_unknown, std::ptrdiff_t pos = 0)
+      : std::runtime_error(s)
+      , m_error_code(err)
+      , m_position(pos)
+   {
+   }
+   explicit regex_error(regex_constants::error_type err)
+      : std::runtime_error(::boost::BOOST_REGEX_DETAIL_NS::get_default_error_string(err))
+      , m_error_code(err)
+      , m_position(0)
+   {
+   }
+   ~regex_error() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {}
+   regex_constants::error_type code()const
+   { return m_error_code; }
+   std::ptrdiff_t position()const
+   { return m_position; }
+   void raise()const 
+   {
+#ifndef BOOST_NO_EXCEPTIONS
+#ifndef BOOST_REGEX_STANDALONE
+      ::boost::throw_exception(*this);
+#else
+      throw* this;
+#endif
+#endif
+   }
+private:
+   regex_constants::error_type m_error_code;
+   std::ptrdiff_t m_position;
+};
+
+typedef regex_error bad_pattern;
+typedef regex_error bad_expression;
+
+namespace BOOST_REGEX_DETAIL_NS{
+
+template <class E>
+inline void raise_runtime_error(const E& ex)
+{
+#ifndef BOOST_REGEX_STANDALONE
+   ::boost::throw_exception(ex);
+#else
+   throw ex;
+#endif
+}
+
+template <class traits>
+void raise_error(const traits& t, regex_constants::error_type code)
+{
+   (void)t;  // warning suppression
+   regex_error e(t.error_string(code), code, 0);
+   ::boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(e);
+}
+
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+} // namespace boost
+
+#endif

lib/third_party/boost/regex/include/boost/regex/v4/perl_matcher.hpp

@@ -0,0 +1,645 @@
+/*
+ *
+ * Copyright (c) 2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+#ifndef BOOST_REGEX_MATCHER_HPP
+#define BOOST_REGEX_MATCHER_HPP
+
+#include <boost/regex/v4/iterator_category.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#pragma warning(disable : 4251)
+#if BOOST_MSVC < 1700
+#     pragma warning(disable : 4231)
+#endif
+#  if BOOST_MSVC < 1600
+#     pragma warning(disable : 4660)
+#  endif
+#if BOOST_MSVC < 1910
+#pragma warning(disable:4800)
+#endif
+#endif
+
+namespace boost{
+namespace BOOST_REGEX_DETAIL_NS{
+
+//
+// error checking API:
+//
+inline void BOOST_REGEX_CALL verify_options(boost::regex_constants::syntax_option_type, match_flag_type mf)
+{
+   //
+   // can't mix match_extra with POSIX matching rules:
+   //
+   if ((mf & match_extra) && (mf & match_posix))
+   {
+      std::logic_error msg("Usage Error: Can't mix regular expression captures with POSIX matching rules");
+      throw_exception(msg);
+   }
+}
+//
+// function can_start:
+//
+template <class charT>
+inline bool can_start(charT c, const unsigned char* map, unsigned char mask)
+{
+   return ((c < static_cast<charT>(0)) ? true : ((c >= static_cast<charT>(1 << CHAR_BIT)) ? true : map[c] & mask));
+}
+inline bool can_start(char c, const unsigned char* map, unsigned char mask)
+{
+   return map[(unsigned char)c] & mask;
+}
+inline bool can_start(signed char c, const unsigned char* map, unsigned char mask)
+{
+   return map[(unsigned char)c] & mask;
+}
+inline bool can_start(unsigned char c, const unsigned char* map, unsigned char mask)
+{
+   return map[c] & mask;
+}
+inline bool can_start(unsigned short c, const unsigned char* map, unsigned char mask)
+{
+   return ((c >= (1 << CHAR_BIT)) ? true : map[c] & mask);
+}
+#if !defined(__hpux) && !defined(__WINSCW__)// WCHAR_MIN not usable in pp-directives.
+#if defined(WCHAR_MIN) && (WCHAR_MIN == 0) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+inline bool can_start(wchar_t c, const unsigned char* map, unsigned char mask)
+{
+   return ((c >= static_cast<wchar_t>(1u << CHAR_BIT)) ? true : map[c] & mask);
+}
+#endif
+#endif
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+inline bool can_start(unsigned int c, const unsigned char* map, unsigned char mask)
+{
+   return (((c >= static_cast<unsigned int>(1u << CHAR_BIT)) ? true : map[c] & mask));
+}
+#endif
+
+
+//
+// Unfortunately Rogue Waves standard library appears to have a bug
+// in std::basic_string::compare that results in erroneous answers
+// in some cases (tested with Borland C++ 5.1, Rogue Wave lib version
+// 0x020101) the test case was:
+// {39135,0} < {0xff,0}
+// which succeeds when it should not.
+//
+#ifndef _RWSTD_VER
+template <class C, class T, class A>
+inline int string_compare(const std::basic_string<C,T,A>& s, const C* p)
+{ 
+   if(0 == *p)
+   {
+      if(s.empty() || ((s.size() == 1) && (s[0] == 0)))
+         return 0;
+   }
+   return s.compare(p); 
+}
+#else
+template <class C, class T, class A>
+inline int string_compare(const std::basic_string<C,T,A>& s, const C* p)
+{ 
+   if(0 == *p)
+   {
+      if(s.empty() || ((s.size() == 1) && (s[0] == 0)))
+         return 0;
+   }
+   return s.compare(p); 
+}
+inline int string_compare(const std::string& s, const char* p)
+{ return std::strcmp(s.c_str(), p); }
+# ifndef BOOST_NO_WREGEX
+inline int string_compare(const std::wstring& s, const wchar_t* p)
+{ return std::wcscmp(s.c_str(), p); }
+#endif
+#endif
+template <class Seq, class C>
+inline int string_compare(const Seq& s, const C* p)
+{
+   std::size_t i = 0;
+   while((i < s.size()) && (p[i] == s[i]))
+   {
+      ++i;
+   }
+   return (i == s.size()) ? -(int)p[i] : (int)s[i] - (int)p[i];
+}
+# define STR_COMP(s,p) string_compare(s,p)
+
+template<class charT>
+inline const charT* re_skip_past_null(const charT* p)
+{
+  while (*p != static_cast<charT>(0)) ++p;
+  return ++p;
+}
+
+template <class iterator, class charT, class traits_type, class char_classT>
+iterator BOOST_REGEX_CALL re_is_set_member(iterator next, 
+                          iterator last, 
+                          const re_set_long<char_classT>* set_, 
+                          const regex_data<charT, traits_type>& e, bool icase)
+{   
+   const charT* p = reinterpret_cast<const charT*>(set_+1);
+   iterator ptr;
+   unsigned int i;
+   //bool icase = e.m_flags & regex_constants::icase;
+
+   if(next == last) return next;
+
+   typedef typename traits_type::string_type traits_string_type;
+   const ::boost::regex_traits_wrapper<traits_type>& traits_inst = *(e.m_ptraits);
+   
+   // dwa 9/13/00 suppress incorrect MSVC warning - it claims this is never
+   // referenced
+   (void)traits_inst;
+
+   // try and match a single character, could be a multi-character
+   // collating element...
+   for(i = 0; i < set_->csingles; ++i)
+   {
+      ptr = next;
+      if(*p == static_cast<charT>(0))
+      {
+         // treat null string as special case:
+         if(traits_inst.translate(*ptr, icase))
+         {
+            ++p;
+            continue;
+         }
+         return set_->isnot ? next : (ptr == next) ? ++next : ptr;
+      }
+      else
+      {
+         while(*p && (ptr != last))
+         {
+            if(traits_inst.translate(*ptr, icase) != *p)
+               break;
+            ++p;
+            ++ptr;
+         }
+
+         if(*p == static_cast<charT>(0)) // if null we've matched
+            return set_->isnot ? next : (ptr == next) ? ++next : ptr;
+
+         p = re_skip_past_null(p);     // skip null
+      }
+   }
+
+   charT col = traits_inst.translate(*next, icase);
+
+
+   if(set_->cranges || set_->cequivalents)
+   {
+      traits_string_type s1;
+      //
+      // try and match a range, NB only a single character can match
+      if(set_->cranges)
+      {
+         if((e.m_flags & regex_constants::collate) == 0)
+            s1.assign(1, col);
+         else
+         {
+            charT a[2] = { col, charT(0), };
+            s1 = traits_inst.transform(a, a + 1);
+         }
+         for(i = 0; i < set_->cranges; ++i)
+         {
+            if(STR_COMP(s1, p) >= 0)
+            {
+               do{ ++p; }while(*p);
+               ++p;
+               if(STR_COMP(s1, p) <= 0)
+                  return set_->isnot ? next : ++next;
+            }
+            else
+            {
+               // skip first string
+               do{ ++p; }while(*p);
+               ++p;
+            }
+            // skip second string
+            do{ ++p; }while(*p);
+            ++p;
+         }
+      }
+      //
+      // try and match an equivalence class, NB only a single character can match
+      if(set_->cequivalents)
+      {
+         charT a[2] = { col, charT(0), };
+         s1 = traits_inst.transform_primary(a, a +1);
+         for(i = 0; i < set_->cequivalents; ++i)
+         {
+            if(STR_COMP(s1, p) == 0)
+               return set_->isnot ? next : ++next;
+            // skip string
+            do{ ++p; }while(*p);
+            ++p;
+         }
+      }
+   }
+   if(traits_inst.isctype(col, set_->cclasses) == true)
+      return set_->isnot ? next : ++next;
+   if((set_->cnclasses != 0) && (traits_inst.isctype(col, set_->cnclasses) == false))
+      return set_->isnot ? next : ++next;
+   return set_->isnot ? ++next : next;
+}
+
+template <class BidiIterator>
+class repeater_count
+{
+   repeater_count** stack;
+   repeater_count* next;
+   int state_id;
+   std::size_t count;        // the number of iterations so far
+   BidiIterator start_pos;   // where the last repeat started
+
+   repeater_count* unwind_until(int n, repeater_count* p, int current_recursion_id)
+   { 
+      while(p && (p->state_id != n))
+      {
+         if(-2 - current_recursion_id == p->state_id)
+            return 0;
+         p = p->next;
+         if(p && (p->state_id < 0))
+         {
+            p = unwind_until(p->state_id, p, current_recursion_id);
+            if(!p)
+               return p;
+            p = p->next;
+         }
+      }
+      return p;
+   }
+public:
+   repeater_count(repeater_count** s) : stack(s), next(0), state_id(-1), count(0), start_pos() {}
+   
+   repeater_count(int i, repeater_count** s, BidiIterator start, int current_recursion_id)
+      : start_pos(start)
+   {
+      state_id = i;
+      stack = s;
+      next = *stack;
+      *stack = this;
+      if((state_id > next->state_id) && (next->state_id >= 0))
+         count = 0;
+      else
+      {
+         repeater_count* p = next;
+         p = unwind_until(state_id, p, current_recursion_id);
+         if(p)
+         {
+            count = p->count;
+            start_pos = p->start_pos;
+         }
+         else
+            count = 0;
+      }
+   }
+   ~repeater_count()
+   {
+      if(next)
+         *stack = next;
+   }
+   std::size_t get_count() { return count; }
+   int get_id() { return state_id; }
+   std::size_t operator++() { return ++count; }
+   bool check_null_repeat(const BidiIterator& pos, std::size_t max)
+   {
+      // this is called when we are about to start a new repeat,
+      // if the last one was NULL move our count to max,
+      // otherwise save the current position.
+      bool result = (count == 0) ? false : (pos == start_pos);
+      if(result)
+         count = max;
+      else
+         start_pos = pos;
+      return result;
+   }
+};
+
+struct saved_state;
+
+enum saved_state_type
+{
+   saved_type_end = 0,
+   saved_type_paren = 1,
+   saved_type_recurse = 2,
+   saved_type_assertion = 3,
+   saved_state_alt = 4,
+   saved_state_repeater_count = 5,
+   saved_state_extra_block = 6,
+   saved_state_greedy_single_repeat = 7,
+   saved_state_rep_slow_dot = 8,
+   saved_state_rep_fast_dot = 9,
+   saved_state_rep_char = 10,
+   saved_state_rep_short_set = 11,
+   saved_state_rep_long_set = 12,
+   saved_state_non_greedy_long_repeat = 13, 
+   saved_state_count = 14
+};
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#if BOOST_MSVC >= 1800
+#pragma warning(disable:26495)
+#endif
+#endif
+template <class Results>
+struct recursion_info
+{
+   typedef typename Results::value_type value_type;
+   typedef typename value_type::iterator iterator;
+   int idx;
+   const re_syntax_base* preturn_address;
+   Results results;
+   repeater_count<iterator>* repeater_stack;
+   iterator location_of_start;
+};
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+template <class BidiIterator, class Allocator, class traits>
+class perl_matcher
+{
+public:
+   typedef typename traits::char_type char_type;
+   typedef perl_matcher<BidiIterator, Allocator, traits> self_type;
+   typedef bool (self_type::*matcher_proc_type)();
+   typedef std::size_t traits_size_type;
+   typedef typename is_byte<char_type>::width_type width_type;
+   typedef typename regex_iterator_traits<BidiIterator>::difference_type difference_type;
+   typedef match_results<BidiIterator, Allocator> results_type;
+
+   perl_matcher(BidiIterator first, BidiIterator end, 
+      match_results<BidiIterator, Allocator>& what, 
+      const basic_regex<char_type, traits>& e,
+      match_flag_type f,
+      BidiIterator l_base)
+      :  m_result(what), base(first), last(end), 
+         position(first), backstop(l_base), re(e), traits_inst(e.get_traits()), 
+         m_independent(false), next_count(&rep_obj), rep_obj(&next_count)
+#ifdef BOOST_REGEX_NON_RECURSIVE
+      , m_recursions(0)
+#endif
+   {
+      construct_init(e, f);
+   }
+
+   bool match();
+   bool find();
+
+   void setf(match_flag_type f)
+   { m_match_flags |= f; }
+   void unsetf(match_flag_type f)
+   { m_match_flags &= ~f; }
+
+private:
+   void construct_init(const basic_regex<char_type, traits>& e, match_flag_type f);
+
+   bool find_imp();
+   bool match_imp();
+#ifdef BOOST_REGEX_HAS_MS_STACK_GUARD
+   typedef bool (perl_matcher::*protected_proc_type)();
+   bool protected_call(protected_proc_type);
+#endif
+   void estimate_max_state_count(std::random_access_iterator_tag*);
+   void estimate_max_state_count(void*);
+   bool match_prefix();
+   bool match_all_states();
+
+   // match procs, stored in s_match_vtable:
+   bool match_startmark();
+   bool match_endmark();
+   bool match_literal();
+   bool match_start_line();
+   bool match_end_line();
+   bool match_wild();
+   bool match_match();
+   bool match_word_boundary();
+   bool match_within_word();
+   bool match_word_start();
+   bool match_word_end();
+   bool match_buffer_start();
+   bool match_buffer_end();
+   bool match_backref();
+   bool match_long_set();
+   bool match_set();
+   bool match_jump();
+   bool match_alt();
+   bool match_rep();
+   bool match_combining();
+   bool match_soft_buffer_end();
+   bool match_restart_continue();
+   bool match_long_set_repeat();
+   bool match_set_repeat();
+   bool match_char_repeat();
+   bool match_dot_repeat_fast();
+   bool match_dot_repeat_slow();
+   bool match_dot_repeat_dispatch()
+   {
+      return ::boost::is_random_access_iterator<BidiIterator>::value ? match_dot_repeat_fast() : match_dot_repeat_slow();
+   }
+   bool match_backstep();
+   bool match_assert_backref();
+   bool match_toggle_case();
+#ifdef BOOST_REGEX_RECURSIVE
+   bool backtrack_till_match(std::size_t count);
+#endif
+   bool match_recursion();
+   bool match_fail();
+   bool match_accept();
+   bool match_commit();
+   bool match_then();
+   bool skip_until_paren(int index, bool match = true);
+
+   // find procs stored in s_find_vtable:
+   bool find_restart_any();
+   bool find_restart_word();
+   bool find_restart_line();
+   bool find_restart_buf();
+   bool find_restart_lit();
+
+private:
+   // final result structure to be filled in:
+   match_results<BidiIterator, Allocator>& m_result;
+   // temporary result for POSIX matches:
+   scoped_ptr<match_results<BidiIterator, Allocator> > m_temp_match;
+   // pointer to actual result structure to fill in:
+   match_results<BidiIterator, Allocator>* m_presult;
+   // start of sequence being searched:
+   BidiIterator base;
+   // end of sequence being searched:
+   BidiIterator last; 
+   // current character being examined:
+   BidiIterator position;
+   // where to restart next search after failed match attempt:
+   BidiIterator restart;
+   // where the current search started from, acts as base for $` during grep:
+   BidiIterator search_base;
+   // how far we can go back when matching lookbehind:
+   BidiIterator backstop;
+   // the expression being examined:
+   const basic_regex<char_type, traits>& re;
+   // the expression's traits class:
+   const ::boost::regex_traits_wrapper<traits>& traits_inst;
+   // the next state in the machine being matched:
+   const re_syntax_base* pstate;
+   // matching flags in use:
+   match_flag_type m_match_flags;
+   // how many states we have examined so far:
+   std::ptrdiff_t state_count;
+   // max number of states to examine before giving up:
+   std::ptrdiff_t max_state_count;
+   // whether we should ignore case or not:
+   bool icase;
+   // set to true when (position == last), indicates that we may have a partial match:
+   bool m_has_partial_match;
+   // set to true whenever we get a match:
+   bool m_has_found_match;
+   // set to true whenever we're inside an independent sub-expression:
+   bool m_independent;
+   // the current repeat being examined:
+   repeater_count<BidiIterator>* next_count;
+   // the first repeat being examined (top of linked list):
+   repeater_count<BidiIterator> rep_obj;
+   // the mask to pass when matching word boundaries:
+   typename traits::char_class_type m_word_mask;
+   // the bitmask to use when determining whether a match_any matches a newline or not:
+   unsigned char match_any_mask;
+   // recursion information:
+   std::vector<recursion_info<results_type> > recursion_stack;
+#ifdef BOOST_REGEX_RECURSIVE
+   // Set to false by a (*COMMIT):
+   bool m_can_backtrack;
+   bool m_have_accept;
+   bool m_have_then;
+#endif
+#ifdef BOOST_REGEX_NON_RECURSIVE
+   //
+   // additional members for non-recursive version:
+   //
+   typedef bool (self_type::*unwind_proc_type)(bool);
+
+   void extend_stack();
+   bool unwind(bool);
+   bool unwind_end(bool);
+   bool unwind_paren(bool);
+   bool unwind_recursion_stopper(bool);
+   bool unwind_assertion(bool);
+   bool unwind_alt(bool);
+   bool unwind_repeater_counter(bool);
+   bool unwind_extra_block(bool);
+   bool unwind_greedy_single_repeat(bool);
+   bool unwind_slow_dot_repeat(bool);
+   bool unwind_fast_dot_repeat(bool);
+   bool unwind_char_repeat(bool);
+   bool unwind_short_set_repeat(bool);
+   bool unwind_long_set_repeat(bool);
+   bool unwind_non_greedy_repeat(bool);
+   bool unwind_recursion(bool);
+   bool unwind_recursion_pop(bool);
+   bool unwind_commit(bool);
+   bool unwind_then(bool);
+   bool unwind_case(bool);
+   void destroy_single_repeat();
+   void push_matched_paren(int index, const sub_match<BidiIterator>& sub);
+   void push_recursion_stopper();
+   void push_assertion(const re_syntax_base* ps, bool positive);
+   void push_alt(const re_syntax_base* ps);
+   void push_repeater_count(int i, repeater_count<BidiIterator>** s);
+   void push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int state_id);
+   void push_non_greedy_repeat(const re_syntax_base* ps);
+   void push_recursion(int idx, const re_syntax_base* p, results_type* presults, results_type* presults2);
+   void push_recursion_pop();
+   void push_case_change(bool);
+
+   // pointer to base of stack:
+   saved_state* m_stack_base;
+   // pointer to current stack position:
+   saved_state* m_backup_state;
+   // how many memory blocks have we used up?:
+   unsigned used_block_count;
+   // determines what value to return when unwinding from recursion,
+   // allows for mixed recursive/non-recursive algorithm:
+   bool m_recursive_result;
+   // We have unwound to a lookahead/lookbehind, used by COMMIT/PRUNE/SKIP:
+   bool m_unwound_lookahead;
+   // We have unwound to an alternative, used by THEN:
+   bool m_unwound_alt;
+   // We are unwinding a commit - used by independent subs to determine whether to stop there or carry on unwinding:
+   //bool m_unwind_commit;
+   // Recursion limit:
+   unsigned m_recursions;
+#endif
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#if BOOST_MSVC >= 1800
+#pragma warning(disable:26495)
+#endif
+#endif
+   // these operations aren't allowed, so are declared private,
+   // bodies are provided to keep explicit-instantiation requests happy:
+   perl_matcher& operator=(const perl_matcher&)
+   {
+      return *this;
+   }
+   perl_matcher(const perl_matcher& that)
+      : m_result(that.m_result), re(that.re), traits_inst(that.traits_inst), rep_obj(0) {}
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+};
+
+} // namespace BOOST_REGEX_DETAIL_NS
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+} // namespace boost
+
+//
+// include the implementation of perl_matcher:
+//
+#ifdef BOOST_REGEX_RECURSIVE
+#include <boost/regex/v4/perl_matcher_recursive.hpp>
+#else
+#include <boost/regex/v4/perl_matcher_non_recursive.hpp>
+#endif
+// this one has to be last:
+#include <boost/regex/v4/perl_matcher_common.hpp>
+
+#endif

lib/third_party/boost/regex/include/boost/regex/v4/primary_transform.hpp

@@ -0,0 +1,146 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE:        primary_transform.hpp
+  *   VERSION:     see <boost/version.hpp>
+  *   DESCRIPTION: Heuristically determines the sort string format in use
+  *                by the current locale.
+  */
+
+#ifndef BOOST_REGEX_PRIMARY_TRANSFORM
+#define BOOST_REGEX_PRIMARY_TRANSFORM
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+namespace boost{
+   namespace BOOST_REGEX_DETAIL_NS{
+
+
+enum{
+   sort_C,
+   sort_fixed,
+   sort_delim,
+   sort_unknown
+};
+
+template <class S, class charT>
+unsigned count_chars(const S& s, charT c)
+{
+   //
+   // Count how many occurrences of character c occur
+   // in string s: if c is a delimeter between collation
+   // fields, then this should be the same value for all
+   // sort keys:
+   //
+   unsigned int count = 0;
+   for(unsigned pos = 0; pos < s.size(); ++pos)
+   {
+      if(s[pos] == c) ++count;
+   }
+   return count;
+}
+
+
+template <class traits, class charT>
+unsigned find_sort_syntax(const traits* pt, charT* delim)
+{
+   //
+   // compare 'a' with 'A' to see how similar they are,
+   // should really use a-accute but we can't portably do that,
+   //
+   typedef typename traits::string_type string_type;
+   typedef typename traits::char_type char_type;
+
+   // Suppress incorrect warning for MSVC
+   (void)pt;
+
+   char_type a[2] = {'a', '\0', };
+   string_type sa(pt->transform(a, a+1));
+   if(sa == a)
+   {
+      *delim = 0;
+      return sort_C;
+   }
+   char_type A[2] = { 'A', '\0', };
+   string_type sA(pt->transform(A, A+1));
+   char_type c[2] = { ';', '\0', };
+   string_type sc(pt->transform(c, c+1));
+
+   int pos = 0;
+   while((pos <= static_cast<int>(sa.size())) && (pos <= static_cast<int>(sA.size())) && (sa[pos] == sA[pos])) ++pos;
+   --pos;
+   if(pos < 0)
+   {
+      *delim = 0;
+      return sort_unknown;
+   }
+   //
+   // at this point sa[pos] is either the end of a fixed width field
+   // or the character that acts as a delimiter:
+   //
+   charT maybe_delim = sa[pos];
+   if((pos != 0) && (count_chars(sa, maybe_delim) == count_chars(sA, maybe_delim)) && (count_chars(sa, maybe_delim) == count_chars(sc, maybe_delim)))
+   {
+      *delim = maybe_delim;
+      return sort_delim;
+   }
+   //
+   // OK doen't look like a delimiter, try for fixed width field:
+   //
+   if((sa.size() == sA.size()) && (sa.size() == sc.size()))
+   {
+      // note assumes that the fixed width field is less than
+      // (numeric_limits<charT>::max)(), should be true for all types
+      // I can't imagine 127 character fields...
+      *delim = static_cast<charT>(++pos);
+      return sort_fixed;
+   }
+   //
+   // don't know what it is:
+   //
+   *delim = 0;
+   return sort_unknown;
+}
+
+
+   } // namespace BOOST_REGEX_DETAIL_NS
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif
+
+
+
+
+
+
+

lib/third_party/boost/regex/include/boost/regex/v4/protected_call.hpp

@@ -0,0 +1,83 @@
+/*
+ *
+ * Copyright (c) 2004
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         basic_regex_creator.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares template class basic_regex_creator which fills in
+  *                the data members of a regex_data object.
+  */
+
+#ifndef BOOST_REGEX_V4_PROTECTED_CALL_HPP
+#define BOOST_REGEX_V4_PROTECTED_CALL_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+namespace boost{
+namespace BOOST_REGEX_DETAIL_NS{
+
+class BOOST_REGEX_DECL abstract_protected_call
+{
+public:
+   bool BOOST_REGEX_CALL execute()const;
+   // this stops gcc-4 from complaining:
+   virtual ~abstract_protected_call(){}
+private:
+   virtual bool call()const = 0;
+};
+
+template <class T>
+class concrete_protected_call
+   : public abstract_protected_call
+{
+public:
+   typedef bool (T::*proc_type)();
+   concrete_protected_call(T* o, proc_type p)
+      : obj(o), proc(p) {}
+private:
+   bool call()const BOOST_OVERRIDE;
+   T* obj;
+   proc_type proc;
+};
+
+template <class T>
+bool concrete_protected_call<T>::call()const
+{
+   return (obj->*proc)();
+}
+
+}
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif

lib/third_party/boost/regex/include/boost/regex/v4/regbase.hpp

@@ -0,0 +1,180 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regbase.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares class regbase.
+  */
+
+#ifndef BOOST_REGEX_V4_REGBASE_HPP
+#define BOOST_REGEX_V4_REGBASE_HPP
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+namespace boost{
+//
+// class regbase
+// handles error codes and flags
+//
+class BOOST_REGEX_DECL regbase
+{
+public:
+   enum flag_type_
+   {
+      //
+      // Divide the flags up into logical groups:
+      // bits 0-7 indicate main synatx type.
+      // bits 8-15 indicate syntax subtype.
+      // bits 16-31 indicate options that are common to all
+      // regex syntaxes.
+      // In all cases the default is 0.
+      //
+      // Main synatx group:
+      //
+      perl_syntax_group = 0,                      // default
+      basic_syntax_group = 1,                     // POSIX basic
+      literal = 2,                                // all characters are literals
+      main_option_type = literal | basic_syntax_group | perl_syntax_group, // everything!
+      //
+      // options specific to perl group:
+      //
+      no_bk_refs = 1 << 8,                        // \d not allowed
+      no_perl_ex = 1 << 9,                        // disable perl extensions
+      no_mod_m = 1 << 10,                         // disable Perl m modifier
+      mod_x = 1 << 11,                            // Perl x modifier
+      mod_s = 1 << 12,                            // force s modifier on (overrides match_not_dot_newline)
+      no_mod_s = 1 << 13,                         // force s modifier off (overrides match_not_dot_newline)
+
+      //
+      // options specific to basic group:
+      //
+      no_char_classes = 1 << 8,                   // [[:CLASS:]] not allowed
+      no_intervals = 1 << 9,                      // {x,y} not allowed
+      bk_plus_qm = 1 << 10,                       // uses \+ and \?
+      bk_vbar = 1 << 11,                          // use \| for alternatives
+      emacs_ex = 1 << 12,                         // enables emacs extensions
+
+      //
+      // options common to all groups:
+      //
+      no_escape_in_lists = 1 << 16,                     // '\' not special inside [...]
+      newline_alt = 1 << 17,                            // \n is the same as |
+      no_except = 1 << 18,                              // no exception on error
+      failbit = 1 << 19,                                // error flag
+      icase = 1 << 20,                                  // characters are matched regardless of case
+      nocollate = 0,                                    // don't use locale specific collation (deprecated)
+      collate = 1 << 21,                                // use locale specific collation
+      nosubs = 1 << 22,                                 // don't mark sub-expressions
+      save_subexpression_location = 1 << 23,            // save subexpression locations
+      no_empty_expressions = 1 << 24,                   // no empty expressions allowed
+      optimize = 0,                                     // not really supported
+      
+
+
+      basic = basic_syntax_group | collate | no_escape_in_lists,
+      extended = no_bk_refs | collate | no_perl_ex | no_escape_in_lists,
+      normal = 0,
+      emacs = basic_syntax_group | collate | emacs_ex | bk_vbar,
+      awk = no_bk_refs | collate | no_perl_ex,
+      grep = basic | newline_alt,
+      egrep = extended | newline_alt,
+      sed = basic,
+      perl = normal,
+      ECMAScript = normal,
+      JavaScript = normal,
+      JScript = normal
+   };
+   typedef unsigned int flag_type;
+
+   enum restart_info
+   {
+      restart_any = 0,
+      restart_word = 1,
+      restart_line = 2,
+      restart_buf = 3,
+      restart_continue = 4,
+      restart_lit = 5,
+      restart_fixed_lit = 6, 
+      restart_count = 7
+   };
+};
+
+//
+// provide std lib proposal compatible constants:
+//
+namespace regex_constants{
+
+   enum flag_type_
+   {
+
+      no_except = ::boost::regbase::no_except,
+      failbit = ::boost::regbase::failbit,
+      literal = ::boost::regbase::literal,
+      icase = ::boost::regbase::icase,
+      nocollate = ::boost::regbase::nocollate,
+      collate = ::boost::regbase::collate,
+      nosubs = ::boost::regbase::nosubs,
+      optimize = ::boost::regbase::optimize,
+      bk_plus_qm = ::boost::regbase::bk_plus_qm,
+      bk_vbar = ::boost::regbase::bk_vbar,
+      no_intervals = ::boost::regbase::no_intervals,
+      no_char_classes = ::boost::regbase::no_char_classes,
+      no_escape_in_lists = ::boost::regbase::no_escape_in_lists,
+      no_mod_m = ::boost::regbase::no_mod_m,
+      mod_x = ::boost::regbase::mod_x,
+      mod_s = ::boost::regbase::mod_s,
+      no_mod_s = ::boost::regbase::no_mod_s,
+      save_subexpression_location = ::boost::regbase::save_subexpression_location,
+      no_empty_expressions = ::boost::regbase::no_empty_expressions,
+
+      basic = ::boost::regbase::basic,
+      extended = ::boost::regbase::extended,
+      normal = ::boost::regbase::normal,
+      emacs = ::boost::regbase::emacs,
+      awk = ::boost::regbase::awk,
+      grep = ::boost::regbase::grep,
+      egrep = ::boost::regbase::egrep,
+      sed = basic,
+      perl = normal,
+      ECMAScript = normal,
+      JavaScript = normal,
+      JScript = normal
+   };
+   typedef ::boost::regbase::flag_type syntax_option_type;
+
+} // namespace regex_constants
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif
+

lib/third_party/boost/regex/include/boost/regex/v4/regex.hpp

@@ -0,0 +1,166 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares boost::basic_regex<> and associated
+  *                functions and classes. This header is the main
+  *                entry point for the template regex code.
+  */
+
+#ifndef BOOST_RE_REGEX_HPP_INCLUDED
+#define BOOST_RE_REGEX_HPP_INCLUDED
+
+#ifdef __cplusplus
+
+// what follows is all C++ don't include in C builds!!
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+#ifndef BOOST_REGEX_WORKAROUND_HPP
+#include <boost/regex/v4/regex_workaround.hpp>
+#endif
+
+#ifndef BOOST_REGEX_FWD_HPP
+#include <boost/regex_fwd.hpp>
+#endif
+#ifndef BOOST_REGEX_TRAITS_HPP
+#include <boost/regex/regex_traits.hpp>
+#endif
+#ifndef BOOST_REGEX_RAW_BUFFER_HPP
+#include <boost/regex/v4/error_type.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_MATCH_FLAGS
+#include <boost/regex/v4/match_flags.hpp>
+#endif
+#ifndef BOOST_REGEX_RAW_BUFFER_HPP
+#include <boost/regex/v4/regex_raw_buffer.hpp>
+#endif
+#ifndef BOOST_RE_PAT_EXCEPT_HPP
+#include <boost/regex/pattern_except.hpp>
+#endif
+
+#ifndef BOOST_REGEX_V4_CHAR_REGEX_TRAITS_HPP
+#include <boost/regex/v4/char_regex_traits.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_STATES_HPP
+#include <boost/regex/v4/states.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_REGBASE_HPP
+#include <boost/regex/v4/regbase.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_ITERATOR_TRAITS_HPP
+#include <boost/regex/v4/iterator_traits.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_BASIC_REGEX_HPP
+#include <boost/regex/v4/basic_regex.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_BASIC_REGEX_CREATOR_HPP
+#include <boost/regex/v4/basic_regex_creator.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_BASIC_REGEX_PARSER_HPP
+#include <boost/regex/v4/basic_regex_parser.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_SUB_MATCH_HPP
+#include <boost/regex/v4/sub_match.hpp>
+#endif
+#ifndef BOOST_REGEX_FORMAT_HPP
+#include <boost/regex/v4/regex_format.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_MATCH_RESULTS_HPP
+#include <boost/regex/v4/match_results.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_PROTECTED_CALL_HPP
+#include <boost/regex/v4/protected_call.hpp>
+#endif
+#ifndef BOOST_REGEX_MATCHER_HPP
+#include <boost/regex/v4/perl_matcher.hpp>
+#endif
+
+
+namespace boost{
+#ifdef BOOST_REGEX_NO_FWD
+typedef basic_regex<char, regex_traits<char> > regex;
+#ifndef BOOST_NO_WREGEX
+typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
+#endif
+#endif
+
+typedef match_results<const char*> cmatch;
+typedef match_results<std::string::const_iterator> smatch;
+#ifndef BOOST_NO_WREGEX
+typedef match_results<const wchar_t*> wcmatch;
+typedef match_results<std::wstring::const_iterator> wsmatch;
+#endif
+
+} // namespace boost
+#ifndef BOOST_REGEX_MATCH_HPP
+#include <boost/regex/v4/regex_match.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_REGEX_SEARCH_HPP
+#include <boost/regex/v4/regex_search.hpp>
+#endif
+#ifndef BOOST_REGEX_ITERATOR_HPP
+#include <boost/regex/v4/regex_iterator.hpp>
+#endif
+#ifndef BOOST_REGEX_TOKEN_ITERATOR_HPP
+#include <boost/regex/v4/regex_token_iterator.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_REGEX_GREP_HPP
+#include <boost/regex/v4/regex_grep.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_REGEX_REPLACE_HPP
+#include <boost/regex/v4/regex_replace.hpp>
+#endif
+#ifndef BOOST_REGEX_V4_REGEX_MERGE_HPP
+#include <boost/regex/v4/regex_merge.hpp>
+#endif
+#ifndef BOOST_REGEX_SPLIT_HPP
+#include <boost/regex/v4/regex_split.hpp>
+#endif
+
+#endif  // __cplusplus
+
+#endif  // include
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

lib/third_party/boost/regex/include/boost/regex/v4/regex_fwd.hpp

@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_fwd.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Forward declares boost::basic_regex<> and
+  *                associated typedefs.
+  */
+
+#ifndef BOOST_REGEX_FWD_HPP_INCLUDED
+#define BOOST_REGEX_FWD_HPP_INCLUDED
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+
+//
+// define BOOST_REGEX_NO_FWD if this
+// header doesn't work!
+//
+#ifdef BOOST_REGEX_NO_FWD
+#  ifndef BOOST_RE_REGEX_HPP
+#     include <boost/regex.hpp>
+#  endif
+#else
+
+namespace boost{
+
+template <class charT>
+class cpp_regex_traits;
+template <class charT>
+struct c_regex_traits;
+template <class charT>
+class w32_regex_traits;
+
+#ifdef BOOST_REGEX_USE_WIN32_LOCALE
+template <class charT, class implementationT = w32_regex_traits<charT> >
+struct regex_traits;
+#elif defined(BOOST_REGEX_USE_CPP_LOCALE)
+template <class charT, class implementationT = cpp_regex_traits<charT> >
+struct regex_traits;
+#else
+template <class charT, class implementationT = c_regex_traits<charT> >
+struct regex_traits;
+#endif
+
+template <class charT, class traits = regex_traits<charT> >
+class basic_regex;
+
+typedef basic_regex<char, regex_traits<char> > regex;
+#ifndef BOOST_NO_WREGEX
+typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
+#endif
+
+} // namespace boost
+
+#endif  // BOOST_REGEX_NO_FWD
+
+#endif
+
+
+
+

lib/third_party/boost/regex/include/boost/regex/v4/regex_grep.hpp

@@ -0,0 +1,155 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_grep.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Provides regex_grep implementation.
+  */
+
+#ifndef BOOST_REGEX_V4_REGEX_GREP_HPP
+#define BOOST_REGEX_V4_REGEX_GREP_HPP
+
+
+namespace boost{
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+//
+// regex_grep:
+// find all non-overlapping matches within the sequence first last:
+//
+template <class Predicate, class BidiIterator, class charT, class traits>
+inline unsigned int regex_grep(Predicate foo, 
+                               BidiIterator first, 
+                               BidiIterator last, 
+                               const basic_regex<charT, traits>& e, 
+                               match_flag_type flags = match_default)
+{
+   if(e.flags() & regex_constants::failbit)
+      return false;
+
+   typedef typename match_results<BidiIterator>::allocator_type match_allocator_type;
+
+   match_results<BidiIterator> m;
+   BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, match_allocator_type, traits> matcher(first, last, m, e, flags, first);
+   unsigned int count = 0;
+   while(matcher.find())
+   {
+      ++count;
+      if(0 == foo(m))
+         return count; // caller doesn't want to go on
+      if(m[0].second == last)
+         return count; // we've reached the end, don't try and find an extra null match.
+      if(m.length() == 0)
+      {
+         if(m[0].second == last)
+            return count;
+         // we found a NULL-match, now try to find
+         // a non-NULL one at the same position:
+         match_results<BidiIterator, match_allocator_type> m2(m);
+         matcher.setf(match_not_null | match_continuous);
+         if(matcher.find())
+         {
+            ++count;
+            if(0 == foo(m))
+               return count;
+         }
+         else
+         {
+            // reset match back to where it was:
+            m = m2;
+         }
+         matcher.unsetf((match_not_null | match_continuous) & ~flags);
+      }
+   }
+   return count;
+}
+
+//
+// regex_grep convenience interfaces:
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+//
+// this isn't really a partial specialisation, but template function
+// overloading - if the compiler doesn't support partial specialisation
+// then it really won't support this either:
+template <class Predicate, class charT, class traits>
+inline unsigned int regex_grep(Predicate foo, const charT* str, 
+                        const basic_regex<charT, traits>& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_grep(foo, str, str + traits::length(str), e, flags);
+}
+
+template <class Predicate, class ST, class SA, class charT, class traits>
+inline unsigned int regex_grep(Predicate foo, const std::basic_string<charT, ST, SA>& s, 
+                 const basic_regex<charT, traits>& e, 
+                 match_flag_type flags = match_default)
+{
+   return regex_grep(foo, s.begin(), s.end(), e, flags);
+}
+#else  // partial specialisation
+inline unsigned int regex_grep(bool (*foo)(const cmatch&), const char* str, 
+                        const regex& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_grep(foo, str, str + regex::traits_type::length(str), e, flags);
+}
+#ifndef BOOST_NO_WREGEX
+inline unsigned int regex_grep(bool (*foo)(const wcmatch&), const wchar_t* str, 
+                        const wregex& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_grep(foo, str, str + wregex::traits_type::length(str), e, flags);
+}
+#endif
+inline unsigned int regex_grep(bool (*foo)(const match_results<std::string::const_iterator>&), const std::string& s,
+                        const regex& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_grep(foo, s.begin(), s.end(), e, flags);
+}
+#if !defined(BOOST_NO_WREGEX)
+inline unsigned int regex_grep(bool (*foo)(const match_results<std::basic_string<wchar_t>::const_iterator>&), 
+                     const std::basic_string<wchar_t>& s, 
+                        const wregex& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_grep(foo, s.begin(), s.end(), e, flags);
+}
+#endif
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+} // namespace boost
+
+#endif  // BOOST_REGEX_V4_REGEX_GREP_HPP
+

lib/third_party/boost/regex/include/boost/regex/v4/regex_iterator.hpp

@@ -0,0 +1,195 @@
+/*
+ *
+ * Copyright (c) 2003
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_iterator.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Provides regex_iterator implementation.
+  */
+
+#ifndef BOOST_REGEX_V4_REGEX_ITERATOR_HPP
+#define BOOST_REGEX_V4_REGEX_ITERATOR_HPP
+
+#include <boost/shared_ptr.hpp>
+
+namespace boost{
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+template <class BidirectionalIterator, 
+          class charT,
+          class traits>
+class regex_iterator_implementation 
+{
+   typedef basic_regex<charT, traits> regex_type;
+
+   match_results<BidirectionalIterator> what;  // current match
+   BidirectionalIterator                base;  // start of sequence
+   BidirectionalIterator                end;   // end of sequence
+   const regex_type                     re;   // the expression
+   match_flag_type                      flags; // flags for matching
+
+public:
+   regex_iterator_implementation(const regex_type* p, BidirectionalIterator last, match_flag_type f)
+      : base(), end(last), re(*p), flags(f){}
+   regex_iterator_implementation(const regex_iterator_implementation& other)
+      :what(other.what), base(other.base), end(other.end), re(other.re), flags(other.flags){}
+   bool init(BidirectionalIterator first)
+   {
+      base = first;
+      return regex_search(first, end, what, re, flags);
+   }
+   bool compare(const regex_iterator_implementation& that)
+   {
+      if(this == &that) return true;
+      return (&re.get_data() == &that.re.get_data()) && (end == that.end) && (flags == that.flags) && (what[0].first == that.what[0].first) && (what[0].second == that.what[0].second);
+   }
+   const match_results<BidirectionalIterator>& get()
+   { return what; }
+   bool next()
+   {
+      //if(what.prefix().first != what[0].second)
+      //   flags |= match_prev_avail;
+      BidirectionalIterator next_start = what[0].second;
+      match_flag_type f(flags);
+      if(!what.length() || (f & regex_constants::match_posix))
+         f |= regex_constants::match_not_initial_null;
+      //if(base != next_start)
+      //   f |= regex_constants::match_not_bob;
+      bool result = regex_search(next_start, end, what, re, f, base);
+      if(result)
+         what.set_base(base);
+      return result;
+   }
+private:
+   regex_iterator_implementation& operator=(const regex_iterator_implementation&);
+};
+
+template <class BidirectionalIterator, 
+          class charT = BOOST_DEDUCED_TYPENAME BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::value_type,
+          class traits = regex_traits<charT> >
+class regex_iterator 
+{
+private:
+   typedef regex_iterator_implementation<BidirectionalIterator, charT, traits> impl;
+   typedef shared_ptr<impl> pimpl;
+public:
+   typedef          basic_regex<charT, traits>                   regex_type;
+   typedef          match_results<BidirectionalIterator>                    value_type;
+   typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type 
+                                                                            difference_type;
+   typedef          const value_type*                                       pointer;
+   typedef          const value_type&                                       reference; 
+   typedef          std::forward_iterator_tag                               iterator_category;
+   
+   regex_iterator(){}
+   regex_iterator(BidirectionalIterator a, BidirectionalIterator b, 
+                  const regex_type& re, 
+                  match_flag_type m = match_default)
+                  : pdata(new impl(&re, b, m))
+   {
+      if(!pdata->init(a))
+      {
+         pdata.reset();
+      }
+   }
+   regex_iterator(const regex_iterator& that)
+      : pdata(that.pdata) {}
+   regex_iterator& operator=(const regex_iterator& that)
+   {
+      pdata = that.pdata;
+      return *this;
+   }
+   bool operator==(const regex_iterator& that)const
+   { 
+      if((pdata.get() == 0) || (that.pdata.get() == 0))
+         return pdata.get() == that.pdata.get();
+      return pdata->compare(*(that.pdata.get())); 
+   }
+   bool operator!=(const regex_iterator& that)const
+   { return !(*this == that); }
+   const value_type& operator*()const
+   { return pdata->get(); }
+   const value_type* operator->()const
+   { return &(pdata->get()); }
+   regex_iterator& operator++()
+   {
+      cow();
+      if(0 == pdata->next())
+      {
+         pdata.reset();
+      }
+      return *this;
+   }
+   regex_iterator operator++(int)
+   {
+      regex_iterator result(*this);
+      ++(*this);
+      return result;
+   }
+private:
+
+   pimpl pdata;
+
+   void cow()
+   {
+      // copy-on-write
+      if(pdata.get() && !pdata.unique())
+      {
+         pdata.reset(new impl(*(pdata.get())));
+      }
+   }
+};
+
+typedef regex_iterator<const char*> cregex_iterator;
+typedef regex_iterator<std::string::const_iterator> sregex_iterator;
+#ifndef BOOST_NO_WREGEX
+typedef regex_iterator<const wchar_t*> wcregex_iterator;
+typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
+#endif
+
+// make_regex_iterator:
+template <class charT, class traits>
+inline regex_iterator<const charT*, charT, traits> make_regex_iterator(const charT* p, const basic_regex<charT, traits>& e, regex_constants::match_flag_type m = regex_constants::match_default)
+{
+   return regex_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, m);
+}
+template <class charT, class traits, class ST, class SA>
+inline regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, regex_constants::match_flag_type m = regex_constants::match_default)
+{
+   return regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, m);
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+} // namespace boost
+
+#endif // BOOST_REGEX_V4_REGEX_ITERATOR_HPP
+

lib/third_party/boost/regex/include/boost/regex/v4/regex_match.hpp

@@ -0,0 +1,382 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_match.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Regular expression matching algorithms.
+  *                Note this is an internal header file included
+  *                by regex.hpp, do not include on its own.
+  */
+
+
+#ifndef BOOST_REGEX_MATCH_HPP
+#define BOOST_REGEX_MATCH_HPP
+
+namespace boost{
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+//
+// proc regex_match
+// returns true if the specified regular expression matches
+// the whole of the input.  Fills in what matched in m.
+//
+template <class BidiIterator, class Allocator, class charT, class traits>
+bool regex_match(BidiIterator first, BidiIterator last, 
+                 match_results<BidiIterator, Allocator>& m, 
+                 const basic_regex<charT, traits>& e, 
+                 match_flag_type flags = match_default)
+{
+   BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, first);
+   return matcher.match();
+}
+template <class iterator, class charT, class traits>
+bool regex_match(iterator first, iterator last, 
+                 const basic_regex<charT, traits>& e, 
+                 match_flag_type flags = match_default)
+{
+   match_results<iterator> m;
+   return regex_match(first, last, m, e, flags | regex_constants::match_any);
+}
+//
+// query_match convenience interfaces:
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+//
+// this isn't really a partial specialisation, but template function
+// overloading - if the compiler doesn't support partial specialisation
+// then it really won't support this either:
+template <class charT, class Allocator, class traits>
+inline bool regex_match(const charT* str, 
+                        match_results<const charT*, Allocator>& m, 
+                        const basic_regex<charT, traits>& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(str, str + traits::length(str), m, e, flags);
+}
+
+template <class ST, class SA, class Allocator, class charT, class traits>
+inline bool regex_match(const std::basic_string<charT, ST, SA>& s, 
+                 match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 
+                 const basic_regex<charT, traits>& e, 
+                 match_flag_type flags = match_default)
+{
+   return regex_match(s.begin(), s.end(), m, e, flags);
+}
+template <class charT, class traits>
+inline bool regex_match(const charT* str, 
+                        const basic_regex<charT, traits>& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<const charT*> m;
+   return regex_match(str, str + traits::length(str), m, e, flags | regex_constants::match_any);
+}
+
+template <class ST, class SA, class charT, class traits>
+inline bool regex_match(const std::basic_string<charT, ST, SA>& s, 
+                 const basic_regex<charT, traits>& e, 
+                 match_flag_type flags = match_default)
+{
+   typedef typename std::basic_string<charT, ST, SA>::const_iterator iterator;
+   match_results<iterator> m;
+   return regex_match(s.begin(), s.end(), m, e, flags | regex_constants::match_any);
+}
+#else  // partial ordering
+inline bool regex_match(const char* str, 
+                        cmatch& m, 
+                        const regex& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(str, str + regex::traits_type::length(str), m, e, flags);
+}
+inline bool regex_match(const char* str, 
+                        const regex& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<const char*> m;
+   return regex_match(str, str + regex::traits_type::length(str), m, e, flags | regex_constants::match_any);
+}
+#ifndef BOOST_NO_STD_LOCALE
+inline bool regex_match(const char* str, 
+                        cmatch& m, 
+                        const basic_regex<char, cpp_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(str, str + regex::traits_type::length(str), m, e, flags);
+}
+inline bool regex_match(const char* str, 
+                        const basic_regex<char, cpp_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<const char*> m;
+   return regex_match(str, str + regex::traits_type::length(str), m, e, flags | regex_constants::match_any);
+}
+#endif
+inline bool regex_match(const char* str, 
+                        cmatch& m, 
+                        const basic_regex<char, c_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(str, str + regex::traits_type::length(str), m, e, flags);
+}
+inline bool regex_match(const char* str, 
+                        const basic_regex<char, c_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<const char*> m;
+   return regex_match(str, str + regex::traits_type::length(str), m, e, flags | regex_constants::match_any);
+}
+#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
+inline bool regex_match(const char* str, 
+                        cmatch& m, 
+                        const basic_regex<char, w32_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(str, str + regex::traits_type::length(str), m, e, flags);
+}
+inline bool regex_match(const char* str, 
+                        const basic_regex<char, w32_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<const char*> m;
+   return regex_match(str, str + regex::traits_type::length(str), m, e, flags | regex_constants::match_any);
+}
+#endif
+#ifndef BOOST_NO_WREGEX
+inline bool regex_match(const wchar_t* str, 
+                        wcmatch& m, 
+                        const wregex& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(str, str + wregex::traits_type::length(str), m, e, flags);
+}
+inline bool regex_match(const wchar_t* str, 
+                        const wregex& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<const wchar_t*> m;
+   return regex_match(str, str + wregex::traits_type::length(str), m, e, flags | regex_constants::match_any);
+}
+#ifndef BOOST_NO_STD_LOCALE
+inline bool regex_match(const wchar_t* str, 
+                        wcmatch& m, 
+                        const basic_regex<wchar_t, cpp_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(str, str + wregex::traits_type::length(str), m, e, flags);
+}
+inline bool regex_match(const wchar_t* str, 
+                        const basic_regex<wchar_t, cpp_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<const wchar_t*> m;
+   return regex_match(str, str + wregex::traits_type::length(str), m, e, flags | regex_constants::match_any);
+}
+#endif
+inline bool regex_match(const wchar_t* str, 
+                        wcmatch& m, 
+                        const basic_regex<wchar_t, c_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(str, str + wregex::traits_type::length(str), m, e, flags);
+}
+inline bool regex_match(const wchar_t* str, 
+                        const basic_regex<wchar_t, c_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<const wchar_t*> m;
+   return regex_match(str, str + wregex::traits_type::length(str), m, e, flags | regex_constants::match_any);
+}
+#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
+inline bool regex_match(const wchar_t* str, 
+                        wcmatch& m, 
+                        const basic_regex<wchar_t, w32_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(str, str + wregex::traits_type::length(str), m, e, flags);
+}
+inline bool regex_match(const wchar_t* str, 
+                        const basic_regex<wchar_t, w32_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<const wchar_t*> m;
+   return regex_match(str, str + wregex::traits_type::length(str), m, e, flags | regex_constants::match_any);
+}
+#endif
+#endif
+inline bool regex_match(const std::string& s, 
+                        smatch& m,
+                        const regex& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(s.begin(), s.end(), m, e, flags);
+}
+inline bool regex_match(const std::string& s, 
+                        const regex& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<std::string::const_iterator> m;
+   return regex_match(s.begin(), s.end(), m, e, flags | regex_constants::match_any);
+}
+#ifndef BOOST_NO_STD_LOCALE
+inline bool regex_match(const std::string& s, 
+                        smatch& m,
+                        const basic_regex<char, cpp_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(s.begin(), s.end(), m, e, flags);
+}
+inline bool regex_match(const std::string& s, 
+                        const basic_regex<char, cpp_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<std::string::const_iterator> m;
+   return regex_match(s.begin(), s.end(), m, e, flags | regex_constants::match_any);
+}
+#endif
+inline bool regex_match(const std::string& s, 
+                        smatch& m,
+                        const basic_regex<char, c_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(s.begin(), s.end(), m, e, flags);
+}
+inline bool regex_match(const std::string& s, 
+                        const basic_regex<char, c_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<std::string::const_iterator> m;
+   return regex_match(s.begin(), s.end(), m, e, flags | regex_constants::match_any);
+}
+#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
+inline bool regex_match(const std::string& s, 
+                        smatch& m,
+                        const basic_regex<char, w32_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(s.begin(), s.end(), m, e, flags);
+}
+inline bool regex_match(const std::string& s, 
+                        const basic_regex<char, w32_regex_traits<char> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<std::string::const_iterator> m;
+   return regex_match(s.begin(), s.end(), m, e, flags | regex_constants::match_any);
+}
+#endif
+#if !defined(BOOST_NO_WREGEX)
+inline bool regex_match(const std::basic_string<wchar_t>& s, 
+                        match_results<std::basic_string<wchar_t>::const_iterator>& m,
+                        const wregex& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(s.begin(), s.end(), m, e, flags);
+}
+inline bool regex_match(const std::basic_string<wchar_t>& s, 
+                        const wregex& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<std::basic_string<wchar_t>::const_iterator> m;
+   return regex_match(s.begin(), s.end(), m, e, flags | regex_constants::match_any);
+}
+#ifndef BOOST_NO_STD_LOCALE
+inline bool regex_match(const std::basic_string<wchar_t>& s, 
+                        match_results<std::basic_string<wchar_t>::const_iterator>& m,
+                        const basic_regex<wchar_t, cpp_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(s.begin(), s.end(), m, e, flags);
+}
+inline bool regex_match(const std::basic_string<wchar_t>& s, 
+                        const basic_regex<wchar_t, cpp_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<std::basic_string<wchar_t>::const_iterator> m;
+   return regex_match(s.begin(), s.end(), m, e, flags | regex_constants::match_any);
+}
+#endif
+inline bool regex_match(const std::basic_string<wchar_t>& s, 
+                        match_results<std::basic_string<wchar_t>::const_iterator>& m,
+                        const basic_regex<wchar_t, c_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(s.begin(), s.end(), m, e, flags);
+}
+inline bool regex_match(const std::basic_string<wchar_t>& s, 
+                        const basic_regex<wchar_t, c_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<std::basic_string<wchar_t>::const_iterator> m;
+   return regex_match(s.begin(), s.end(), m, e, flags | regex_constants::match_any);
+}
+#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
+inline bool regex_match(const std::basic_string<wchar_t>& s, 
+                        match_results<std::basic_string<wchar_t>::const_iterator>& m,
+                        const basic_regex<wchar_t, w32_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   return regex_match(s.begin(), s.end(), m, e, flags);
+}
+inline bool regex_match(const std::basic_string<wchar_t>& s, 
+                        const basic_regex<wchar_t, w32_regex_traits<wchar_t> >& e, 
+                        match_flag_type flags = match_default)
+{
+   match_results<std::basic_string<wchar_t>::const_iterator> m;
+   return regex_match(s.begin(), s.end(), m, e, flags | regex_constants::match_any);
+}
+#endif
+#endif
+
+#endif
+
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+} // namespace boost
+
+#endif   // BOOST_REGEX_MATCH_HPP
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

lib/third_party/boost/regex/include/boost/regex/v4/regex_merge.hpp

@@ -0,0 +1,93 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_format.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Provides formatting output routines for search and replace
+  *                operations.  Note this is an internal header file included
+  *                by regex.hpp, do not include on its own.
+  */
+
+#ifndef BOOST_REGEX_V4_REGEX_MERGE_HPP
+#define BOOST_REGEX_V4_REGEX_MERGE_HPP
+
+
+namespace boost{
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+template <class OutputIterator, class Iterator, class traits, class charT>
+inline OutputIterator regex_merge(OutputIterator out,
+                         Iterator first,
+                         Iterator last,
+                         const basic_regex<charT, traits>& e, 
+                         const charT* fmt, 
+                         match_flag_type flags = match_default)
+{
+   return regex_replace(out, first, last, e, fmt, flags);
+}
+
+template <class OutputIterator, class Iterator, class traits, class charT>
+inline OutputIterator regex_merge(OutputIterator out,
+                         Iterator first,
+                         Iterator last,
+                         const basic_regex<charT, traits>& e, 
+                         const std::basic_string<charT>& fmt,
+                         match_flag_type flags = match_default)
+{
+   return regex_merge(out, first, last, e, fmt.c_str(), flags);
+}
+
+template <class traits, class charT>
+inline std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
+                         const basic_regex<charT, traits>& e, 
+                         const charT* fmt,
+                         match_flag_type flags = match_default)
+{
+   return regex_replace(s, e, fmt, flags);
+}
+
+template <class traits, class charT>
+inline std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
+                         const basic_regex<charT, traits>& e, 
+                         const std::basic_string<charT>& fmt,
+                         match_flag_type flags = match_default)
+{
+   return regex_replace(s, e, fmt, flags);
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+} // namespace boost
+
+#endif  // BOOST_REGEX_V4_REGEX_MERGE_HPP
+
+

lib/third_party/boost/regex/include/boost/regex/v4/regex_raw_buffer.hpp

@@ -0,0 +1,241 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_raw_buffer.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Raw character buffer for regex code.
+  *                Note this is an internal header file included
+  *                by regex.hpp, do not include on its own.
+  */
+
+#ifndef BOOST_REGEX_RAW_BUFFER_HPP
+#define BOOST_REGEX_RAW_BUFFER_HPP
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+
+#include <algorithm>
+#include <cstddef>
+
+namespace boost{
+   namespace BOOST_REGEX_DETAIL_NS{
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+struct empty_padding{};
+
+union padding
+{
+   void* p;
+   unsigned int i;
+};
+
+template <int N>
+struct padding3
+{
+   enum{
+      padding_size = 8,
+      padding_mask = 7
+   };
+};
+
+template<>
+struct padding3<2>
+{
+   enum{
+      padding_size = 2,
+      padding_mask = 1
+   };
+};
+
+template<>
+struct padding3<4>
+{
+   enum{
+      padding_size = 4,
+      padding_mask = 3
+   };
+};
+
+template<>
+struct padding3<8>
+{
+   enum{
+      padding_size = 8,
+      padding_mask = 7
+   };
+};
+
+template<>
+struct padding3<16>
+{
+   enum{
+      padding_size = 16,
+      padding_mask = 15
+   };
+};
+
+enum{
+   padding_size = padding3<sizeof(padding)>::padding_size,
+   padding_mask = padding3<sizeof(padding)>::padding_mask
+};
+
+//
+// class raw_storage
+// basically this is a simplified vector<unsigned char>
+// this is used by basic_regex for expression storage
+//
+
+class raw_storage
+{
+public:
+   typedef std::size_t           size_type;
+   typedef unsigned char*        pointer;
+private:
+   pointer last, start, end;
+public:
+
+   raw_storage();
+   raw_storage(size_type n);
+
+   ~raw_storage()
+   {
+      ::operator delete(start);
+   }
+
+   void BOOST_REGEX_CALL resize(size_type n)
+   {
+      size_type newsize = start ? last - start : 1024;
+      while (newsize < n)
+         newsize *= 2;
+      size_type datasize = end - start;
+      // extend newsize to WORD/DWORD boundary:
+      newsize = (newsize + padding_mask) & ~(padding_mask);
+
+      // allocate and copy data:
+      pointer ptr = static_cast<pointer>(::operator new(newsize));
+      BOOST_REGEX_NOEH_ASSERT(ptr)
+         if (start)
+            std::memcpy(ptr, start, datasize);
+
+      // get rid of old buffer:
+      ::operator delete(start);
+
+      // and set up pointers:
+      start = ptr;
+      end = ptr + datasize;
+      last = ptr + newsize;
+   }
+
+   void* BOOST_REGEX_CALL extend(size_type n)
+   {
+      if(size_type(last - end) < n)
+         resize(n + (end - start));
+      pointer result = end;
+      end += n;
+      return result;
+   }
+
+   void* BOOST_REGEX_CALL insert(size_type pos, size_type n)
+   {
+      BOOST_REGEX_ASSERT(pos <= size_type(end - start));
+      if (size_type(last - end) < n)
+         resize(n + (end - start));
+      void* result = start + pos;
+      std::memmove(start + pos + n, start + pos, (end - start) - pos);
+      end += n;
+      return result;
+   }
+
+   size_type BOOST_REGEX_CALL size()
+   {
+      return size_type(end - start);
+   }
+
+   size_type BOOST_REGEX_CALL capacity()
+   {
+      return size_type(last - start);
+   }
+
+   void* BOOST_REGEX_CALL data()const
+   {
+      return start;
+   }
+
+   size_type BOOST_REGEX_CALL index(void* ptr)
+   {
+      return size_type(static_cast<pointer>(ptr) - static_cast<pointer>(data()));
+   }
+
+   void BOOST_REGEX_CALL clear()
+   {
+      end = start;
+   }
+
+   void BOOST_REGEX_CALL align()
+   {
+      // move end up to a boundary:
+      end = start + (((end - start) + padding_mask) & ~padding_mask);
+   }
+   void swap(raw_storage& that)
+   {
+      std::swap(start, that.start);
+      std::swap(end, that.end);
+      std::swap(last, that.last);
+  }
+};
+
+inline raw_storage::raw_storage()
+{
+   last = start = end = 0;
+}
+
+inline raw_storage::raw_storage(size_type n)
+{
+   start = end = static_cast<pointer>(::operator new(n));
+   BOOST_REGEX_NOEH_ASSERT(start)
+   last = start + n;
+}
+
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable: 4103)
+#endif
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+} // namespace BOOST_REGEX_DETAIL_NS
+} // namespace boost
+
+#endif
+
+
+
+
+
+