impr: Simplify tracy integration

.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://downloads.fdossena.com/geth.php?r=mesa64-latest -L -o mesa.7z
+        curl https://werwolv.net/downloads/mesa/MesaForWindows-x64-latest.7z -L -o mesa.7z
         7z e mesa.7z
         mv opengl32.dll build/install
 
@@ -153,14 +153,15 @@ jobs:
 
     - name: ⬇️ Install dependencies
       run: |
-        brew reinstall python || brew link --overwrite python || true
+        set -x
+        brew reinstall python || brew link --overwrite python
         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 || true
+        brew install glfw
 
     - name: ⬇️ Install .NET
       uses: actions/setup-dotnet@v4
@@ -173,7 +174,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}}
@@ -218,7 +219,7 @@ jobs:
           -DIMHEX_COMMIT_HASH_LONG="${GITHUB_SHA}"                                                  \
           -DIMHEX_COMMIT_BRANCH="${GITHUB_REF##*/}"                                                 \
           ..
-
+      
     - name: 🛠️ Build
       run: cd build && ninja install
 
@@ -263,7 +264,7 @@ jobs:
       uses: actions/checkout@v4
       with:
         submodules: recursive
-
+    
     - name: 📁 Restore docker /cache
       uses: actions/cache@v4
       with:
@@ -345,7 +346,7 @@ jobs:
           if-no-files-found: error
           name: macOS DMG arm64
           path: ./*.dmg
-
+  
   # Ubuntu build
   ubuntu:
     strategy:
@@ -353,7 +354,7 @@ jobs:
       matrix:
         include:
           - release_num: 22.04
-          - release_num: 24.04
+          - release_num: 23.04
 
     name: 🐧 Ubuntu ${{ matrix.release_num }}
     runs-on: ubuntu-latest
@@ -383,6 +384,11 @@ 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:
@@ -396,7 +402,7 @@ jobs:
           git config --global --add safe.directory '*'
           mkdir -p build
           cd build
-          CC=gcc-12 CXX=g++-12 cmake -G "Ninja"                       \
+          CC=gcc-13 CXX=g++-13 cmake -G "Ninja"                       \
             -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}                    \
             -DCMAKE_INSTALL_PREFIX="/usr"                             \
             -DCMAKE_C_COMPILER_LAUNCHER=ccache                        \
@@ -408,9 +414,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: |
@@ -445,7 +451,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:
@@ -531,9 +537,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: |
@@ -581,14 +587,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,7 +48,6 @@ 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 IMHEX_VERSION_PLAIN)
+loadVersion(IMHEX_VERSION)
 setVariableInParent(IMHEX_VERSION ${IMHEX_VERSION})
 configureCMake()
 
 project(imhex
         LANGUAGES       C CXX
-        VERSION         ${IMHEX_VERSION_PLAIN}
+        VERSION         ${IMHEX_VERSION}
         DESCRIPTION     "The ImHex Hex Editor"
         HOMEPAGE_URL    "https://imhex.werwolv.net"
 )
@@ -69,6 +69,7 @@ addBundledLibraries()
 add_subdirectory(lib/libimhex)
 add_subdirectory(main)
 addPluginDirectories()
+add_subdirectory(lib/trace)
 
 # Add unit tests
 if (IMHEX_ENABLE_UNIT_TESTS)

README.md

@@ -1,16 +1,13 @@
 <a href="https://imhex.werwolv.net">
   <h1 align="center">
     <picture>
-      <img height="300px" style="margin: 0; padding: 0" src="./resources/dist/common/logo/ImHexLogoSVGBG.svg">
+      <img height="300px" 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.
-    <br>
-    <a href="https://itinerarium.github.io/phoneme-synthesis/?w=/'ˈɪmhɛks/"><strong>/ˈɪmhɛks/</strong></a>
-</p>
+<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 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>
@@ -318,8 +315,7 @@ To use ImHex, the following minimal system requirements need to be met.
 
 - **OS**: 
   - **Windows**: Windows 7 or higher (Windows 10/11 recommended)
-  - **macOS**: macOS 12.1 (Monterey) or higher, 
-    - Lower versions are supported, but you'll need to compile ImHex yourself
+  - **macOS**: macOS 11 (Big Sur) or higher, 
   - **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.35.4
+1.33.0

cmake/build_helpers.cmake

@@ -59,7 +59,6 @@ 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 ".")
@@ -269,7 +268,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 --entitlements ${CMAKE_SOURCE_DIR}/resources/macos/Entitlements.plist --sign - ${CMAKE_INSTALL_PREFIX}/${BUNDLE_NAME} COMMAND_ERROR_IS_FATAL ANY)")
+                    install(CODE "execute_process(COMMAND ${CODESIGN_PATH} --force --deep --sign - ${CMAKE_INSTALL_PREFIX}/${BUNDLE_NAME} COMMAND_ERROR_IS_FATAL ANY)")
                 endif()
             endif()
 
@@ -398,14 +397,12 @@ macro(setDefaultBuiltTypeIfUnset)
     endif()
 endmacro()
 
-function(loadVersion version plain_version)
+function(loadVersion 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)
@@ -546,10 +543,8 @@ 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()
@@ -701,14 +696,6 @@ 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)
 
@@ -743,30 +730,6 @@ 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)
@@ -848,9 +811,6 @@ 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,5 +89,4 @@ 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,8 +38,4 @@ if (ZSTD_FOUND)
     message(STATUS "Found Zstd: ${ZSTD_LIBRARY}")
 endif()
 
-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})
+mark_as_advanced(ZSTD_INCLUDE_DIR 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)
+    target_link_libraries(${IMHEX_PLUGIN_NAME} PRIVATE libimhex ${FMT_LIBRARIES} imgui_all_includes libwolv tracing)
     addIncludesFromLibrary(${IMHEX_PLUGIN_NAME} libpl)
     addIncludesFromLibrary(${IMHEX_PLUGIN_NAME} libpl-gen)
 
@@ -72,23 +72,10 @@ 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})
 
-    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})
+    foreach(feature ${IMHEX_PLUGIN_FEATURES})
+        string(TOUPPER ${feature} feature)
+        add_definitions(-DIMHEX_PLUGIN_${IMHEX_PLUGIN_NAME}_FEATURE_${feature}=0)
+    endforeach()
 
     # Add the new plugin to the main dependency list so it gets built by default
     if (TARGET imhex_all)
@@ -101,28 +88,12 @@ 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(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}"
-        )
+        set_target_properties(${IMHEX_PLUGIN_NAME} PROPERTIES INSTALL_RPATH_USE_ORIGIN ON INSTALL_RPATH "$ORIGIN/")
     endif()
 
-    if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt AND IMHEX_ENABLE_UNIT_TESTS AND IMHEX_ENABLE_PLUGIN_TESTS)
+    if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt AND IMHEX_ENABLE_UNIT_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")
@@ -130,10 +101,6 @@ 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,10 +29,6 @@ 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)
@@ -48,7 +44,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/liblibimhex.dll.a"
+            IMPORTED_IMPLIB "${CMAKE_CURRENT_SOURCE_DIR}/lib/libimhex.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

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

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.svg" id="logo" alt="ImHex Logo">
+    <img src="https://raw.githubusercontent.com/WerWolv/ImHex/master/plugins/builtin/romfs/assets/dark/banner.png" 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: 0%;
+    --progress: 25%;
 }
 
 .progress-bar-container {
@@ -174,15 +174,4 @@ 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,77 +100,7 @@ var notWorkingTimer = setTimeout(() => {
 
 var Module = {
     preRun:  [],
-    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));
-            }
-        };
-    },
+    postRun: [],
     onRuntimeInitialized: function() {
         // Triggered when the wasm module is loaded and ready to use.
         document.getElementById("loading").style.display = "none"
@@ -181,55 +111,13 @@ var Module = {
     print:   (function() { })(),
     printErr: function(text) {  },
     canvas: (function() {
-        const canvas = document.getElementById('canvas');
-        canvas.addEventListener("webglcontextlost", function(e) {
-            alert('WebGL context lost, please reload the page');
-            e.preventDefault();
-        }, false);
+        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);
 
-        // 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');
-        }
+        return canvas;
     })(),
     setStatus: function(text) { },
     totalDependencies: 0,
@@ -256,9 +144,14 @@ 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,8 +36,6 @@ 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
 
@@ -125,7 +123,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::libcurl)
+    target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${CURL_LIBRARIES})
 endif()
 
 
@@ -144,7 +142,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} ${BOOST_LIBRARIES})
+target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${NLOHMANN_JSON_LIBRARIES} imgui_all_includes ${MBEDTLS_LIBRARIES} ${FMT_LIBRARIES} ${LUNASVG_LIBRARIES} tracing)
 
 set_property(TARGET libimhex PROPERTY INTERPROCEDURAL_OPTIMIZATION FALSE)
 

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

@@ -774,7 +774,6 @@ 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();
@@ -917,11 +916,6 @@ 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
@@ -987,34 +981,12 @@ namespace hex {
             namespace impl {
 
                 using Callback = std::function<std::string(prv::Provider *provider, u64 address, size_t size)>;
-                struct ExportMenuEntry {
+                struct Entry {
                     UnlocalizedString unlocalizedName;
                     Callback callback;
                 };
 
-                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();
+                const std::vector<Entry>& getEntries();
 
             }
 
@@ -1024,14 +996,7 @@ namespace hex {
              * @param unlocalizedName The unlocalized name of the formatter
              * @param callback The function to call to format the data
              */
-            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);
+            void add(const UnlocalizedString &unlocalizedName, const impl::Callback &callback);
 
         }
 
@@ -1092,7 +1057,7 @@ namespace hex {
             };
 
             struct MiniMapVisualizer {
-                using Callback = std::function<void(u64, std::span<const u8>, std::vector<ImColor>&)>;
+                using Callback = std::function<ImColor(const std::vector<u8>&)>;
 
                 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>(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_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(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,10 +58,6 @@ 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;
         };
@@ -77,12 +73,11 @@ namespace hex {
 
             explicit Event(Callback func) noexcept : m_func(std::move(func)) { }
 
-            template<typename E>
-            void call(Params... params) const {
+            void operator()(std::string_view eventName, Params... params) const {
                 try {
                     m_func(params...);
                 } catch (const std::exception &e) {
-                    log::error("An exception occurred while handling event {}: {}", wolv::type::getTypeName<E>(), e.what());
+                    log::error("An exception occurred while handling event {}: {}", eventName, e.what());
                     throw;
                 }
             }
@@ -103,7 +98,7 @@ namespace hex {
      */
     class EventManager {
     public:
-        using EventList = std::multimap<impl::EventId, std::unique_ptr<impl::EventBase>>;
+        using EventList = std::list<std::pair<impl::EventId, std::unique_ptr<impl::EventBase>>>;
 
         /**
          * @brief Subscribes to an event
@@ -116,7 +111,7 @@ namespace hex {
             std::scoped_lock lock(getEventMutex());
 
             auto &events = getEvents();
-            return events.insert({ E::Id, std::make_unique<E>(function) });
+            return events.insert(events.end(), std::make_pair(E::Id, std::make_unique<E>(function)));
         }
 
         /**
@@ -168,7 +163,7 @@ namespace hex {
             });
 
             if (iter != tokenStore.end()) {
-                getEvents().erase(iter->second);
+                getEvents().remove(*iter->second);
                 tokenStore.erase(iter);
             }
 
@@ -183,14 +178,14 @@ namespace hex {
         static void post(auto && ...args) {
             std::scoped_lock lock(getEventMutex());
 
-            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)...);
+            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)...);
+                }
             }
 
             #if defined (DEBUG)
-                if constexpr (E::ShouldLog)
+                if (E::ShouldLog)
                     log::debug("Event posted: '{}'", wolv::type::getTypeName<E>());
             #endif
         }
@@ -270,7 +265,6 @@ 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
@@ -280,7 +274,6 @@ 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<std::set<Region>(const prv::Provider *, u64, size_t)>;
+                using HoveringFunction = std::function<bool(const prv::Provider *, u64, const u8*, size_t)>;
 
                 const std::map<u32, Highlighting>& getBackgroundHighlights();
                 const std::map<u32, HighlightingFunction>& getBackgroundHighlightingFunctions();
@@ -293,7 +293,7 @@ namespace hex {
             namespace impl {
 
                 void resetClosingProvider();
-                std::set<prv::Provider*> getClosingProviders();
+                const std::set<prv::Provider*>& getClosingProviders();
 
             }
 
@@ -434,7 +434,6 @@ 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 = { });
 
@@ -574,12 +573,6 @@ 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
@@ -604,16 +597,6 @@ 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
@@ -639,12 +622,6 @@ 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,9 +102,12 @@ namespace hex {
         std::string m_unlocalizedString;
     };
 
-    // {fmt} formatter for hex::Lang
-    inline auto format_as(const hex::Lang &entry) {
-        return entry.get();
-    }
+}
 
-}
+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);
+    }
+};

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

@@ -119,8 +119,6 @@ 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
@@ -147,10 +145,6 @@ 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

@@ -1,111 +0,0 @@
-#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,7 +2,6 @@
 
 #include <string_view>
 #include <fmt/format.h>
-#include <fmt/ranges.h>
 
 namespace hex {
 

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

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <hex.hpp>
+
 #include <string>
 #include <vector>
 #include <filesystem>
@@ -29,7 +31,36 @@ 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,10 +61,6 @@ 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,7 +298,31 @@ namespace hex {
 
     [[nodiscard]] std::optional<std::string> getEnvironmentVariable(const std::string &env);
 
-    [[nodiscard]] std::string limitStringLength(const std::string &string, size_t maxLength);
+    [[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::optional<std::fs::path> getInitialFilePath();
 

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

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

lib/libimhex/include/hex/plugin.hpp

@@ -37,34 +37,15 @@ 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 plugin list on the Welcome screen.
+ * Name, Author and Description will be displayed in the 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)
@@ -104,7 +85,6 @@ void* PluginSubCommandsFunctionHelper<T>::getSubCommands() {
         ImGui::SetCurrentContext(ctx);                                                                                          \
         GImGui = ctx;                                                                                                           \
     }                                                                                                                           \
-    IMHEX_DEFINE_PLUGIN_FEATURES();                                                                                             \
     IMHEX_PLUGIN_VISIBILITY_PREFIX void* getFeatures() {                                                                        \
         return PluginFeatureFunctionHelper<PluginFunctionHelperInstantiation>::getFeatures();                                   \
     }                                                                                                                           \
@@ -149,3 +129,18 @@ 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,8 +123,6 @@ 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);
@@ -188,12 +186,7 @@ namespace ImGuiExt {
     void SmallProgressBar(float fraction, float yOffset = 0.0F);
 
     inline void TextFormatted(std::string_view fmt, auto &&...args) {
-        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());
-        }
+        ImGui::TextUnformatted(hex::format(fmt, std::forward<decltype(args)>(args)...).c_str());
     }
 
     inline void TextFormattedSelectable(std::string_view fmt, auto &&...args) {
@@ -215,24 +208,15 @@ namespace ImGuiExt {
     }
 
     inline void TextFormattedColored(ImColor color, std::string_view fmt, auto &&...args) {
-        ImGui::PushStyleColor(ImGuiCol_Text, color.Value);
-        ImGuiExt::TextFormatted(fmt, std::forward<decltype(args)>(args)...);
-        ImGui::PopStyleColor();
+        ImGui::TextColored(color, "%s", hex::format(fmt, std::forward<decltype(args)>(args)...).c_str());
     }
 
     inline void TextFormattedDisabled(std::string_view fmt, auto &&...args) {
-        ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetStyle().Colors[ImGuiCol_TextDisabled]);
-        ImGuiExt::TextFormatted(fmt, std::forward<decltype(args)>(args)...);
-        ImGui::PopStyleColor();
+        ImGui::TextDisabled("%s", hex::format(fmt, std::forward<decltype(args)>(args)...).c_str());
     }
 
     inline void TextFormattedWrapped(std::string_view fmt, auto &&...args) {
-        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();
+        ImGui::TextWrapped("%s", hex::format(fmt, std::forward<decltype(args)>(args)...).c_str());
     }
 
     inline void TextFormattedWrappedSelectable(std::string_view fmt, auto &&...args) {
@@ -302,7 +286,7 @@ namespace ImGuiExt {
     bool BeginBox();
     void EndBox();
 
-    bool BeginSubWindow(const char *label, bool *collapsed = nullptr, ImVec2 size = ImVec2(0, 0), ImGuiChildFlags flags = ImGuiChildFlags_None);
+    void BeginSubWindow(const char *label, 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,7 +158,6 @@ 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,7 +2,6 @@
 #include <hex/api/event_manager.hpp>
 
 #include <hex/helpers/auto_reset.hpp>
-#include <hex/helpers/default_paths.hpp>
 
 #include <nlohmann/json.hpp>
 
@@ -198,7 +197,7 @@ namespace hex {
     constexpr static auto AchievementsFile = "achievements.json";
 
     void AchievementManager::loadProgress() {
-        for (const auto &directory : paths::Config.read()) {
+        for (const auto &directory : fs::getDefaultPaths(fs::ImHexPath::Config)) {
             auto path = directory / AchievementsFile;
 
             if (!wolv::io::fs::exists(path)) {
@@ -247,7 +246,7 @@ namespace hex {
         if (json.empty())
             return;
 
-        for (const auto &directory : paths::Config.write()) {
+        for (const auto &directory : fs::getDefaultPaths(fs::ImHexPath::Config)) {
             auto path = directory / AchievementsFile;
 
             wolv::io::File file(path, wolv::io::File::Mode::Create);

lib/libimhex/source/api/content_registry.cpp

@@ -4,7 +4,6 @@
 #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>
@@ -102,7 +101,7 @@ namespace hex {
 
                 void load() {
                     bool loaded = false;
-                    for (const auto &dir : paths::Config.read()) {
+                    for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Config)) {
                         wolv::io::File file(dir / SettingsFile, wolv::io::File::Mode::Read);
 
                         if (file.isValid()) {
@@ -143,7 +142,7 @@ namespace hex {
                     if (result.empty()) {
                         return;
                     }
-                    for (const auto &dir : paths::Config.write()) {
+                    for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Config)) {
                         wolv::io::File file(dir / SettingsFile, wolv::io::File::Mode::Create);
 
                         if (file.isValid()) {
@@ -154,7 +153,7 @@ namespace hex {
                 }
 
                 void clear() {
-                    for (const auto &dir : paths::Config.write()) {
+                    for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Config)) {
                         wolv::io::fs::remove(dir / SettingsFile);
                     }
                 }
@@ -596,7 +595,7 @@ namespace hex {
                 );
             }
 
-            runtime.setIncludePaths(paths::PatternsInclude.read() | paths::Patterns.read());
+            runtime.setIncludePaths(fs::getDefaultPaths(fs::ImHexPath::PatternsInclude) | fs::getDefaultPaths(fs::ImHexPath::Patterns));
 
             for (const auto &[ns, name, paramCount, callback, dangerous] : impl::getFunctions()) {
                 if (dangerous)
@@ -821,12 +820,6 @@ 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;
             }
@@ -936,35 +929,11 @@ 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 });
@@ -1013,28 +982,17 @@ namespace hex {
 
         namespace impl {
 
-            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;
+            static AutoReset<std::vector<Entry>> s_entries;
+            const std::vector<Entry>& getEntries() {
+                return *s_entries;
             }
 
         }
 
-        void addExportMenuEntry(const UnlocalizedString &unlocalizedName, const impl::Callback &callback) {
+        void add(const UnlocalizedString &unlocalizedName, const impl::Callback &callback) {
             log::debug("Registered new data formatter: {}", unlocalizedName.get());
 
-            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 });
+            impl::s_entries->push_back({ unlocalizedName, callback });
         }
 
     }

lib/libimhex/source/api/imhex_api.cpp

@@ -15,7 +15,6 @@
 #include <imgui.h>
 #include <imgui_internal.h>
 #include <set>
-#include <algorithm>
 #include <GLFW/glfw3.h>
 
 #if defined(OS_WINDOWS)
@@ -184,24 +183,24 @@ namespace hex {
             impl::s_hoveringFunctions->erase(id);
         }
 
-        static u32 s_tooltipId = 0;
+        static u32 tooltipId = 0;
         u32 addTooltip(Region region, std::string value, color_t color) {
-            s_tooltipId++;
-            impl::s_tooltips->insert({ s_tooltipId, { region, std::move(value), color } });
+            tooltipId++;
+            impl::s_tooltips->insert({ tooltipId, { region, std::move(value), color } });
 
-            return s_tooltipId;
+            return tooltipId;
         }
 
         void removeTooltip(u32 id) {
             impl::s_tooltips->erase(id);
         }
 
-        static u32 s_tooltipFunctionId;
+        static u32 tooltipFunctionId;
         u32 addTooltipProvider(TooltipFunction function) {
-            s_tooltipFunctionId++;
-            impl::s_tooltipFunctions->insert({ s_tooltipFunctionId, std::move(function) });
+            tooltipFunctionId++;
+            impl::s_tooltipFunctions->insert({ tooltipFunctionId, std::move(function) });
 
-            return s_tooltipFunctionId;
+            return tooltipFunctionId;
         }
 
         void removeTooltipProvider(u32 id) {
@@ -268,7 +267,6 @@ 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 {
 
@@ -277,7 +275,7 @@ namespace hex {
                 s_closingProviders.clear();
             }
 
-            std::set<prv::Provider*> getClosingProviders() {
+            const std::set<prv::Provider*>& getClosingProviders() {
                 return s_closingProviders;
             }
 
@@ -338,7 +336,6 @@ namespace hex {
 
         void markDirty() {
             get()->markDirty();
-            EventProviderDirtied::post(get());
         }
 
         void resetDirty() {
@@ -426,37 +423,20 @@ namespace hex {
                 }
             }
 
-            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());
+            provider->close();
+            EventProviderClosed::post(provider);
             RequestUpdateWindowTitle::post();
 
-            // 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();
+            TaskManager::runWhenTasksFinished([it, provider] {
+                EventProviderDeleted::post(provider);
+                impl::s_closingProviders.erase(provider);
 
-                    provider->close();
-                });
+                s_providers->erase(it);
+                if (s_currentProvider >= i64(s_providers->size()))
+                    setCurrentProvider(0);
+
+                if (s_providers->empty())
+                    EventProviderChanged::post(provider, nullptr);
             });
         }
 
@@ -532,11 +512,6 @@ 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;
@@ -638,7 +613,7 @@ namespace hex {
         }
 
         void* getLibImHexModuleHandle() {
-            return hex::getContainingModule(reinterpret_cast<void*>(&getLibImHexModuleHandle));
+            return hex::getContainingModule((void*)&getLibImHexModuleHandle);
         }
 
 
@@ -681,10 +656,6 @@ 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())
@@ -771,25 +742,6 @@ 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) {
@@ -832,10 +784,6 @@ 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;
@@ -862,7 +810,7 @@ namespace hex {
 
             EventImHexClosing::subscribe([executablePath, updateTypeString] {
                 hex::executeCommand(
-                        hex::format("\"{}\" \"{}\"",
+                        hex::format("{} {}",
                                     wolv::util::toUTF8String(executablePath),
                                     updateTypeString
                                     )
@@ -941,9 +889,9 @@ namespace hex {
                 s_fontSize = size;
             }
 
-            static AutoReset<ImFontAtlas*> s_fontAtlas;
+            static AutoReset<std::shared_ptr<ImFontAtlas>> s_fontAtlas;
             void setFontAtlas(ImFontAtlas* fontAtlas) {
-                s_fontAtlas = fontAtlas;
+                s_fontAtlas = std::unique_ptr<ImFontAtlas, void(*)(ImFontAtlas*)>(fontAtlas, IM_DELETE);
             }
 
             static ImFont *s_boldFont = nullptr;
@@ -1026,7 +974,7 @@ namespace hex {
         }
 
         ImFontAtlas* getFontAtlas() {
-            return impl::s_fontAtlas;
+            return impl::s_fontAtlas->get();
         }
 
         ImFont* Bold() {

lib/libimhex/source/api/layout_manager.cpp

@@ -1,15 +1,13 @@
 #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 {
 
@@ -42,7 +40,10 @@ namespace hex {
         fileName += ".hexlyt";
 
         std::fs::path layoutPath;
-        for (const auto &path : paths::Layouts.write()) {
+        for (const auto &path : hex::fs::getDefaultPaths(fs::ImHexPath::Layouts)) {
+            if (!hex::fs::isPathWritable(layoutPath))
+                continue;
+
             layoutPath = path / fileName;
         }
 
@@ -108,7 +109,7 @@ namespace hex {
     void LayoutManager::reload() {
         s_layouts->clear();
 
-        for (const auto &directory : paths::Layouts.read()) {
+        for (const auto &directory : hex::fs::getDefaultPaths(fs::ImHexPath::Layouts)) {
             for (const auto &entry : std::fs::directory_iterator(directory)) {
                 const auto &path = entry.path();
 

lib/libimhex/source/api/plugin_manager.cpp

@@ -5,7 +5,6 @@
 #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>
 
@@ -307,7 +306,7 @@ namespace hex {
 
     bool PluginManager::loadLibraries() {
         bool success = true;
-        for (const auto &loadPath : paths::Libraries.read())
+        for (const auto &loadPath : fs::getDefaultPaths(fs::ImHexPath::Libraries))
             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(
-                        ::GetModuleHandleW(L"Kernel32.dll"),
+                        ::GetModuleHandle("Kernel32.dll"),
                         "SetThreadDescription"
                     )
                 )

lib/libimhex/source/api/tutorial_manager.cpp

@@ -21,11 +21,6 @@ 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:
@@ -61,42 +56,8 @@ 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;
@@ -111,28 +72,6 @@ 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())
@@ -142,30 +81,6 @@ 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();
 
@@ -326,13 +241,39 @@ namespace hex {
             m_onAppear();
 
         for (const auto &[text, ids] : m_highlights) {
-            s_highlights->emplace(calculateId(ids), text);
+            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);
         }
     }
 
     void TutorialManager::Tutorial::Step::removeHighlights() const {
         for (const auto &[text, ids] : m_highlights) {
-            s_highlights->erase(calculateId(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);
+            }
+
+            s_highlights->erase(idStack.get());
         }
     }
 
@@ -427,4 +368,15 @@ 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,7 +3,6 @@
 
 #include <hex/helpers/logger.hpp>
 #include <hex/helpers/auto_reset.hpp>
-#include <hex/helpers/default_paths.hpp>
 
 #include <wolv/io/file.hpp>
 
@@ -26,7 +25,7 @@ namespace hex {
             .builtin = false
         }).first;
 
-        for (const auto &workspaceFolder : paths::Workspaces.write()) {
+        for (const auto &workspaceFolder : fs::getDefaultPaths(fs::ImHexPath::Workspaces)) {
             const auto workspacePath = workspaceFolder / (name + ".hexws");
             if (exportToFile(workspacePath)) {
                 s_currentWorkspace->second.path = workspacePath;
@@ -158,7 +157,7 @@ namespace hex {
     void WorkspaceManager::reload() {
         WorkspaceManager::reset();
 
-        for (const auto &defaultPath : paths::Workspaces.read()) {
+        for (const auto &defaultPath : fs::getDefaultPaths(fs::ImHexPath::Workspaces)) {
             for (const auto &entry : std::fs::directory_iterator(defaultPath)) {
                 if (!entry.is_regular_file()) {
                     continue;

lib/libimhex/source/helpers/default_paths.cpp

@@ -1,153 +0,0 @@
-#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,37 +24,6 @@
     #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>
@@ -63,9 +32,6 @@
 #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;
@@ -82,7 +48,7 @@ namespace hex::fs {
 
         #if defined(OS_WINDOWS)
             hex::unused(
-                ShellExecuteW(nullptr, L"open", filePath.c_str(), nullptr, nullptr, SW_SHOWNORMAL)
+                ShellExecute(nullptr, "open", wolv::util::toUTF8String(filePath).c_str(), nullptr, nullptr, SW_SHOWNORMAL)
             );
         #elif defined(OS_MACOS)
             hex::unused(system(
@@ -100,8 +66,9 @@ namespace hex::fs {
         }
 
         #if defined(OS_WINDOWS)
-            auto args = fmt::format(L"\"{}\"", dirPath.c_str());
-            ShellExecuteW(nullptr, L"open", L"explorer.exe", args.c_str(), nullptr, SW_SHOWNORMAL);
+            hex::unused(system(
+                hex::format("explorer.exe {}", wolv::util::toUTF8String(dirPath)).c_str()
+            ));
         #elif defined(OS_MACOS)
             hex::unused(system(
                 hex::format("open {}", wolv::util::toUTF8String(dirPath)).c_str()
@@ -118,8 +85,9 @@ namespace hex::fs {
         }
 
         #if defined(OS_WINDOWS)
-            auto args = fmt::format(L"/select,\"{}\"", selectedFilePath.c_str());
-            ShellExecuteW(nullptr, L"open", L"explorer.exe", args.c_str(), nullptr, SW_SHOWNORMAL);
+            hex::unused(system(
+                hex::format(R"(explorer.exe /select,"{}")", wolv::util::toUTF8String(selectedFilePath)).c_str()
+            ));
         #elif defined(OS_MACOS)
             hex::unused(system(
                 hex::format(
@@ -264,22 +232,20 @@ 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(), nativeWindow);
+                        result = NFD::OpenDialogMultiple(outPaths, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str());
                     else
-                        result = NFD::OpenDialog(outPath, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str(), nativeWindow);
+                        result = NFD::OpenDialog(outPath, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str());
                     break;
                 case DialogMode::Save:
-                    result = NFD::SaveDialog(outPath, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str(), nullptr, nativeWindow);
+                    result = NFD::SaveDialog(outPath, validExtensionsNfd.data(), validExtensionsNfd.size(), defaultPath.empty() ? nullptr : defaultPath.c_str());
                     break;
                 case DialogMode::Folder:
-                    result = NFD::PickFolder(outPath, defaultPath.empty() ? nullptr : defaultPath.c_str(), nativeWindow);
+                    result = NFD::PickFolder(outPath, defaultPath.empty() ? nullptr : defaultPath.c_str());
                     break;
             }
 
@@ -320,6 +286,170 @@ 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

@@ -1,15 +0,0 @@
-#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,10 +2,8 @@
 
 #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>
 
@@ -82,7 +80,7 @@ namespace hex::log {
         void redirectToFile() {
             if (s_loggerFile.isValid()) return;
 
-            for (const auto &path : paths::Logs.all()) {
+            for (const auto &path : fs::getDefaultPaths(fs::ImHexPath::Logs, true)) {
                 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();
@@ -144,12 +142,14 @@ namespace hex::log {
             fmt::print(dest, "{0}", std::string(projectNameLength > MaxTagLength ? 0 : MaxTagLength - projectNameLength, ' '));
         }
 
-        void assertionHandler(const char* exprString, const char* file, int line) {
-            log::error("Assertion failed: {} at {}:{}", exprString, file, line);
+        void assertionHandler(bool expr, const char* exprString, const char* file, int line) {
+            if (!expr) {
+                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,7 +3,6 @@
 #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>
@@ -30,7 +29,7 @@ namespace hex::magic {
         std::string magicFiles;
 
         std::error_code error;
-        for (const auto &dir : paths::Magic.read()) {
+        for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Magic)) {
             for (const auto &entry : std::fs::directory_iterator(dir, error)) {
                 auto path = std::fs::absolute(entry.path());
 
@@ -65,12 +64,12 @@ namespace hex::magic {
         if (magicFiles->empty())
             return true;
 
-        std::array<char, 1024> cwd = { };
+        std::array<char, 1024> cwd = { 0x00 };
         if (getcwd(cwd.data(), cwd.size()) == nullptr)
             return false;
 
         std::optional<std::fs::path> magicFolder;
-        for (const auto &dir : paths::Magic.write()) {
+        for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Magic)) {
             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)
-            ShellExecuteA(nullptr, "open", url.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
+            ShellExecute(nullptr, "open", url.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
         #elif defined(OS_MACOS)
             openWebpageMacos(url.c_str());
         #elif defined(OS_LINUX)
@@ -679,44 +679,6 @@ 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,12 +118,6 @@
         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,7 +20,6 @@ namespace hex::subcommands {
                 }
             }
         }
-
         return std::nullopt;
     }
 
@@ -28,8 +27,7 @@ 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;
 
@@ -78,18 +76,18 @@ namespace hex::subcommands {
         }
 
         // Save last command to run
-        if (currentSubCommand.has_value()) {
+        if (currentSubCommand) {
             subCommands.emplace_back(*currentSubCommand, currentSubCommandArgs);
         }
 
         // Run the subcommands
-        for (auto &[subcommand, args] : subCommands) {
-            subcommand.callback(args);
+        for (auto& subCommandPair : subCommands) {
+            subCommandPair.first.callback(subCommandPair.second);
         }
 
-        // Exit the process if it's not the main instance (the commands have been forwarded to another instance)
+        // Exit the process if its not the main instance (the commands have been forwarded to another instance)
         if (!ImHexApi::System::isMainInstance()) {
-            std::exit(0);
+            exit(0);
         }
     }
 
@@ -97,15 +95,12 @@ namespace hex::subcommands {
         log::debug("Forwarding subcommand {} (maybe to us)", cmdName);
 
         std::vector<u8> data;
-        if (!args.empty()) {
-            for (const auto &arg: args) {
-                data.insert(data.end(), arg.begin(), arg.end());
-                data.push_back('\0');
-            }
-
-            data.pop_back();
+        for (const auto &arg: args) {
+            data.insert(data.end(), arg.begin(), arg.end());
+            data.push_back('\0');
         }
-
+        data.erase(data.end()-1);
+        
         SendMessageToMainInstance::post(hex::format("command/{}", cmdName), data);
     }
 

lib/libimhex/source/ui/imgui_imhex_extensions.cpp

@@ -285,10 +285,6 @@ 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);
@@ -518,7 +514,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, 0));
+        PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, GetStyle().FramePadding.y));
         PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0F);
 
         PushStyleColor(ImGuiCol_Text, iconColor);
@@ -526,7 +522,7 @@ namespace ImGuiExt {
         PopStyleColor();
 
         if (IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
-            SetNextWindowSizeConstraints(ImVec2(GetTextLineHeight() * 25, 0), ImVec2(GetTextLineHeight() * 35, FLT_MAX));
+            SetNextWindowSizeConstraints(ImVec2(GetTextLineHeight() * 25, 0), ImVec2(GetTextLineHeight() * 25, FLT_MAX));
             BeginTooltip();
             TextFormattedWrapped("{}", text);
             EndTooltip();
@@ -575,27 +571,15 @@ namespace ImGuiExt {
         ImGuiID hoveredID = GetHoveredID();
 
         bool result = false;
-        if (IsItemHovered(ImGuiHoveredFlags_DelayNormal) && (currTime - lastMoveTime) >= 0.5 && hoveredID == lastHoveredID) {
+        if (IsItemHovered() && (currTime - lastMoveTime) >= 0.5 && hoveredID == lastHoveredID) {
             if (!std::string_view(text).empty()) {
-                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));
-
+                const auto width = 300 * hex::ImHexApi::System::getGlobalScale();
+                ImGui::SetNextWindowSizeConstraints(ImVec2(width, 0), ImVec2(width, FLT_MAX));
                 if (BeginTooltip()) {
                     if (isSeparator)
                         SeparatorText(text);
-                    else {
-                        if (wrapping)
-                            TextFormattedWrapped("{}", text);
-                        else
-                            TextFormatted("{}", text);
-                    }
+                    else
+                        TextFormattedWrapped("{}", text);
 
                     EndTooltip();
                 }
@@ -768,9 +752,7 @@ 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 padding = (size - label_size) / 2;
+        ImVec2 size = CalcItemSize(ImVec2(1, 1) * GetCurrentWindow()->MenuBarHeight(), label_size.x + style.FramePadding.x * 2.0F, label_size.y + style.FramePadding.y * 2.0F);
 
         const ImRect bb(pos, pos + size);
         ItemSize(size, style.FramePadding.y);
@@ -787,7 +769,7 @@ namespace ImGuiExt {
                                                                                                  : ImGuiCol_MenuBarBg);
         RenderNavHighlight(bb, id);
         RenderFrame(bb.Min, bb.Max, col, false, style.FrameRounding);
-        RenderTextClipped(bb.Min + padding, bb.Max - padding, symbol, nullptr, &size, style.ButtonTextAlign, &bb);
+        RenderTextClipped(bb.Min + style.FramePadding, bb.Max - style.FramePadding, symbol, nullptr, &label_size, style.ButtonTextAlign, &bb);
 
         PopStyleColor();
 
@@ -963,7 +945,7 @@ namespace ImGuiExt {
 
         SetCursorPosX(GetCursorPosX() + frame_size.x);
 
-        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);
+        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);
 
         if (value_changed)
             MarkItemEdited(GImGui->LastItemData.ID);
@@ -1174,37 +1156,17 @@ namespace ImGuiExt {
         PopStyleVar();
     }
 
-    bool BeginSubWindow(const char *label, bool *collapsed, ImVec2 size, ImGuiChildFlags flags) {
+    void BeginSubWindow(const char *label, 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()) {
-                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::TextUnformatted(label);
                 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 fmt::format("{}###{}", Lang(unlocalizedName), unlocalizedName.get());
+        return Lang(unlocalizedName) + "###" + unlocalizedName.get();
     }
 
 }

lib/third_party/boost/CMakeLists.txt

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

lib/third_party/boost/regex/CMakeLists.txt

@@ -1,10 +0,0 @@
-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

@@ -1,43 +0,0 @@
-/*
- *
- * 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

@@ -1,100 +0,0 @@
-/*
- *
- * 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

@@ -1,41 +0,0 @@
-/*
- *
- * 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

@@ -1,480 +0,0 @@
-/*
- *
- * 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

@@ -1,72 +0,0 @@
-/*
- *
- * 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

@@ -1,207 +0,0 @@
-/*
- *
- * 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

@@ -1,30 +0,0 @@
-/*
- *
- * 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

@@ -1,186 +0,0 @@
-/*
- *
- * 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

@@ -1,32 +0,0 @@
-/*
- *
- * 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

@@ -1,29 +0,0 @@
-/*
- *
- * 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

@@ -1,182 +0,0 @@
-/*
- *
- * 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

@@ -1,32 +0,0 @@
-/*
- *
- * 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

@@ -1,39 +0,0 @@
-/*
- *
- * 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

@@ -1,95 +0,0 @@
-/*
- *
- * 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

@@ -1,797 +0,0 @@
-/*
- *
- * 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

@@ -1,511 +0,0 @@
-/*
- *
- * 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

@@ -1,81 +0,0 @@
-/*
- *
- * 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

@@ -1,213 +0,0 @@
-/*
- *
- * 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

@@ -1,59 +0,0 @@
-/*
- *
- * 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

@@ -1,54 +0,0 @@
-/*
- *
- * 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

@@ -1,91 +0,0 @@
-/*
- *
- * 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

@@ -1,135 +0,0 @@
-/*
- *
- * 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

@@ -1,161 +0,0 @@
-/*
- *
- * 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

@@ -1,716 +0,0 @@
-/*
- *
- * 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

@@ -1,183 +0,0 @@
- /*
- * 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

@@ -1,171 +0,0 @@
-/*
- *
- * 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

@@ -1,128 +0,0 @@
-/*
- *
- * 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

@@ -1,645 +0,0 @@
-/*
- *
- * 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

@@ -1,146 +0,0 @@
-/*
- *
- * 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

@@ -1,83 +0,0 @@
-/*
- *
- * 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

@@ -1,180 +0,0 @@
-/*
- *
- * 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

@@ -1,166 +0,0 @@
-/*
- *
- * 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

@@ -1,73 +0,0 @@
-/*
- *
- * 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

@@ -1,155 +0,0 @@
-/*
- *
- * 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

@@ -1,195 +0,0 @@
-/*
- *
- * 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

@@ -1,382 +0,0 @@
-/*
- *
- * 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

@@ -1,93 +0,0 @@
-/*
- *
- * 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

@@ -1,241 +0,0 @@
-/*
- *
- * 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
-
-
-
-
-
-