Convert other uses of 0xABCD back to ABCDh

This reverts commit 9cc9518f8b.

.github/workflows/main.yml

@@ -0,0 +1,418 @@
+name: CI/CD
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+# Release builds
+  build_release_macos:
+    name: Release build (macOS universal, static Qt 6.5.0)
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Get Qt
+        uses: actions/checkout@v3
+        with:
+          repository: LongSoft/qt-6-static-universal-macos
+          path: qt
+          lfs: true
+      - name: Unpack Qt
+        shell: bash
+        working-directory: qt
+        run: sudo 7z x qt-6.5.0-static-universal-macos.7z -o/opt
+      - name: Create build directory
+        run: cmake -E make_directory ${{runner.workspace}}/build
+      - name: Configure everything
+        working-directory: ${{runner.workspace}}/build
+        run: cmake -DCMAKE_PREFIX_PATH="/opt/qt-6.5.0-static-universal-macos" -DCMAKE_OSX_ARCHITECTURES="x86_64;arm64" -DCMAKE_OSX_DEPLOYMENT_TARGET="11.0" ../UEFITool
+      - name: Build everything
+        working-directory: ${{runner.workspace}}/build
+        shell: bash
+        run: cmake --build . --config Release
+      - name: Create dist directory
+        run: cmake -E make_directory ${{runner.workspace}}/UEFITool/dist
+      - name: Signed archive everything
+        if: github.repository_owner == 'LongSoft'
+        working-directory: ${{runner.workspace}}/build
+        env:
+          MAC_CERTIFICATE_PASSWORD: ${{ secrets.MAC_CERTIFICATE_PASSWORD }}
+          MAC_ACCOUNT_NAME: ${{ secrets.MAC_ACCOUNT_NAME }}
+          MAC_ACCOUNT_PASSWORD: ${{ secrets.MAC_ACCOUNT_PASSWORD }}
+        shell: bash
+        run: |
+          UEFITOOL_VER=$(cat ../UEFITool/version.h | grep PROGRAM_VERSION | cut -d'"' -f2 | sed 's/NE alpha /A/') ; \
+          codesign -fs - UEFIExtract/UEFIExtract
+          codesign -fs - UEFIFind/UEFIFind
+          zip -qryj ../UEFITool/dist/UEFIExtract_NE_${UEFITOOL_VER}_universal_mac.zip ./UEFIExtract/UEFIExtract
+          zip -qryj ../UEFITool/dist/UEFIFind_NE_${UEFITOOL_VER}_universal_mac.zip ./UEFIFind/UEFIFind
+          brew install create-dmg || exit 1
+          curl -OL "https://github.com/acidanthera/ocbuild/raw/master/codesign/appsign.sh" || exit 1
+          chmod a+x appsign.sh || exit 1
+          "$(pwd)/appsign.sh" ./UEFITool/UEFITool.app ../UEFITool/dist/UEFITool_NE_${UEFITOOL_VER}_universal_mac.dmg
+      - name: Archive everything
+        if: github.repository_owner != 'LongSoft'
+        working-directory: ${{runner.workspace}}/build
+        shell: bash
+        run: |
+          UEFITOOL_VER=$(cat ../UEFITool/version.h | grep PROGRAM_VERSION | cut -d'"' -f2 | sed 's/NE alpha /A/') ; \
+          codesign -fs - UEFIExtract/UEFIExtract
+          codesign -fs - UEFIFind/UEFIFind
+          zip -qryj ../UEFITool/dist/UEFIExtract_NE_${UEFITOOL_VER}_universal_mac.zip ./UEFIExtract/UEFIExtract
+          zip -qryj ../UEFITool/dist/UEFIFind_NE_${UEFITOOL_VER}_universal_mac.zip ./UEFIFind/UEFIFind
+          cd UEFITool
+          codesign -fs - --deep UEFITool.app
+          zip -qry ../../UEFITool/dist/UEFITool_NE_${UEFITOOL_VER}_universal_mac.zip ./UEFITool.app
+      - name: Upload to artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: macOS builds
+          path: dist/*
+      - name: Upload to releases
+        if: github.event_name == 'release'
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: dist/*
+          tag: ${{ github.ref }}
+          file_glob: true
+
+  build_release_linux:
+    name: Release build (Linux x64, shared Qt 6)
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - name: Get Qt
+        run: | 
+          sudo apt update
+          sudo apt-get install -qq zip cmake libgl1-mesa-dev qt6-base-dev
+      - name: Create build directory
+        run: cmake -E make_directory ${{runner.workspace}}/build
+      - name: Configure everything
+        working-directory: ${{runner.workspace}}/build
+        run: cmake ../UEFITool
+      - name: Build everything
+        working-directory: ${{runner.workspace}}/build
+        shell: bash
+        run: cmake --build . --config Release
+      - name: Create dist directory
+        run: cmake -E make_directory ${{runner.workspace}}/UEFITool/dist
+      - name: Archive everything
+        working-directory: ${{runner.workspace}}/build
+        shell: bash
+        run: |
+          UEFITOOL_VER=$(cat ../UEFITool/version.h | grep PROGRAM_VERSION | cut -d'"' -f2 | sed 's/NE alpha /A/') ; \
+          zip -qryj ../UEFITool/dist/UEFIExtract_NE_${UEFITOOL_VER}_x64_linux.zip ./UEFIExtract/uefiextract
+          zip -qryj ../UEFITool/dist/UEFIFind_NE_${UEFITOOL_VER}_x64_linux.zip ./UEFIFind/uefifind
+          zip -qryj ../UEFITool/dist/UEFITool_NE_${UEFITOOL_VER}_x64_linux.zip ./UEFITool/uefitool
+      - name: Upload to artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: Linux builds
+          path: dist/*.zip
+      - name: Upload to releases
+        if: github.event_name == 'release'
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: dist/*.zip
+          tag: ${{ github.ref }}
+          file_glob: true
+
+  build_release_freebsd:
+    name: Release build (FreeBSD x64, shared Qt 6)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build on FreeBSD inside Ubuntu VM
+        id: test
+        uses: cross-platform-actions/action@v0.27.0
+        with:
+          operating_system: freebsd
+          version: '13.3'
+          shell: sh
+          run: |
+            sudo pkg install -y zip cmake qt6-base
+            mkdir dist
+            mkdir build
+            cd build
+            cmake ..
+            cmake --build . --config Release
+            UEFITOOL_VER=$(cat ../version.h | grep PROGRAM_VERSION | cut -d'"' -f2 | sed 's/NE alpha /A/') ; \
+            zip -qryj ../dist/UEFIExtract_NE_${UEFITOOL_VER}_x64_freebsd.zip ./UEFIExtract/uefiextract
+            zip -qryj ../dist/UEFIFind_NE_${UEFITOOL_VER}_x64_freebsd.zip ./UEFIFind/uefifind
+            zip -qryj ../dist/UEFITool_NE_${UEFITOOL_VER}_x64_freebsd.zip ./UEFITool/uefitool
+      - name: Upload to artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: FreeBSD builds
+          path: dist/*.zip
+      - name: Upload to releases
+        if: github.event_name == 'release'
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: dist/*.zip
+          tag: ${{ github.ref }}
+          file_glob: true
+
+  build_release_windows_32:
+    name: Release build (Win32, static Qt 5.6.3)
+    runs-on: windows-2019
+    steps:
+      - uses: actions/checkout@v3 
+      - name: Get Qt 5.6.3
+        uses: actions/checkout@v3
+        with:
+          repository: LongSoft/qt-5.6.3-static-x86-msvc2017
+          path: qt5
+          lfs: true
+      - name: Unpack Qt 5.6.3
+        shell: bash
+        working-directory: qt5
+        run: 7z x qt-5.6.3-static-x86-msvc2017.7z -o../..
+      - name: Create dist directory
+        shell: bash
+        run: mkdir dist
+      - name: Create UEFIExtract build directory
+        run: cmake -E make_directory ${{runner.workspace}}/build/UEFIExtract
+      - name: Configure UEFIExtract
+        shell: bash
+        working-directory: ${{runner.workspace}}/build/UEFIExtract
+        run: cmake -G "Visual Studio 16 2019" -A Win32 -T "v141_xp" -DCMAKE_MSVC_RUNTIME_LIBRARY="MultiThreaded" ../../UEFITool/UEFIExtract/
+      - name: Build UEFIExtract
+        working-directory: ${{runner.workspace}}/build/UEFIExtract
+        shell: bash
+        run: cmake --build . --config Release
+      - name: Archive UEFIExtract
+        working-directory: ${{runner.workspace}}/build/UEFIExtract/Release
+        shell: bash
+        run: |
+          UEFITOOL_VER=$(cat ../../../UEFITool/version.h | grep PROGRAM_VERSION | cut -d'"' -f2 | sed 's/NE alpha /A/') ; \
+          7z a ../../../UEFITool/dist/UEFIExtract_NE_${UEFITOOL_VER}_win32.zip UEFIExtract.exe
+      - name: Create UEFIFind build directory
+        run: cmake -E make_directory ${{runner.workspace}}/build/UEFIFind
+      - name: Configure UEFIFind
+        working-directory: ${{runner.workspace}}/build/UEFIFind
+        shell: bash
+        run: cmake -G "Visual Studio 16 2019" -A Win32 -T "v141_xp" -DCMAKE_MSVC_RUNTIME_LIBRARY="MultiThreaded" ../../UEFITool/UEFIFind/
+      - name: Build UEFIFind
+        working-directory: ${{runner.workspace}}/build/UEFIFind
+        shell: bash
+        run: cmake --build . --config Release
+      - name: Archive UEFIFind
+        working-directory: ${{runner.workspace}}/build/UEFIFind/Release
+        shell: bash
+        run: |
+          UEFITOOL_VER=$(cat ../../../UEFITool/version.h | grep PROGRAM_VERSION | cut -d'"' -f2 | sed 's/NE alpha /A/') ; \
+          7z a ../../../UEFITool/dist/UEFIFind_NE_${UEFITOOL_VER}_win32.zip UEFIFind.exe
+      - name: Create UEFITool build directory
+        run: cmake -E make_directory ${{runner.workspace}}/build/UEFITool
+      - name: Configure UEFITool
+        shell: bash
+        working-directory: ${{runner.workspace}}/build/UEFITool
+        run: ../../qt-5.6.3-static-x86-msvc2017/bin/qmake.exe -tp vc ../../UEFITool/UEFITool/
+      - name: Build UEFITool
+        working-directory: ${{runner.workspace}}/build/UEFITool
+        shell: cmd
+        run: |
+            call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars32.bat"
+            msbuild -t:Rebuild -p:PlatformToolset=v141_xp;Configuration=Release
+      - name: Archive UEFITool
+        working-directory: ${{runner.workspace}}/build/UEFITool/release
+        shell: bash
+        run: |
+          UEFITOOL_VER=$(cat ../../../UEFITool/version.h | grep PROGRAM_VERSION | cut -d'"' -f2 | sed 's/NE alpha /A/') ; \
+          7z a ../../../UEFITool/dist/UEFITool_NE_${UEFITOOL_VER}_win32.zip UEFITool.exe
+      - name: Upload to artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: Windows 32-bit builds
+          path: dist/*.zip
+      - name: Upload to releases
+        if: github.event_name == 'release'
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: dist/*.zip
+          tag: ${{ github.ref }}
+          file_glob: true
+
+  build_release_windows_64:
+    name: Release build (Win64, static Qt 6.5.0)
+    runs-on: windows-2022
+    steps:
+      - uses: actions/checkout@v3 
+      - name: Get Qt 6.5.0
+        uses: actions/checkout@v3
+        with:
+          repository: LongSoft/qt-6-static-x64-msvc2022
+          path: qt6
+          lfs: true
+      - name: Unpack Qt 6.5.0
+        shell: bash
+        working-directory: qt6
+        run: 7z x qt-6.5.0-static-x64-msvc2022.7z -o../..
+      - name: Create build directory
+        run: cmake -E make_directory ${{runner.workspace}}/build
+      - name: Configure everything
+        working-directory: ${{runner.workspace}}/build
+        shell: cmd
+        run: cmake -DCMAKE_PREFIX_PATH="D:\a\UEFITool\qt-6.5.0-static-x64-msvc2022" -DCMAKE_MSVC_RUNTIME_LIBRARY="MultiThreaded" -A x64 ../UEFITool
+      - name: Build everything
+        working-directory: ${{runner.workspace}}/build
+        shell: bash
+        run: cmake --build . --config Release
+      - name: Create dist directory
+        run: cmake -E make_directory ${{runner.workspace}}/UEFITool/dist
+      - name: Archive everything
+        working-directory: ${{runner.workspace}}/build
+        shell: bash
+        run: |
+          UEFITOOL_VER=$(cat ../UEFITool/version.h | grep PROGRAM_VERSION | cut -d'"' -f2 | sed 's/NE alpha /A/') ; \
+          7z a ../UEFITool/dist/UEFIExtract_NE_${UEFITOOL_VER}_win64.zip ./UEFIExtract/Release/UEFIExtract.exe
+          7z a ../UEFITool/dist/UEFIFind_NE_${UEFITOOL_VER}_win64.zip ./UEFIFind/Release/UEFIFind.exe
+          7z a ../UEFITool/dist/UEFITool_NE_${UEFITOOL_VER}_win64.zip ./UEFITool/Release/UEFITool.exe
+      - name: Upload to artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: Windows 64-bit builds
+          path: dist/*.zip
+      - name: Upload to releases
+        if: github.event_name == 'release'
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: dist/*.zip
+          tag: ${{ github.ref }}
+          file_glob: true
+
+# Build Tests
+  build_test_linux_meson:
+    name: Meson build system test (shared Qt 5)
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - name: Get Deps
+        run: | 
+          sudo apt update
+          sudo apt-get install -qq cmake meson zlib1g-dev qtbase5-dev
+      - name: Configure build
+        run: mkdir build-meson && meson ./build-meson
+      - name: Build everything
+        run: ninja -C build-meson
+
+  build_test_windows_mingw:
+    name: MinGW compiler test (shared Qt 6.5.0)
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Qt
+        uses: jurplel/install-qt-action@v3
+        with:
+          version: '6.5.0'
+          host: 'windows'
+          target: 'desktop'
+          arch: 'win64_mingw'
+      - name: Build everything
+        run: |
+          cmake -G "MinGW Makefiles" -B build .
+          cmake --build build --parallel
+
+  build_test_linux_fuzzer:
+    name: Fuzzer build test (Clang, Linux x64)
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - name: Create build directory
+        run: cmake -E make_directory ${{runner.workspace}}/build
+      - name: Configure everything
+        working-directory: ${{runner.workspace}}/build
+        run: CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake ../UEFITool/fuzzing
+      - name: Build everything
+        working-directory: ${{runner.workspace}}/build
+        shell: bash
+        run: cmake --build .
+      - name: Create dist directory
+        run: cmake -E make_directory ${{runner.workspace}}/dist
+      - name: Archive everything
+        working-directory: ${{runner.workspace}}/build
+        shell: bash
+        run: |
+          UEFITOOL_VER=$(cat ../UEFITool/version.h | grep PROGRAM_VERSION | cut -d'"' -f2 | sed 's/NE alpha /A/') ; \
+          zip -qryj ../dist/ffsparser_fuzzer_NE_${UEFITOOL_VER}_x64_linux.zip ./ffsparser_fuzzer
+      - name: Upload to artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: Fuzzer
+          path: ${{runner.workspace}}/dist/*.zip
+
+# Static Analysis
+  build_analyze_linux_coverity:
+    env:
+      PROJECT_TYPE: TOOL
+      JOB_TYPE: COVERITY
+    if: github.repository_owner == 'LongSoft' && github.event_name != 'pull_request'
+    name: Coverity Static Analysis (shared Qt 6.5.0)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Qt
+        uses: jurplel/install-qt-action@v3
+        with:
+          version: '6.5.0'
+          host: 'linux'
+          target: 'desktop'
+      - name: Create build directory
+        run: cmake -E make_directory ${{runner.workspace}}/build
+      - name: Configure everything
+        working-directory: ${{runner.workspace}}/build
+        run: cmake ../UEFITool
+      - name: Run Coverity
+        working-directory: ${{runner.workspace}}/build
+        run: |
+          src=$(/usr/bin/curl -Lfs https://raw.githubusercontent.com/acidanthera/ocbuild/master/coverity/covstrap-linux.sh) && eval "$src" || exit 1
+        env:
+          COVERITY_SCAN_TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
+          COVERITY_SCAN_EMAIL: ${{ secrets.COVERITY_SCAN_EMAIL }}
+          COVERITY_BUILD_COMMAND: cmake --build .
+
+  build_analyze_linux_sonarcloud:
+    if: github.repository_owner == 'LongSoft' && github.event_name != 'pull_request'
+    name: SonarCloud Static Analysis (shared Qt 6.5.0)
+    runs-on: ubuntu-latest
+    env:
+      BUILD_WRAPPER_OUT_DIR: build_wrapper_output_directory # Directory where build-wrapper output will be placed
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
+      - name: Install Qt
+        uses: jurplel/install-qt-action@v3
+        with:
+          version: '6.5.0'
+          host: 'linux'
+          target: 'desktop'
+      - name: Install JDK 17
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'zulu'
+          java-version: 17
+      - name: Install build-wrapper
+        uses: SonarSource/sonarcloud-github-c-cpp@v2
+      - name: Run build-wrapper
+        run: |
+          cmake -B build .
+          build-wrapper-linux-x86-64 --out-dir ${{ env.BUILD_WRAPPER_OUT_DIR }} cmake --build build
+      - name: SonarQube Scan
+        uses: SonarSource/sonarqube-scan-action@v4.2.1
+        env:
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+          SONAR_ROOT_CERT: ${{ secrets.SONAR_ROOT_CERT }}
+        with:
+          # Consult https://docs.sonarsource.com/sonarqube-server/latest/analyzing-source-code/scanners/sonarscanner/ for more information and options
+          args: >
+            --define sonar.cfamily.compile-commands="${{ env.BUILD_WRAPPER_OUT_DIR }}/compile_commands.json" 

.gitignore

@@ -3,6 +3,7 @@
 #################
 moc_*.*
 ui_*.*
+qrc_*.*
 
 #################
 ## Qt Creator
@@ -231,3 +232,23 @@ pip-log.txt
 #############
 *.o
 Makefile
+
+uefitool_plugin_import.cpp
+UEFITool.app/
+UEFITool/XCBuildData
+UEFIDump/UEFIDump
+UEFIExtract/UEFIExtract
+UEFIExtract/guids.csv
+UEFIFind/UEFIFind
+.qmake.stash
+CMakeCache.txt
+CMakeFiles
+cmake_install.cmake
+DerivedData
+*.xcodeproj
+compile_commands.json
+CMakeScripts
+UEFITool/qrc_uefitool.cpp
+XcodeQT5
+XcodeQT6
+*.dSYM

CMakeLists.txt

@@ -0,0 +1,7 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 3.22)
+
+PROJECT(UEFITool_everything)
+
+ADD_SUBDIRECTORY(UEFIExtract)
+ADD_SUBDIRECTORY(UEFIFind)
+ADD_SUBDIRECTORY(UEFITool)

README.md

@@ -3,7 +3,7 @@
 UEFITool is a viewer and editor of firmware images conforming to UEFI Platform Interface (PI) Specifications.
 
 ![UEFITool icon](https://raw.githubusercontent.com/LongSoft/UEFITool/new_engine/UEFITool/icons/uefitool_64x64.png "UEFITool icon")  
-![Coverity badge](https://scan.coverity.com/projects/1812/badge.svg?flat=1 "Coverity badge")
+![CI Status](https://github.com/LongSoft/UEFITool/actions/workflows/main.yml/badge.svg?branch=new_engine) [![Scan Status](https://scan.coverity.com/projects/17209/badge.svg?flat=1)](https://scan.coverity.com/projects/17209) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=LongSoft_UEFITool&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=LongSoft_UEFITool)
 
 
 ## Very Brief Introduction to UEFI
@@ -29,28 +29,37 @@ The missing parts are in development and the version with a new engine will be m
 
 There are some other projects that use UEFITool's engine:
 * UEFIExtract, which uses ffsParser to parse supplied firmware image into a tree structure and dumps the parsed structure recursively on the FS. Jethro Beekman's [tree](https://github.com/jethrogb/uefireverse) utility can be used to work with the extracted tree.
-* UEFIDump, a variation of UEFIExtract that dumps all leaf items into one .dump folder without any hierarchy. This tool is a PoC for non-Qt engine usage.
+* UEFIFind, which uses ffsParser to find image elements containing a specified pattern. It was developed for [UBU](https://winraid.level1techs.com/t/tool-guide-news-uefi-bios-updater-ubu/30357) project.
-* UEFIFind, which uses ffsParser to find image elements containing a specified pattern. It was developed for [UBU](http://www.win-raid.com/t154f16-Tool-Guide-News-quot-UEFI-BIOS-Updater-quot-UBU.html) project.
-* [OZMTool](https://github.com/tuxuser/UEFITool/tree/OZM/OZMTool), which uses UEFITool's engine to perform various "hackintosh"-related firmware modifications.
 
 ## Alternatives
 
 Right now there are some alternatives to UEFITool that you could find useful too:
-* **[PhoenixTool](http://forums.mydigitallife.info/threads/13194-Tool-to-Insert-Replace-SLIC-in-Phoenix-Insyde-Dell-EFI-BIOSes)** by [AndyP](http://forums.mydigitallife.info/members/39295-andyp). Windows-only freeware GUI application written in C#. Used mostly for SLIC-related modifications, but it not limited to this task. Requires Microsoft .NET 3.5 to work properly. Supports unpacking firmware images from various vendor-specific formats like encrypted HP update files and Dell installers.  
+* **[FMMT](https://github.com/tianocore/edk2/tree/master/BaseTools/Source/Python/FMMT)** by TianoCore. Python-based open source toolset for modifying EDK2-based UEFI firmware images. Does not support any IBV customizations, but is _official_, and lives in EDK2 repository.
+* **[Fiano](https://github.com/linuxboot/fiano)** by Google and Facebook. Go-based cross-platform open source toolset for modifying UEFI firmware images.
+* **[PhoenixTool](https://forums.mydigitallife.net/threads/tool-to-insert-replace-slic-in-phoenix-insyde-dell-efi-bioses.13194)** by [AndyP](https://forums.mydigitallife.net/members/andyp.39295). Windows-only freeware GUI application written in C#. Used mostly for SLIC-related modifications, but it not limited to this task. Requires Microsoft .NET 3.5 to work properly. Supports unpacking firmware images from various vendor-specific formats like encrypted HP update files and Dell installers.
 * **[uefi-firmware-parser](https://github.com/theopolis/uefi-firmware-parser)** by [Teddy Reed](https://github.com/theopolis). Cross-platform open source console application written in Python. Very tinker-friendly due to use of Python. Can be used in scripts to automate firmware patching.
 * **[Chipsec](https://github.com/chipsec/chipsec)** by Intel. Cross-platform partially open source console application written in Python and C. Can be used to test Intel-based platforms for various security-related misconfigurations, but also has NVRAM parser and other components aimed to firmware modification.
-* **MMTool** by AMI. Windows-only proprietary application available to AMI clients. Works only with Aptio4- and AptioV-based firmware images, but has some interesting features including OptionROM replacement and microcode update. Must be licensed from AMI.
-* **H2OEZE** by Insyde. Windows-only proprietary application available to Insyde clients. Works only with InsydeH2O-based firmware images. Must be licensed from Insyde.
-* **SCT BIOS Editor** by Phoenix. Windows-only proprietary application available to Phoenix clients. Works only with Phoenix SCT-based firmware images. Must be licensed from Phoenix.
 
 ## Installation
 
-You can either use [pre-built binaries for Windows and OSX](https://github.com/LongSoft/UEFITool/releases) or build a binary yourself.  
+You can either use [pre-built binaries](https://github.com/LongSoft/UEFITool/releases) or build a binary yourself.  
-* To build a binary that uses Qt library (UEFITool, UEFIExtract, UEFIFind) you need a C++ compiler and an instance of Qt4/Qt5 library. Install both of them, get the sources, generate makefiles using qmake (`qmake UEFITool.pro`) and use your system's make command on that generated files (i.e. `nmake release`, `make release` and so on).
+* To build a binary that uses Qt library (UEFITool) you need a C++ compiler and an instance of [Qt5 or Qt6](https://www.qt.io) library. Install both of them, get the sources, generate makefiles using qmake (`qmake ./UEFITool/uefitool.pro`) and use your system's make command on that generated files (i.e. `nmake release`, `make release` and so on). Qt6-based builds can also use CMAKE as an altearnative build system.
-* To build a binary that doesn't use Qt (UEFIDump), you need a C++ compiler and CMAKE utility to generate a makefile for your OS and build environment. Install both of them, get the sources, generate makefiles using cmake (`cmake UEFIDump`) and use your system's make command on that generated files (i.e. `nmake release`, `make release` and so on).
+* To build a binary that doesn't use Qt (UEFIExtract, UEFIFind), you need a C++ compiler and [CMAKE](https://cmake.org) utility to generate a makefile for your OS and build environment. Install both of them, get the sources, generate makefiles using cmake (`cmake UEFIExtract`) and use your system's make command on that generated files (i.e. `nmake release`, `make release` and so on). Non-Qt builds can also use Meson as an alternative build system.
 
 ## Known issues
 
+* Image editing is currently only possible using an outdated and unsupported UEFITool 0.28 (`old_engine` branch) and the tools based on it (`UEFIReplace`, `UEFIPatch`). This is the top priority [issue #67](https://github.com/LongSoft/UEFITool/issues/67), which is being worked on, albeit slowly (due to the amount of coding and testing required to implement it correctly). 
 * Some vendor-specific firmware update files can be opened incorrectly or can't be opened at all. This includes encrypted HP update files, Dell HDR and EXE files, some InsydeFlash FD files and so on. Enabling support for such files will require massive amount of reverse-engineering which is almost pointless because the updated image can be obtained from BIOS chip where it's already decrypted and unpacked.
-* Intel Firmware Interface Table (FIT) editing is not supported right now. FIT contains pointers to various image components that must be loaded before executing the first CPU instruction from the BIOS chip. Those components include CPU microcode updates, binaries and settings used by BIOS Guard and Boot Guard technologies and some other stuff. More information on FIT can be obtained [here](http://downloadmirror.intel.com/18931/eng/Intel%20TXT%20LAB%20Handout.pdf).
+* Intel Firmware Interface Table (FIT) editing is not supported right now. FIT contains pointers to various image components that must be loaded before executing the first CPU instruction from the BIOS chip. Those components include CPU microcode updates, binaries and settings used by BIOS Guard and Boot Guard technologies and some other stuff. More information on FIT can be obtained [here](https://edc.intel.com/content/www/us/en/design/products-and-solutions/software-and-services/firmware-and-bios/firmware-interface-table/firmware-interface-table/).
-* Builder code is still not ready, but I'm working hard on it.
+* Windows builds of `UEFIExtract` and `UEFIFind` might encouter an issue with folder paths being longer than 260 bytes (`MAX_PATH`) on some input files (see [issue #363](https://github.com/LongSoft/UEFITool/issues/363)). This is a [known Windows limitation](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry), that can be fixed by enabling long paths support via Windows Registry and adding a manifest to the executable file that requires such support. `UEFIExtract` has the required manifest additions since version `A67`, and the required registry file is provided by Microsoft on the page linked above, but this workaround is only awailable starting with Windows 10 build 1067.   
+
+## Bug repellents
+
+* [Coverity Scan](https://scan.coverity.com/projects/17209) - static analyzer for C, C++, C#, JavaScript, Ruby, or Python code.
+* [SonarCloud](https://sonarcloud.io/project/overview?id=LongSoft_UEFITool) - cloud-based source code analysis service.
+
+## GUID Database
+
+Every new release includes an update to the database of known UEFI-related GUIDs build with help of [Linux Vendor Firmware Service](https://fwupd.org).
+
+You can download the up-to-date version of that database using [this link](https://fwupd.org/lvfs/shards/export/csv).

UEFIDump/CMakeLists.txt

@@ -1,48 +0,0 @@
-PROJECT(UEFIDump)
-
-SET(PROJECT_SOURCES 
- uefidump_main.cpp 
- uefidump.cpp 
- ../common/types.cpp 
- ../common/descriptor.cpp 
- ../common/ffs.cpp 
- ../common/nvram.cpp 
- ../common/ffsparser.cpp 
- ../common/ffsreport.cpp 
- ../common/peimage.cpp 
- ../common/treeitem.cpp 
- ../common/treemodel.cpp 
- ../common/utility.cpp 
- ../common/LZMA/LzmaDecompress.c 
- ../common/LZMA/SDK/C/LzmaDec.c 
- ../common/Tiano/EfiTianoDecompress.c 
-  ../common/ustring.cpp 
- ../bstrlib/bstrlib.c 
- ../bstrlib/bstrwrap.cpp
-)
-
-SET(PROJECT_HEADERS 
- uefidump.h 
- ../common/basetypes.h 
- ../common/descriptor.h 
- ../common/gbe.h 
- ../common/me.h 
- ../common/ffs.h
- ../common/fit.h  
- ../common/nvram.h 
- ../common/ffsparser.h 
- ../common/ffsreport.h 
- ../common/peimage.h 
- ../common/types.h 
- ../common/treeitem.h 
- ../common/treemodel.h 
- ../common/utility.h 
- ../common/LZMA/LzmaDecompress.h 
- ../common/Tiano/EfiTianoDecompress.h 
- ../common/ubytearray.h 
- ../common/ustring.h 
- ../bstrlib/bstrlib.h 
- ../bstrlib/bstrwrap.h
-)
-
-ADD_EXECUTABLE(UEFIDump ${PROJECT_SOURCES} ${PROJECT_HEADERS})

UEFIDump/uefidump.cpp

@@ -1,204 +0,0 @@
-/* ffsdumper.cpp
-
-Copyright (c) 2015, Nikolaj Schlej. All rights reserved.
-This program and the accompanying materials
-are licensed and made available under the terms and conditions of the BSD License
-which accompanies this distribution.  The full text of the license may be found at
-http://opensource.org/licenses/bsd-license.php
-
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-*/
-
-#include "uefidump.h"
-#include "../common/ffs.h"
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <iomanip>
-#include <sys/stat.h>
-
-#ifdef WIN32
-#include <direct.h>
-bool isExistOnFs(const UString & path) {
-    struct _stat buf;
-    return (_stat((const char*)path.toLocal8Bit(), &buf) == 0);
-}
-
-bool makeDirectory(const UString & dir) {
-    return (_mkdir((const char*)dir.toLocal8Bit()) == 0);
-}
-
-bool changeDirectory(const UString & dir) {
-    return (_chdir((const char*)dir.toLocal8Bit()) == 0);
-}
-#else
-#include <unistd.h>
-bool isExistOnFs(const UString & path) {
-    struct stat buf;
-    return (stat((const char*)path.toLocal8Bit(), &buf) == 0);
-}
-
-bool makeDirectory(const UString & dir) {
-    return (mkdir((const char*)dir.toLocal8Bit(), ACCESSPERMS) == 0);
-}
-
-bool changeDirectory(const UString & dir) {
-    return (chdir((const char*)dir.toLocal8Bit()) == 0);
-}
-#endif
-
-USTATUS UEFIDumper::dump(const UByteArray & buffer, const UString & inPath, const UString & guid)
-{
-    UString path = UString(inPath) + UString(".dump");
-    UString reportPath = UString(inPath) + UString(".report.txt");
-
-    if (initialized) {
-        // Check if called with a different buffer as before
-        if (buffer != currentBuffer) {
-            // Reinitalize if so
-            initialized = false;
-        }
-    }
-
-    if (!initialized) {
-        // Fill currentBuffer
-        currentBuffer = buffer;
-
-        // Parse FFS structure
-        USTATUS result = ffsParser.parse(buffer);
-        if (result)
-            return result;
-        // Show ffsParser messages
-        std::vector<std::pair<UString, UModelIndex> > messages = ffsParser.getMessages();
-        for (size_t i = 0; i < messages.size(); i++) {
-            std::cout << messages[i].first << std::endl;
-        }
-
-        // Show FIT table
-        std::vector<std::vector<UString> > fitTable = ffsParser.getFitTable();
-        if (fitTable.size()) {
-            std::cout << "-------------------------------------------------------------------" << std::endl;
-            std::cout << "     Address     |   Size    |  Ver  | CS  |         Type          " << std::endl;
-            std::cout << "-------------------------------------------------------------------" << std::endl;
-            for (size_t i = 0; i < fitTable.size(); i++) {
-                std::cout << (const char*)fitTable[i][0].toLocal8Bit() << " | "
-                    << (const char*)fitTable[i][1].toLocal8Bit() << " | "
-                    << (const char*)fitTable[i][2].toLocal8Bit() << " | "
-                    << (const char*)fitTable[i][3].toLocal8Bit() << " | "
-                    << (const char*)fitTable[i][4].toLocal8Bit() << std::endl;
-            }
-        }
-
-        // Create ffsReport
-        FfsReport ffsReport(&model);
-        std::vector<UString> report = ffsReport.generate();
-        if (report.size()) {
-            std::ofstream ofs;
-            ofs.open((const char*)reportPath, std::ofstream::out);
-            for (size_t i = 0; i < report.size(); i++) {
-                ofs << (const char*)report[i].toLocal8Bit() << std::endl;
-            }
-            ofs.close();
-        }
-        
-        initialized = true;
-    }
-    
-    // Check for dump directory existence
-    if (isExistOnFs(path))
-        return U_DIR_ALREADY_EXIST;
-
-    // Create dump directory and cd to it
-    if (!makeDirectory(path))
-        return U_DIR_CREATE;
-
-    if (!changeDirectory(path))
-        return U_DIR_CHANGE;
-    
-    dumped = false;
-    UINT8 result = recursiveDump(model.index(0,0));
-    if (result)
-        return result;
-    else if (!dumped)
-        return U_ITEM_NOT_FOUND;
-
-    return U_SUCCESS;
-}
-
-USTATUS UEFIDumper::recursiveDump(const UModelIndex & index)
-{
-    if (!index.isValid())
-        return U_INVALID_PARAMETER;
-
-    //UByteArray itemHeader = model.header(index);
-    //UByteArray fileHeader = model.header(model.findParentOfType(index, Types::File));
-
-    //if (guid.length() == 0 ||
-    //    (itemHeader.size() >= sizeof (EFI_GUID) && guidToUString(*(const EFI_GUID*)itemHeader.constData()) == guid) ||
-    //    (fileHeader.size() >= sizeof(EFI_GUID) && guidToUString(*(const EFI_GUID*)fileHeader.constData()) == guid)) {
-
-        // Construct file name
-        UString orgName = uniqueItemName(index);
-        UString name = orgName;
-        bool nameFound = false;
-        for (int i = 1; i < 1000; ++i) {
-            if (!isExistOnFs(name + UString("_info.txt"))) {
-                nameFound = true;
-                break;
-            }
-            name = orgName + UString("_") + usprintf("%03d", i);
-        }
-
-        if (!nameFound)
-            return U_INVALID_PARAMETER; //TODO: replace with proper errorCode
-
-        // Add header and body only for leaf sections
-        if (model.rowCount(index) == 0) {
-            // Header
-            UByteArray data = model.header(index);
-            if (!data.isEmpty()) {
-                std::ofstream file;
-                UString str = name + UString("_header.bin");
-                file.open((const char*)str, std::ios::out | std::ios::binary);
-                file.write(data.constData(), data.size());
-                file.close();
-            }
-
-            // Body
-            data = model.body(index);
-            if (!data.isEmpty()) {
-                std::ofstream file;
-                UString str = name + UString("_body.bin");
-                file.open((const char*)str, std::ios::out | std::ios::binary);
-                file.write(data.constData(), data.size());
-                file.close();
-            }
-        }
-        // Info
-        UString info = "Type: " + itemTypeToUString(model.type(index)) + "\n" +
-            "Subtype: " + itemSubtypeToUString(model.type(index), model.subtype(index)) + "\n";
-        if (model.text(index).length() > 0)
-            info += "Text: " + model.text(index) + "\n";
-        info += model.info(index) + "\n";
-
-        std::ofstream file;
-        UString str = name + UString("_info.txt");
-        file.open((const char*)str, std::ios::out);
-        file.write((const char*)info, info.length());
-        file.close();
-
-        dumped = true;
-    //}
-    
-    // Process child items
-    UINT8 result;
-    for (int i = 0; i < model.rowCount(index); i++) {
-        result = recursiveDump(index.child(i, 0));
-        if (result)
-            return result;
-    }
-
-    return U_SUCCESS;
-}

UEFIDump/uefidump_main.cpp

@@ -1,35 +0,0 @@
-/* uefidump_main.cpp
-
-Copyright (c) 2016, Nikolaj Schlej. All rights reserved.
-This program and the accompanying materials
-are licensed and made available under the terms and conditions of the BSD License
-which accompanies this distribution.  The full text of the license may be found at
-http://opensource.org/licenses/bsd-license.php
-
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-*/
-#include <iostream>
-#include <fstream>
-
-#include "uefidump.h"
-
-int main(int argc, char *argv[])
-{
-    
-    if (argc > 1) { 
-        std::ifstream inputFile;
-        inputFile.open(argv[1], std::ios::in | std::ios::binary);
-        std::vector<char> buffer(std::istreambuf_iterator<char>(inputFile),
-            (std::istreambuf_iterator<char>()));
-        inputFile.close();
-        
-        UEFIDumper uefidumper;
-        return (uefidumper.dump(buffer, UString(argv[1])) != U_SUCCESS);
-    }
-
-    std::cout << "UEFIDump 0.1.1" << std::endl << std::endl
-              << "Usage: UEFIDump imagefile" << std::endl;
-    return 0;
-}

UEFIExtract/CMakeLists.txt

@@ -0,0 +1,92 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 3.22)
+
+PROJECT(UEFIExtract)
+
+SET(CMAKE_CXX_STANDARD 11)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+SET(CMAKE_CXX_EXTENSIONS OFF)
+
+SET(PROJECT_SOURCES
+ uefiextract_main.cpp
+ ffsdumper.cpp
+ uefidump.cpp
+ ../common/guiddatabase.cpp
+ ../common/types.cpp
+ ../common/filesystem.cpp
+ ../common/descriptor.cpp
+ ../common/ffs.cpp
+ ../common/nvram.cpp
+ ../common/nvramparser.cpp
+ ../common/meparser.cpp
+ ../common/ffsparser.cpp
+ ../common/fitparser.cpp
+ ../common/ffsreport.cpp
+ ../common/peimage.cpp
+ ../common/treeitem.cpp
+ ../common/treemodel.cpp
+ ../common/utility.cpp
+ ../common/LZMA/LzmaDecompress.c
+ ../common/LZMA/SDK/C/Bra.c
+ ../common/LZMA/SDK/C/Bra86.c
+ ../common/LZMA/SDK/C/CpuArch.c
+ ../common/LZMA/SDK/C/LzmaDec.c
+ ../common/Tiano/EfiTianoDecompress.c
+ ../common/ustring.cpp
+ ../common/bstrlib/bstrlib.c
+ ../common/bstrlib/bstrwrap.cpp
+ ../common/generated/ami_nvar.cpp
+ ../common/generated/apple_sysf.cpp
+ ../common/generated/dell_dvar.cpp
+ ../common/generated/edk2_vss.cpp
+ ../common/generated/edk2_vss2.cpp
+ ../common/generated/edk2_ftw.cpp
+ ../common/generated/insyde_fdc.cpp
+ ../common/generated/insyde_fdm.cpp
+ ../common/generated/ms_slic_marker.cpp
+ ../common/generated/ms_slic_pubkey.cpp
+ ../common/generated/phoenix_flm.cpp
+ ../common/generated/phoenix_evsa.cpp
+ ../common/generated/intel_acbp_v1.cpp
+ ../common/generated/intel_acbp_v2.cpp
+ ../common/generated/intel_keym_v1.cpp
+ ../common/generated/intel_keym_v2.cpp
+ ../common/generated/intel_acm.cpp
+ ../common/kaitai/kaitaistream.cpp
+ ../common/digest/sha1.c
+ ../common/digest/sha256.c
+ ../common/digest/sha512.c
+ ../common/digest/sm3.c
+ ../common/zlib/adler32.c
+ ../common/zlib/compress.c
+ ../common/zlib/crc32.c
+ ../common/zlib/deflate.c
+ ../common/zlib/gzclose.c
+ ../common/zlib/gzlib.c
+ ../common/zlib/gzread.c
+ ../common/zlib/gzwrite.c
+ ../common/zlib/inflate.c
+ ../common/zlib/infback.c
+ ../common/zlib/inftrees.c
+ ../common/zlib/inffast.c
+ ../common/zlib/trees.c
+ ../common/zlib/uncompr.c
+ ../common/zlib/zutil.c
+)
+
+ADD_DEFINITIONS(
+ -DU_ENABLE_NVRAM_PARSING_SUPPORT
+ -DU_ENABLE_ME_PARSING_SUPPORT
+ -DU_ENABLE_FIT_PARSING_SUPPORT
+ -DU_ENABLE_GUID_DATABASE_SUPPORT
+)
+
+ADD_EXECUTABLE(UEFIExtract ${PROJECT_SOURCES} uefiextract.manifest)
+
+IF(UNIX)
+ SET_TARGET_PROPERTIES(UEFIExtract PROPERTIES OUTPUT_NAME uefiextract)
+ENDIF()
+
+INSTALL(
+ TARGETS UEFIExtract
+ RUNTIME DESTINATION bin
+)

UEFIExtract/ffsdumper.cpp

@@ -13,81 +13,219 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 
 #include "ffsdumper.h"
 
-USTATUS FfsDumper::dump(const QModelIndex & root, const QString & path, const bool dumpAll, const QString & guid)
+#include <fstream>
+
+USTATUS FfsDumper::dump(const UModelIndex & root, const UString & path, const DumpMode dumpMode, const UINT8 sectionType, const UString & guid)
 {
     dumped = false;
-    UINT8 result = recursiveDump(root, path, dumpAll, guid);
+    counterHeader = counterBody = counterRaw = counterInfo = 0;
-    if (result)
+    fileList.clear();
+
+    if (changeDirectory(path)) {
+        printf("Directory \"%s\" already exists.\n", (const char*)path.toLocal8Bit());
+        return U_DIR_ALREADY_EXIST;
+    }
+
+    currentPath = path;
+
+    USTATUS result = recursiveDump(root, path, dumpMode, sectionType, guid);
+    if (result) {
+        printf("Error %zu returned from recursiveDump (directory \"%s\").\n", result, (const char*)path.toLocal8Bit());
         return result;
-    else if (!dumped)
+    } else if (!dumped) {
+        if (removeDirectory(path)) {
+            printf("Removed directory \"%s\" since nothing was dumped.\n", (const char*)path.toLocal8Bit());
+        }
         return U_ITEM_NOT_FOUND;
+    }
+
     return U_SUCCESS;
 }
 
-USTATUS FfsDumper::recursiveDump(const QModelIndex & index, const QString & path, const bool dumpAll, const QString & guid)
+USTATUS FfsDumper::recursiveDump(const UModelIndex & index, const UString & path, const DumpMode dumpMode, const UINT8 sectionType, const UString & guid)
 {
     if (!index.isValid())
         return U_INVALID_PARAMETER;
 
-    QDir dir;
     if (guid.isEmpty() ||
-        guidToUString(*(const EFI_GUID*)model->header(index).constData()) == guid ||
+        (model->subtype(index) == EFI_SECTION_FREEFORM_SUBTYPE_GUID &&
-        guidToUString(*(const EFI_GUID*)model->header(model->findParentOfType(index, Types::File)).constData()) == guid) {
+            guidToUString(readUnaligned((const EFI_GUID*)(model->header(index).constData() + sizeof(EFI_COMMON_SECTION_HEADER)))) == guid) ||
+        guidToUString(readUnaligned((const EFI_GUID*)model->header(index).constData())) == guid ||
+        guidToUString(readUnaligned((const EFI_GUID*)model->header(model->findParentOfType(index, Types::File)).constData())) == guid) {
 
-        if (dir.cd(path))
+        if (!changeDirectory(path) && !makeDirectory(path)) {
-            return U_DIR_ALREADY_EXIST;
+            printf("Cannot use directory \"%s\" (recursiveDump part 1).\n", (const char*)path.toLocal8Bit());
-
-        if (!dir.mkpath(path))
             return U_DIR_CREATE;
-
-        QFile file;
-        if (dumpAll || model->rowCount(index) == 0)  { // Dump if leaf item or dumpAll is true
-            if (!model->header(index).isEmpty()) {
-                file.setFileName(QObject::tr("%1/header.bin").arg(path));
-                if (!file.open(QFile::WriteOnly))
-                    return U_FILE_OPEN;
-
-                file.write(model->header(index));
-                file.close();
         }
 
-            if (!model->body(index).isEmpty()) {
+        if (currentPath != path) {
-                file.setFileName(QObject::tr("%1/body.bin").arg(path));
+            counterHeader = counterBody = counterUncData = counterRaw = counterInfo = 0;
-                if (!file.open(QFile::WriteOnly))
+            currentPath = path;
-                    return U_FILE_OPEN;
-
-                file.write(model->body(index));
-                file.close();
-            }
         }
 
-        // Always dump info
+        if (fileList.count(index) == 0
-        QString info = QObject::tr("Type: %1\nSubtype: %2\n%3%4\n")
+            && (dumpMode == DUMP_ALL || model->rowCount(index) == 0)
-            .arg(itemTypeToUString(model->type(index)))
+            && (sectionType == IgnoreSectionType || model->subtype(index) == sectionType)) {
-            .arg(itemSubtypeToUString(model->type(index), model->subtype(index)))
+
-            .arg(model->text(index).isEmpty() ? QObject::tr("") : QObject::tr("Text: %1\n").arg(model->text(index)))
+            if ((dumpMode == DUMP_ALL || dumpMode == DUMP_CURRENT || dumpMode == DUMP_HEADER)
-            .arg(model->info(index));
+                && !model->hasEmptyHeader(index)) {
-        file.setFileName(QObject::tr("%1/info.txt").arg(path));
+                fileList.insert(index);
-        if (!file.open(QFile::Text | QFile::WriteOnly))
+
-            return U_FILE_OPEN;
+                UString filename;
+                if (counterHeader == 0)
+                    filename = usprintf("%s/header.bin", path.toLocal8Bit());
+                else
+                    filename = usprintf("%s/header_%d.bin", path.toLocal8Bit(), counterHeader);
+                counterHeader++;
+
+                std::ofstream file(filename.toLocal8Bit(), std::ofstream::binary);
+                if (!file) {
+                    printf("Cannot open header \"%s\".\n", (const char*)filename.toLocal8Bit());
+                    return U_FILE_OPEN;
+                }
+
+                const UByteArray &data = model->header(index);
+                file.write(data.constData(), data.size());
 
-        file.write(info.toLatin1());
-        file.close();
                 dumped = true;
             }
 
-    UINT8 result;
+            if ((dumpMode == DUMP_ALL || dumpMode == DUMP_CURRENT || dumpMode == DUMP_BODY)
+                && !model->hasEmptyBody(index)) {
+                fileList.insert(index);
+                UString filename;
+                if (counterBody == 0)
+                    filename = usprintf("%s/body.bin", path.toLocal8Bit());
+                else
+                    filename = usprintf("%s/body_%d.bin", path.toLocal8Bit(), counterBody);
+                counterBody++;
+
+                std::ofstream file(filename.toLocal8Bit(), std::ofstream::binary);
+                if (!file) {
+                    printf("Cannot open body \"%s\".\n", (const char*)filename.toLocal8Bit());
+                    return U_FILE_OPEN;
+                }
+
+                const UByteArray &data = model->body(index);
+                file.write(data.constData(), data.size());
+
+                dumped = true;
+            }
+
+            if ((dumpMode == DUMP_ALL || dumpMode == DUMP_CURRENT || dumpMode == DUMP_UNC_DATA)
+                && !model->hasEmptyUncompressedData(index)) {
+                fileList.insert(index);
+                UString filename;
+                if (counterUncData == 0)
+                    filename = usprintf("%s/unc_data.bin", path.toLocal8Bit());
+                else
+                    filename = usprintf("%s/unc_data_%d.bin", path.toLocal8Bit(), counterUncData);
+                counterUncData++;
+
+                std::ofstream file(filename.toLocal8Bit(), std::ofstream::binary);
+                if (!file) {
+                    printf("Cannot open uncompressed data \"%s\".\n", (const char*)filename.toLocal8Bit());
+                    return U_FILE_OPEN;
+                }
+
+                const UByteArray &data = model->uncompressedData(index);
+                file.write(data.constData(), data.size());
+
+                dumped = true;
+            }
+            
+            if (dumpMode == DUMP_FILE) {
+                UModelIndex fileIndex = index;
+                if (model->type(fileIndex) != Types::File) {
+                    fileIndex = model->findParentOfType(index, Types::File);
+                    if (!fileIndex.isValid())
+                        fileIndex = index;
+                }
+
+                // We may select parent file during ffs extraction.
+                if (fileList.count(fileIndex) == 0) {
+                    fileList.insert(fileIndex);
+
+                    UString filename;
+                    if (counterRaw == 0)
+                        filename = usprintf("%s/file.ffs", path.toLocal8Bit());
+                    else
+                        filename = usprintf("%s/file_%d.ffs", path.toLocal8Bit(), counterRaw);
+                    counterRaw++;
+
+                    std::ofstream file(filename.toLocal8Bit(), std::ofstream::binary);
+                    if (!file) {
+                        printf("Cannot open file \"%s\".\n", (const char*)filename.toLocal8Bit());
+                        return U_FILE_OPEN;
+                    }
+
+                    const UByteArray &headerData = model->header(fileIndex);
+                    const UByteArray &bodyData = model->body(fileIndex);
+                    const UByteArray &tailData = model->tail(fileIndex);
+
+                    file.write(headerData.constData(), headerData.size());
+                    file.write(bodyData.constData(), bodyData.size());
+                    file.write(tailData.constData(), tailData.size());
+
+                    dumped = true;
+                }
+            }
+        }
+
+        // Always dump info unless explicitly prohibited
+        if ((dumpMode == DUMP_ALL || dumpMode == DUMP_CURRENT || dumpMode == DUMP_INFO)
+            && (sectionType == IgnoreSectionType || model->subtype(index) == sectionType)) {
+            UString info = usprintf("Type: %s\nSubtype: %s\n%s%s\n",
+                itemTypeToUString(model->type(index)).toLocal8Bit(),
+                itemSubtypeToUString(model->type(index), model->subtype(index)).toLocal8Bit(),
+                (model->text(index).isEmpty() ? UString("") :
+                    usprintf("Text: %s\n", model->text(index).toLocal8Bit())).toLocal8Bit(),
+                model->info(index).toLocal8Bit());
+
+            UString filename;
+            if (counterInfo == 0)
+                filename = usprintf("%s/info.txt", path.toLocal8Bit());
+            else
+                filename = usprintf("%s/info_%d.txt", path.toLocal8Bit(), counterInfo);
+            counterInfo++;
+
+            std::ofstream file(filename.toLocal8Bit());
+            if (!file) {
+                printf("Cannot open info \"%s\".\n", (const char*)filename.toLocal8Bit());
+                return U_FILE_OPEN;
+            }
+
+            file << info.toLocal8Bit();
+
+            dumped = true;
+        }
+    }
+
+    USTATUS result;
+
     for (int i = 0; i < model->rowCount(index); i++) {
-        QModelIndex childIndex = index.child(i, 0);
+        UModelIndex childIndex = index.child(i, 0);
         bool useText = FALSE;
         if (model->type(childIndex) != Types::Volume)
             useText = !model->text(childIndex).isEmpty();
 
-        QString childPath = QString("%1/%2 %3").arg(path).arg(i).arg(useText ? model->text(childIndex) : model->name(childIndex));
+        UString childPath = path;
-        result = recursiveDump(childIndex, childPath, dumpAll, guid);
+        if (dumpMode == DUMP_ALL || dumpMode == DUMP_CURRENT) {
-        if (result)
+            if (!changeDirectory(path) && !makeDirectory(path)) {
+                printf("Cannot use directory \"%s\" (recursiveDump part 2).\n", (const char*)path.toLocal8Bit());
+                return U_DIR_CREATE;
+            }
+
+            UString name = usprintf("%d %s", i, (useText ? model->text(childIndex) : model->name(childIndex)).toLocal8Bit());
+            fixFileName (name, false);
+            childPath = usprintf("%s/%s", path.toLocal8Bit(), name.toLocal8Bit());
+        }
+        result = recursiveDump(childIndex, childPath, dumpMode, sectionType, guid);
+        if (result) {
+            printf("Error %zu returned from recursiveDump (child directory \"%s\").\n", result, (const char*)childPath.toLocal8Bit());
             return result;
         }
+    }
 
     return U_SUCCESS;
 }

UEFIExtract/ffsdumper.h

@@ -14,27 +14,42 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #ifndef FFSDUMPER_H
 #define FFSDUMPER_H
 
-#include <QObject>
+#include <set>
-#include <QDir>
-#include <QByteArray>
-#include <QString>
-#include <QModelIndex>
 
 #include "../common/basetypes.h"
+#include "../common/ustring.h"
 #include "../common/treemodel.h"
 #include "../common/ffs.h"
+#include "../common/filesystem.h"
+#include "../common/utility.h"
 
 class FfsDumper
 {
 public:
-    explicit FfsDumper(TreeModel * treeModel) : model(treeModel), dumped(false) {}
+    enum DumpMode {
+        DUMP_CURRENT,
+        DUMP_ALL,
+        DUMP_BODY,
+        DUMP_UNC_DATA,
+        DUMP_HEADER,
+        DUMP_INFO,
+        DUMP_FILE
+    };
+
+    static const UINT8 IgnoreSectionType = 0xFF;
+
+    explicit FfsDumper(TreeModel * treeModel) : model(treeModel), dumped(false), 
+        counterHeader(0), counterBody(0), counterUncData(0), counterRaw(0), counterInfo(0) {}
     ~FfsDumper() {};
 
-    USTATUS dump(const QModelIndex & root, const QString & path, const bool dumpAll = false, const QString & guid = QString());
+    USTATUS dump(const UModelIndex & root, const UString & path, const DumpMode dumpMode = DUMP_CURRENT, const UINT8 sectionType = IgnoreSectionType, const UString & guid = UString());
 
 private:
-    USTATUS recursiveDump(const QModelIndex & root, const QString & path, const bool dumpAll, const QString & guid);
+    USTATUS recursiveDump(const UModelIndex & root, const UString & path, const DumpMode dumpMode, const UINT8 sectionType, const UString & guid);
     TreeModel* model;
+    UString currentPath;
     bool dumped;
+    int counterHeader, counterBody, counterUncData, counterRaw, counterInfo;
+    std::set<UModelIndex> fileList;
 };
 #endif // FFSDUMPER_H

UEFIExtract/meson.build

@@ -0,0 +1,17 @@
+executable(
+  'UEFIExtract',
+  sources: [
+    'uefiextract_main.cpp',
+    'ffsdumper.cpp',
+    'uefidump.cpp',
+  ],
+  link_with: [
+    lzma,
+    bstrlib,
+    uefitoolcommon,
+  ],
+  dependencies: [
+    zlib,
+  ],
+  install: true,
+)

UEFIExtract/uefidump.cpp

@@ -0,0 +1,151 @@
+/* ffsdumper.cpp
+
+Copyright (c) 2018, LongSoft. All rights reserved.
+This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+*/
+
+#include "uefidump.h"
+#include "../common/ffs.h"
+#include "../common/utility.h"
+#include "../common/filesystem.h"
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <iomanip>
+
+USTATUS UEFIDumper::dump(const UByteArray & buffer, const UString & inPath, const UString & guid)
+{
+    UString path = UString(inPath) + UString(".dump");
+    UString reportPath = UString(inPath) + UString(".report.txt");
+
+    if (initialized) {
+        // Check if called with a different buffer as before
+        if (buffer != currentBuffer) {
+            // Reinitalize if so
+            initialized = false;
+        }
+    }
+
+    if (!initialized) {
+        // Fill currentBuffer
+        currentBuffer = buffer;
+
+        // Parse FFS structure
+        USTATUS result = ffsParser.parse(buffer);
+        if (result)
+            return result;
+
+        ffsParser.outputInfo();
+
+        // Create ffsReport
+        FfsReport ffsReport(&model);
+        std::vector<UString> report = ffsReport.generate();
+        if (report.size()) {
+            std::ofstream ofs;
+            ofs.open(reportPath, std::ofstream::out);
+            for (size_t i = 0; i < report.size(); i++) {
+                ofs << report[i].toLocal8Bit() << std::endl;
+            }
+            ofs.close();
+        }
+        
+        initialized = true;
+    }
+    
+    // Check for dump directory existence
+    if (isExistOnFs(path))
+        return U_DIR_ALREADY_EXIST;
+
+    // Create dump directory and cd to it
+    if (!makeDirectory(path))
+        return U_DIR_CREATE;
+
+    if (!changeDirectory(path))
+        return U_DIR_CHANGE;
+    
+    dumped = false;
+    USTATUS result = recursiveDump(model.index(0,0));
+    if (result)
+        return result;
+    else if (!dumped)
+        return U_ITEM_NOT_FOUND;
+
+    return U_SUCCESS;
+}
+
+USTATUS UEFIDumper::recursiveDump(const UModelIndex & index)
+{
+    if (!index.isValid())
+        return U_INVALID_PARAMETER;
+
+    // Construct file name
+    UString orgName = uniqueItemName(index);
+    UString name = orgName;
+    bool nameFound = false;
+    for (int i = 1; i < 1000; ++i) {
+        if (!isExistOnFs(name + UString("_info.txt"))) {
+            nameFound = true;
+            break;
+        }
+        name = orgName + UString("_") + usprintf("%03d", i);
+    }
+    
+    if (!nameFound) {
+        printf("Cannot find unique name for \"%s\".\n", (const char*)orgName.toLocal8Bit());
+        return U_INVALID_PARAMETER; //TODO: replace with proper errorCode
+    }
+    
+    // Add header and body only for leaf sections
+    if (model.rowCount(index) == 0) {
+        // Header
+        UByteArray data = model.header(index);
+        if (!data.isEmpty()) {
+            std::ofstream file;
+            UString str = name + UString("_header.bin");
+            file.open(str.toLocal8Bit(), std::ios::out | std::ios::binary);
+            file.write(data.constData(), data.size());
+            file.close();
+        }
+        
+        // Body
+        data = model.body(index);
+        if (!data.isEmpty()) {
+            std::ofstream file;
+            UString str = name + UString("_body.bin");
+            file.open(str.toLocal8Bit(), std::ios::out | std::ios::binary);
+            file.write(data.constData(), data.size());
+            file.close();
+        }
+    }
+    // Info
+    UString info = "Type: " + itemTypeToUString(model.type(index)) + "\n" +
+    "Subtype: " + itemSubtypeToUString(model.type(index), model.subtype(index)) + "\n";
+    if (model.text(index).length() > 0)
+        info += "Text: " + model.text(index) + "\n";
+    info += model.info(index) + "\n";
+    
+    std::ofstream file;
+    UString str = name + UString("_info.txt");
+    file.open(str.toLocal8Bit(), std::ios::out);
+    file.write(info.toLocal8Bit(), info.length());
+    file.close();
+    
+    dumped = true;
+    
+    // Process child items
+    USTATUS result;
+    for (int i = 0; i < model.rowCount(index); i++) {
+        result = recursiveDump(index.child(i, 0));
+        if (result)
+            return result;
+    }
+
+    return U_SUCCESS;
+}

UEFIExtract/uefidump.h

@@ -1,6 +1,6 @@
 /* uefidump.h
 
-Copyright (c) 2016, Nikolaj Schlej. All rights reserved.
+Copyright (c) 2018, LongSoft. All rights reserved.
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 which accompanies this distribution.  The full text of the license may be found at

UEFIExtract/uefiextract.manifest

@@ -0,0 +1,8 @@
+<assembly xmlns:asmv1="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+    <asmv1:assemblyIdentity type='win32' name='me.coderush.UEFIExtract' version='1.0.0.0' />
+    <asmv3:application>
+        <asmv3:windowsSettings xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
+            <ws2:longPathAware>true</ws2:longPathAware>
+        </asmv3:windowsSettings>
+    </asmv3:application>
+</assembly>

UEFIExtract/uefiextract.pro

@@ -1,46 +0,0 @@
-QT      += core
-QT      -= gui
-
-TARGET   = UEFIExtract
-TEMPLATE = app
-CONFIG  += console
-CONFIG  -= app_bundle
-
-SOURCES += \
- uefiextract_main.cpp \
- ffsdumper.cpp \
- ../common/types.cpp \
- ../common/descriptor.cpp \
- ../common/ffs.cpp \
- ../common/nvram.cpp \
- ../common/ffsparser.cpp \
- ../common/ffsreport.cpp \
- ../common/peimage.cpp \
- ../common/treeitem.cpp \
- ../common/treemodel.cpp \
- ../common/utility.cpp \
- ../common/LZMA/LzmaDecompress.c \
- ../common/LZMA/SDK/C/LzmaDec.c \
- ../common/Tiano/EfiTianoDecompress.c \
- ../common/ustring.cpp
-
-HEADERS += \
- ffsdumper.h \
- ../common/basetypes.h \
- ../common/descriptor.h \
- ../common/gbe.h \
- ../common/me.h \
- ../common/ffs.h \
- ../common/nvram.h \
- ../common/ffsparser.h \
- ../common/ffsreport.h \
- ../common/peimage.h \
- ../common/types.h \
- ../common/treeitem.h \
- ../common/treemodel.h \
- ../common/utility.h \
- ../common/LZMA/LzmaDecompress.h \
- ../common/Tiano/EfiTianoDecompress.h \
- ../common/ubytearray.h \
- ../common/ustring.h
- 

UEFIExtract/uefiextract_main.cpp

@@ -1,5 +1,5 @@
 /* uefiextract_main.cpp
-Copyright (c) 2016, Nikolaj Schlej. All rights reserved.
+Copyright (c) 2018, LongSoft. All rights reserved.
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 which accompanies this distribution.  The full text of the license may be found at
@@ -7,125 +7,213 @@ http://opensource.org/licenses/bsd-license.php
 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 */
-#include <QCoreApplication>
-#include <QString>
-#include <QFileInfo>
 
 #include <iostream>
+#include <fstream>
+#include <cstring>
+#include <cstdlib>
 
+#include "../version.h"
+#include "../common/basetypes.h"
+#include "../common/ustring.h"
+#include "../common/filesystem.h"
 #include "../common/ffsparser.h"
 #include "../common/ffsreport.h"
+#include "../common/guiddatabase.h"
 #include "ffsdumper.h"
+#include "uefidump.h"
+
+enum ReadType {
+    READ_INPUT,
+    READ_OUTPUT,
+    READ_MODE,
+    READ_SECTION
+};
+
+void print_usage()
+{
+    std::cout << "UEFIExtract " PROGRAM_VERSION << std::endl
+        << "Usage: UEFIExtract {-h | --help | -v | --version} - show help and/or version information." << std::endl
+        << "       UEFIExtract imagefile        - generate report and GUID database, then dump only leaf tree items into .dump folder." << std::endl
+        << "       UEFIExtract imagefile all    - generate report and GUID database, then dump all tree items into .dump folder." << std::endl
+        << "       UEFIExtract imagefile unpack - generate report, then dump all tree items into a single .dump folder (legacy UEFIDump compatibility mode)." << std::endl
+        << "       UEFIExtract imagefile dump   - only generate dump, no report or GUID database needed." << std::endl
+        << "       UEFIExtract imagefile report - only generate report, no dump or GUID database needed." << std::endl
+        << "       UEFIExtract imagefile guids  - only generate GUID database, no dump or report needed." << std::endl
+        << "       UEFIExtract imagefile GUID_1 ... [ -o FILE_1 ... ] [ -m MODE_1 ... ] [ -t TYPE_1 ... ] -" << std::endl
+        << "         Dump only FFS file(s) with specific GUID(s), without report or GUID database." << std::endl
+        << "         Type is section type or FF to ignore. Mode is one of: all, body, unc_data, header, info, file." << std::endl
+        << "         Return value is a bit mask where 0 at position N means that file with GUID_N was found and unpacked, 1 otherwise." << std::endl;
+}
 
 int main(int argc, char *argv[])
 {
-    QCoreApplication a(argc, argv);
+    initGuidDatabase("guids.csv");
-    a.setOrganizationName("CodeRush");
-    a.setOrganizationDomain("coderush.me");
-    a.setApplicationName("UEFIExtract");
 
-    if (a.arguments().length() > 32) {
+    if (argc <= 1) {
-        std::cout << "Too many arguments" << std::endl;
+        print_usage();
         return 1;
     }
     
-    if (a.arguments().length() > 1) {
+    // Help and version
+    if (argc == 2) {
+        UString arg = UString(argv[1]);
+        if (arg == UString("-h") || arg == UString("--help")) {
+            print_usage();
+            return 0;
+        }
+        else if (arg == UString("-v") || arg == UString("--version")) {
+            std::cout << PROGRAM_VERSION << std::endl;
+            return 0;
+        }
+    }
+    
     // Check that input file exists
-        QString path = a.arguments().at(1);
+    USTATUS result;
-        QFileInfo fileInfo(path);
+    UByteArray buffer;
-        if (!fileInfo.exists())
+    UString path = getAbsPath(argv[1]);
+    if (false == readFileIntoBuffer(path, buffer))
         return U_FILE_OPEN;
     
-        // Open the input file
+    // Hack to support legacy UEFIDump mode
-        QFile inputFile;
+    if (argc == 3 && !std::strcmp(argv[2], "unpack")) {
-        inputFile.setFileName(path);
+        UEFIDumper uefidumper;
-        if (!inputFile.open(QFile::ReadOnly))
+        return (uefidumper.dump(buffer, UString(argv[1])) != U_SUCCESS);
-            return U_FILE_OPEN;
+    }
-
-        // Read and close the file
-        QByteArray buffer = inputFile.readAll();
-        inputFile.close();
     
     // Create model and ffsParser
     TreeModel model;
     FfsParser ffsParser(&model);
     // Parse input buffer
-        USTATUS result = ffsParser.parse(buffer);
+    result = ffsParser.parse(buffer);
     if (result)
-            return result;
+        return (int)result;
-
-        // Show ffsParser's messages
-        std::vector<std::pair<QString, QModelIndex> > messages = ffsParser.getMessages();
-        for (size_t i = 0; i < messages.size(); i++) {
-            std::cout << messages[i].first.toLatin1().constData() << std::endl;
-        }
-
-        // Get last VTF
-        std::vector<std::vector<QString> > fitTable = ffsParser.getFitTable();
-        if (fitTable.size()) {
-             std::cout << "-------------------------------------------------------------------" << std::endl;
-             std::cout << "     Address     |   Size    |  Ver  | CS  |         Type          " << std::endl;
-             std::cout << "-------------------------------------------------------------------" << std::endl;
-             for (size_t i = 0; i < fitTable.size(); i++) {
-                  std::cout << fitTable[i][0].toLatin1().constData() << " | "
-                            << fitTable[i][1].toLatin1().constData() << " | "
-                            << fitTable[i][2].toLatin1().constData() << " | "
-                            << fitTable[i][3].toLatin1().constData() << " | "
-                            << fitTable[i][4].toLatin1().constData() << std::endl;
-             }
-        }
     
+    ffsParser.outputInfo();
     
     // Create ffsDumper
     FfsDumper ffsDumper(&model);
     
-        // Dump only leaf elements, no report
+    // Dump only leaf elements, no report or GUID database
-        if (a.arguments().length() == 3 && a.arguments().at(2) == QString("dump")) {
+    if (argc == 3 && !std::strcmp(argv[2], "dump")) {
-            return (ffsDumper.dump(model.index(0, 0), fileInfo.fileName().append(".dump")) != U_SUCCESS);
+        return (ffsDumper.dump(model.index(0, 0), path + UString(".dump")) != U_SUCCESS);
     }
-        else if (a.arguments().length() > 3 || 
+    // Dump named GUIDs found in the image, no dump or report
-            (a.arguments().length() == 3 && a.arguments().at(2) != QString("all") && a.arguments().at(2) != QString("report"))) { // Dump specific files, without report
+    else if (argc == 3 && !std::strcmp(argv[2], "guids")) {
-            UINT32 returned = 0;
+        GuidDatabase db = guidDatabaseFromTreeRecursive(&model, model.index(0, 0));
-            for (int i = 2; i < a.arguments().length(); i++) {
+        if (!db.empty()) {
-                result = ffsDumper.dump(model.index(0, 0), fileInfo.fileName().append(".dump"), true, a.arguments().at(i));
+            return (int)guidDatabaseExportToFile(path + UString(".guids.csv"), db);
-                if (result)
-                    returned |= (1 << (i - 1));
         }
-            return returned;
     }
-                
+    // Generate report, no dump or GUID database
-        // Create ffsReport
+    else if (argc == 3 && !std::strcmp(argv[2], "report")) {
         FfsReport ffsReport(&model);
-        std::vector<QString> report = ffsReport.generate();
+        std::vector<UString> report = ffsReport.generate();
         if (report.size()) {
-            QFile file;
+            std::ofstream file;
-            file.setFileName(fileInfo.fileName().append(".report.txt"));
+            file.open((path + UString(".report.txt")).toLocal8Bit());
-            if (file.open(QFile::Text | QFile::WriteOnly)) {
+            for (size_t i = 0; i < report.size(); i++)
-                for (size_t i = 0; i < report.size(); i++) {
+                file << report[i].toLocal8Bit() << '\n';
-                    file.write(report[i].toLatin1().append('\n'));
-                }
-                file.close();
-            }
-        }
-        
-        // Dump all non-leaf elements, with report, default
-        if (a.arguments().length() == 2) {
-            return (ffsDumper.dump(model.index(0, 0), fileInfo.fileName().append(".dump")) != U_SUCCESS);
-        }
-        else if (a.arguments().length() == 3 && a.arguments().at(2) == QString("all")) { // Dump every elementm with report
-            return (ffsDumper.dump(model.index(0, 0), fileInfo.fileName().append(".dump"), true) != U_SUCCESS);
-        }
-        else if (a.arguments().length() == 3 && a.arguments().at(2) == QString("report")) { // Skip dumping
             return 0;
         }
+        return 1;
     }
+    // Either default or all mode
+    else if (argc == 2 || (argc == 3 && !std::strcmp(argv[2], "all"))) {
+        // Generate report
+        FfsReport ffsReport(&model);
+        std::vector<UString> report = ffsReport.generate();
+        if (report.size()) {
+            std::ofstream file;
+            file.open((path + UString(".report.txt")).toLocal8Bit());
+            for (size_t i = 0; i < report.size(); i++)
+                file << report[i].toLocal8Bit() << '\n';
+        }
+        
+        // Create GUID database
+        GuidDatabase db = guidDatabaseFromTreeRecursive(&model, model.index(0, 0));
+        if (!db.empty()) {
+            guidDatabaseExportToFile(path + UString(".guids.csv"), db);
+        }
+        
+        // Dump all non-leaf elements, with report and GUID database, default
+        if (argc == 2) {
+            return (ffsDumper.dump(model.index(0, 0), path + UString(".dump")) != U_SUCCESS);
+        }
+        else if (argc == 3 && !std::strcmp(argv[2], "all")) { // Dump every element with report and GUID database
+            return (ffsDumper.dump(model.index(0, 0), path + UString(".dump"), FfsDumper::DUMP_ALL) != U_SUCCESS);
+        }
+    }
+    // Dump specific files, without report or GUID database
+    else {
+        std::vector<UString> inputs, outputs;
+        std::vector<FfsDumper::DumpMode> modes;
+        std::vector<UINT8> sectionTypes;
+        ReadType readType = READ_INPUT;
+        for (int i = 2; i < argc; i++) {
+            const char *arg = argv[i];
+            if (!std::strcmp(arg, "-i")) {
+                readType = READ_INPUT;
+                continue;
+            } else if (!std::strcmp(arg, "-o")) {
+                readType = READ_OUTPUT;
+                continue;
+            } else if (!std::strcmp(arg, "-m")) {
+                readType = READ_MODE;
+                continue;
+            } else if (!std::strcmp(arg, "-t")) {
+                readType = READ_SECTION;
+                continue;
+            }
+            
+            if (readType == READ_INPUT) {
+                inputs.push_back(arg);
+            } else if (readType == READ_OUTPUT) {
+                outputs.push_back(getAbsPath(arg));
+            } else if (readType == READ_MODE) {
+                if (!std::strcmp(arg, "all"))
+                    modes.push_back(FfsDumper::DUMP_ALL);
+                else if (!std::strcmp(arg, "body"))
+                    modes.push_back(FfsDumper::DUMP_BODY);
+                else if (!std::strcmp(arg, "unc_data"))
+                    modes.push_back(FfsDumper::DUMP_UNC_DATA);
+                else if (!std::strcmp(arg, "header"))
+                    modes.push_back(FfsDumper::DUMP_HEADER);
+                else if (!std::strcmp(arg, "info"))
+                    modes.push_back(FfsDumper::DUMP_INFO);
+                else if (!std::strcmp(arg, "file"))
+                    modes.push_back(FfsDumper::DUMP_FILE);
+                else
+                    return U_INVALID_PARAMETER;
+            } else if (readType == READ_SECTION) {
+                char *converted = const_cast<char *>(arg);
+                UINT8 sectionType = (UINT8)std::strtol(arg, &converted, 16);
+                if (converted == arg)
+                    return U_INVALID_PARAMETER;
+                sectionTypes.push_back(sectionType);
+            }
+        }
+        if (inputs.empty() || (!outputs.empty() && inputs.size() != outputs.size()) ||
+            (!modes.empty() && inputs.size() != modes.size()) ||
+            (!sectionTypes.empty() && inputs.size() != sectionTypes.size()))
+            return U_INVALID_PARAMETER;
+        
+        USTATUS lastError = U_SUCCESS;
+        for (size_t i = 0; i < inputs.size(); i++) {
+            UString outPath = outputs.empty() ? path + UString(".dump") : outputs[i];
+            FfsDumper::DumpMode mode = modes.empty() ? FfsDumper::DUMP_ALL : modes[i];
+            UINT8 type = sectionTypes.empty() ? FfsDumper::IgnoreSectionType : sectionTypes[i];
+            result = ffsDumper.dump(model.index(0, 0), outPath, mode, type, inputs[i]);
+            if (result) {
+                std::cout << "Guid " << inputs[i].toLocal8Bit() << " failed with " << result << " code!" << std::endl;
+                lastError = result;
+            }
+        }
+        
+        return (int)lastError;
+    }
+    
     // If parameters are different, show version and usage information
-    std::cout << "UEFIExtract 0.13.0" << std::endl << std::endl
+    print_usage();
-              << "Usage: UEFIExtract imagefile        - generate report and dump only leaf tree items into .dump folder." << std::endl
-              << "       UEFIExtract imagefile all    - generate report and dump all tree items." << std::endl
-              << "       UEFIExtract imagefile dump   - only generate dump, no report needed." << std::endl
-              << "       UEFIExtract imagefile report - only generate report, no dump needed." << std::endl
-              << "       UEFIExtract imagefile GUID_1 GUID_2 ... GUID_31 - dump only FFS file(s) with specific GUID(s), without report." << std::endl
-              << "Return value is a bit mask where 0 at position N means that file with GUID_N was found and unpacked, 1 otherwise." << std::endl;
     return 1;
 }

UEFIFind/CMakeLists.txt

@@ -0,0 +1,82 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 3.22)
+
+PROJECT(UEFIFind)
+
+SET(CMAKE_CXX_STANDARD 11)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+SET(CMAKE_CXX_EXTENSIONS OFF)
+
+SET(PROJECT_SOURCES
+ uefifind_main.cpp
+ uefifind.cpp
+ ../common/guiddatabase.cpp
+ ../common/types.cpp
+ ../common/filesystem.cpp
+ ../common/descriptor.cpp
+ ../common/ffs.cpp
+ ../common/nvram.cpp
+ ../common/nvramparser.cpp
+ ../common/ffsparser.cpp
+ ../common/fitparser.cpp
+ ../common/peimage.cpp
+ ../common/treeitem.cpp
+ ../common/treemodel.cpp
+ ../common/utility.cpp
+ ../common/LZMA/LzmaDecompress.c
+ ../common/LZMA/SDK/C/Bra.c
+ ../common/LZMA/SDK/C/Bra86.c
+ ../common/LZMA/SDK/C/CpuArch.c
+ ../common/LZMA/SDK/C/LzmaDec.c
+ ../common/Tiano/EfiTianoDecompress.c
+ ../common/ustring.cpp
+ ../common/bstrlib/bstrlib.c
+ ../common/bstrlib/bstrwrap.cpp
+ ../common/generated/ami_nvar.cpp
+ ../common/generated/apple_sysf.cpp
+ ../common/generated/dell_dvar.cpp
+ ../common/generated/edk2_vss.cpp
+ ../common/generated/edk2_vss2.cpp
+ ../common/generated/edk2_ftw.cpp
+ ../common/generated/insyde_fdc.cpp
+ ../common/generated/insyde_fdm.cpp
+ ../common/generated/ms_slic_marker.cpp
+ ../common/generated/ms_slic_pubkey.cpp
+ ../common/generated/phoenix_flm.cpp
+ ../common/generated/phoenix_evsa.cpp
+ ../common/generated/intel_acbp_v1.cpp
+ ../common/generated/intel_acbp_v2.cpp
+ ../common/generated/intel_keym_v1.cpp
+ ../common/generated/intel_keym_v2.cpp
+ ../common/generated/intel_acm.cpp
+ ../common/kaitai/kaitaistream.cpp
+ ../common/digest/sha1.c
+ ../common/digest/sha256.c
+ ../common/digest/sha512.c
+ ../common/digest/sm3.c
+ ../common/zlib/adler32.c
+ ../common/zlib/compress.c
+ ../common/zlib/crc32.c
+ ../common/zlib/deflate.c
+ ../common/zlib/gzclose.c
+ ../common/zlib/gzlib.c
+ ../common/zlib/gzread.c
+ ../common/zlib/gzwrite.c
+ ../common/zlib/inflate.c
+ ../common/zlib/infback.c
+ ../common/zlib/inftrees.c
+ ../common/zlib/inffast.c
+ ../common/zlib/trees.c
+ ../common/zlib/uncompr.c
+ ../common/zlib/zutil.c
+)
+
+ADD_EXECUTABLE(UEFIFind ${PROJECT_SOURCES} uefifind.manifest)
+
+IF(UNIX)
+ SET_TARGET_PROPERTIES(UEFIFind PROPERTIES OUTPUT_NAME uefifind)
+ENDIF()
+
+INSTALL(
+ TARGETS UEFIFind
+ RUNTIME DESTINATION bin
+)

UEFIFind/meson.build

@@ -0,0 +1,16 @@
+executable(
+  'UEFIFind',
+  sources: [
+    'uefifind_main.cpp',
+    'uefifind.cpp',
+  ],
+  link_with: [
+    lzma,
+    bstrlib,
+    uefitoolcommon,
+  ],
+  dependencies: [
+    zlib,
+  ],
+  install: true,
+)

UEFIFind/uefifind.cpp

@@ -12,6 +12,9 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 */
 
 #include "uefifind.h"
+#include <fstream>
+#include <set>
+
 
 UEFIFind::UEFIFind()
 {
@@ -27,25 +30,13 @@ UEFIFind::~UEFIFind()
     model = NULL;
 }
 
-USTATUS UEFIFind::init(const QString & path)
+USTATUS UEFIFind::init(const UString & path)
 {
-    USTATUS result;
+    UByteArray buffer;
-    
+    if (false == readFileIntoBuffer(path, buffer))
-    fileInfo = QFileInfo(path);
-
-    if (!fileInfo.exists())
         return U_FILE_OPEN;
 
-    QFile inputFile;
+    USTATUS result = ffsParser->parse(buffer);
-    inputFile.setFileName(path);
-
-    if (!inputFile.open(QFile::ReadOnly))
-        return U_FILE_OPEN;
-
-    QByteArray buffer = inputFile.readAll();
-    inputFile.close();
-
-    result = ffsParser->parse(buffer);
     if (result)
         return result;
 
@@ -53,10 +44,78 @@ USTATUS UEFIFind::init(const QString & path)
     return U_SUCCESS;
 }
 
-USTATUS UEFIFind::find(const UINT8 mode, const bool count, const QString & hexPattern, QString & result)
+USTATUS UEFIFind::findFileRecursive(const UModelIndex index, const UString & hexPattern, const UINT8 mode, std::set<std::pair<UModelIndex, UModelIndex> > & files)
 {
-    QModelIndex root = model->index(0, 0);
+    if (!index.isValid())
-    std::set<std::pair<QModelIndex, QModelIndex> > files;
+        return U_SUCCESS;
+
+    if (hexPattern.isEmpty())
+        return U_INVALID_PARAMETER;
+
+    const char *hexPatternRaw = hexPattern.toLocal8Bit();
+    std::vector<UINT8> pattern, patternMask;
+    if (!makePattern(hexPatternRaw, pattern, patternMask))
+        return U_INVALID_PARAMETER;
+
+    // Check for "all substrings" pattern
+    size_t count = 0;
+    for (size_t i = 0; i < patternMask.size(); i++)
+        if (patternMask[i] == 0)
+            count++;
+    if (count == patternMask.size())
+        return U_SUCCESS;
+
+    bool hasChildren = (model->rowCount(index) > 0);
+    for (int i = 0; i < model->rowCount(index); i++) {
+        findFileRecursive(index.model()->index(i, index.column(), index), hexPattern, mode, files);
+    }
+
+    // TODO: handle a case where an item has both compressed and uncompressed bodies
+    UByteArray data;
+    if (hasChildren) {
+        if (mode == SEARCH_MODE_HEADER)
+            data = model->header(index);
+        else if (mode == SEARCH_MODE_ALL)
+            data = model->header(index) + model->body(index);
+    }
+    else {
+        if (mode == SEARCH_MODE_HEADER)
+            data = model->header(index);
+        else if (mode == SEARCH_MODE_BODY)
+            data = model->body(index);
+        else
+            data = model->header(index) + model->body(index);
+    }
+
+    const UINT8 *rawData = reinterpret_cast<const UINT8 *>(data.constData());
+    INTN offset = findPattern(pattern.data(), patternMask.data(), pattern.size(), rawData, data.size(), 0);
+
+    // For patterns that cross header|body boundary, skip patterns entirely located in body, since
+    // children search above has already found them.
+    if (hasChildren && mode == SEARCH_MODE_ALL && offset >= model->header(index).size()) {
+        offset = -1;
+    }
+
+    if (offset >= 0) {
+        if (model->type(index) != Types::File) {
+            UModelIndex parentFile = model->findParentOfType(index, Types::File);
+            if (model->type(index) == Types::Section && model->subtype(index) == EFI_SECTION_FREEFORM_SUBTYPE_GUID)
+                files.insert(std::pair<UModelIndex, UModelIndex>(parentFile, index));
+            else
+                files.insert(std::pair<UModelIndex, UModelIndex>(parentFile, UModelIndex()));
+        }
+        else {
+            files.insert(std::pair<UModelIndex, UModelIndex>(index, UModelIndex()));
+        }
+    }
+
+    return U_SUCCESS;
+}
+
+USTATUS UEFIFind::find(const UINT8 mode, const bool count, const UString & hexPattern, UString & result)
+{
+    UModelIndex root = model->index(0, 0);
+    std::set<std::pair<UModelIndex, UModelIndex> > files;
 
     result.clear();
 
@@ -66,78 +125,24 @@ USTATUS UEFIFind::find(const UINT8 mode, const bool count, const QString & hexPa
     
     if (count) {
         if (!files.empty())
-            result.append(QString("%1\n").arg(files.size()));
+            result += usprintf("%lu\n", files.size());
         return U_SUCCESS;
     }
 
-    for (std::set<std::pair<QModelIndex, QModelIndex> >::const_iterator citer = files.cbegin(); citer != files.cend(); ++citer) {
+    for (std::set<std::pair<UModelIndex, UModelIndex> >::const_iterator citer = files.begin(); citer != files.end(); ++citer) {
-        QByteArray data(16, '\x00');
+        UByteArray data(16, '\x00');
-        std::pair<QModelIndex, QModelIndex> indexes = *citer;
+        std::pair<UModelIndex, UModelIndex> indexes = *citer;
         if (!model->hasEmptyHeader(indexes.first))
             data = model->header(indexes.first).left(16);
-        result.append(guidToUString(*(const EFI_GUID*)data.constData()));
+        result += guidToUString(readUnaligned((const EFI_GUID*)data.constData()));
 
         // Special case of freeform subtype GUID files
         if (indexes.second.isValid() && model->subtype(indexes.second) == EFI_SECTION_FREEFORM_SUBTYPE_GUID) {
-            data = model->header(indexes.second).left(sizeof(EFI_FREEFORM_SUBTYPE_GUID_SECTION));
+            data = model->header(indexes.second);
-            result.append(" ").append(guidToUString(*(const EFI_GUID*)(data.constData() + sizeof(EFI_COMMON_SECTION_HEADER))));
+            result += UString(" ") + (guidToUString(readUnaligned((const EFI_GUID*)(data.constData() + sizeof(EFI_COMMON_SECTION_HEADER)))));
         }
         
-        result.append("\n");
+        result += UString("\n");
     }
     return U_SUCCESS;
 }
-
-USTATUS UEFIFind::findFileRecursive(const QModelIndex index, const QString & hexPattern, const UINT8 mode, std::set<std::pair<QModelIndex, QModelIndex> > & files)
-{
-    if (!index.isValid())
-        return U_SUCCESS;
-
-    if (hexPattern.isEmpty())
-        return U_INVALID_PARAMETER;
-
-    // Check for "all substrings" pattern
-    if (hexPattern.count('.') == hexPattern.length())
-        return U_SUCCESS;
-
-    bool hasChildren = (model->rowCount(index) > 0);
-    for (int i = 0; i < model->rowCount(index); i++) {
-        findFileRecursive(index.child(i, index.column()), hexPattern, mode, files);
-    }
-
-    QByteArray data;
-    if (hasChildren) {
-        if (mode == SEARCH_MODE_HEADER || mode == SEARCH_MODE_ALL)
-            data.append(model->header(index));
-    }
-    else {
-        if (mode == SEARCH_MODE_HEADER)
-            data.append(model->header(index));
-        else if (mode == SEARCH_MODE_BODY)
-            data.append(model->body(index));
-        else
-            data.append(model->header(index)).append(model->body(index));
-    }
-
-    QString hexBody = QString(data.toHex());
-    QRegExp regexp = QRegExp(QString(hexPattern), Qt::CaseInsensitive);
-    INT32 offset = regexp.indexIn(hexBody);
-    while (offset >= 0) {
-        if (offset % 2 == 0) {
-            if (model->type(index) != Types::File) {
-                QModelIndex ffs = model->findParentOfType(index, Types::File);
-                if (model->type(index) == Types::Section && model->subtype(index) == EFI_SECTION_FREEFORM_SUBTYPE_GUID)
-                    files.insert(std::pair<QModelIndex, QModelIndex>(ffs, index));
-                else
-                    files.insert(std::pair<QModelIndex, QModelIndex>(ffs, QModelIndex()));
-            }
-            else
-                files.insert(std::pair<QModelIndex, QModelIndex>(index, QModelIndex()));
-
-            break;
-        }
-        offset = regexp.indexIn(hexBody, offset + 1);
-    }
-
-    return U_SUCCESS;
-}

UEFIFind/uefifind.h

@@ -14,19 +14,15 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #ifndef UEFIFIND_H
 #define UEFIFIND_H
 
+#include <iterator>
 #include <set>
 
-#include <QObject>
-#include <QByteArray>
-#include <QString>
-#include <QDir>
-#include <QFileInfo>
-#include <QString>
-#include <QUuid>
-
 #include "../common/basetypes.h"
+#include "../common/ustring.h"
+#include "../common/filesystem.h"
 #include "../common/ffsparser.h"
 #include "../common/ffs.h"
+#include "../common/utility.h"
 
 class UEFIFind
 {
@@ -34,16 +30,14 @@ public:
     explicit UEFIFind();
     ~UEFIFind();
 
-    USTATUS init(const QString & path);
+    USTATUS init(const UString & path);
-    USTATUS find(const UINT8 mode, const bool count, const QString & hexPattern, QString & result);
+    USTATUS find(const UINT8 mode, const bool count, const UString & hexPattern, UString & result);
 
 private:
-    USTATUS findFileRecursive(const QModelIndex index, const QString & hexPattern, const UINT8 mode, std::set<std::pair<QModelIndex, QModelIndex> > & files);
+    USTATUS findFileRecursive(const UModelIndex index, const UString & hexPattern, const UINT8 mode, std::set<std::pair<UModelIndex, UModelIndex> > & files);
-    QString guidToQString(const UINT8* guid);
 
     FfsParser* ffsParser;
     TreeModel* model;
-    QFileInfo fileInfo;
     bool initDone;
 };
 

UEFIFind/uefifind.manifest

@@ -0,0 +1,8 @@
+<assembly xmlns:asmv1="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+    <asmv1:assemblyIdentity type='win32' name='me.coderush.UEFIFind' version='1.0.0.0' />
+    <asmv3:application>
+        <asmv3:windowsSettings xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
+            <ws2:longPathAware>true</ws2:longPathAware>
+        </asmv3:windowsSettings>
+    </asmv3:application>
+</assembly>

UEFIFind/uefifind.pro

@@ -1,42 +0,0 @@
-QT       += core
-QT       -= gui
-
-TARGET    = UEFIFind
-TEMPLATE  = app
-CONFIG   += console
-CONFIG   -= app_bundle
-
-SOURCES  += uefifind_main.cpp \
- uefifind.cpp \
- ../common/types.cpp \
- ../common/descriptor.cpp \
- ../common/ffs.cpp \
- ../common/nvram.cpp \
- ../common/ffsparser.cpp \
- ../common/peimage.cpp \
- ../common/treeitem.cpp \
- ../common/treemodel.cpp \
- ../common/utility.cpp \
- ../common/LZMA/LzmaDecompress.c \
- ../common/LZMA/SDK/C/LzmaDec.c \
- ../common/Tiano/EfiTianoDecompress.c \
- ../common/ustring.cpp
-
-HEADERS  += uefifind.h \
- ../common/basetypes.h \
- ../common/descriptor.h \
- ../common/gbe.h \
- ../common/me.h \
- ../common/ffs.h \
- ../common/nvram.h \
- ../common/ffsparser.h \
- ../common/peimage.h \
- ../common/types.h \
- ../common/treeitem.h \
- ../common/treemodel.h \
- ../common/utility.h \
- ../common/LZMA/LzmaDecompress.h \
- ../common/Tiano/EfiTianoDecompress.h \
- ../common/ustring.h \
- ../common/ubytearray.h
- 

UEFIFind/uefifind_main.cpp

@@ -1,6 +1,6 @@
 /* uefifind_main.cpp
 
-Copyright (c) 2016, Nikolaj Schlej. All rights reserved.
+Copyright (c) 2018, LongSoft. All rights reserved.
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 which accompanies this distribution.  The full text of the license may be found at
@@ -10,49 +10,77 @@ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 
 */
-#include <QCoreApplication>
 #include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "../version.h"
+#include "../common/guiddatabase.h"
 #include "uefifind.h"
 
+void print_usage()
+{
+    std::cout << "UEFIFind " PROGRAM_VERSION << std::endl <<
+        "Usage: UEFIFind {-h | --help | -v | -version}" << std::endl <<
+        "       UEFIFind imagefile {header | body | all} {list | count} pattern" << std::endl <<
+        "       UEFIFind imagefile file patternsfile" << std::endl;
+}
+
 int main(int argc, char *argv[])
 {
-    QCoreApplication a(argc, argv);
-    a.setOrganizationName("CodeRush");
-    a.setOrganizationDomain("coderush.me");
-    a.setApplicationName("UEFIFind");
-
     UEFIFind w;
-    UINT8 result;
+    USTATUS result;
+
+    if (argc == 1) {
+        print_usage();
+        return U_SUCCESS;
+    }
+    else if (argc == 2) {
+        UString arg = argv[1];
+        if (arg == UString("-h") || arg == UString("--help")) {
+            print_usage();
+            return U_SUCCESS;
+        }
+        else if (arg == UString("-v") || arg == UString("--version")) {
+            std::cout << PROGRAM_VERSION << std::endl;
+            return U_SUCCESS;
+        }
+    }
+    else if (argc == 5) {
+        UString inputArg = argv[1];
+        UString modeArg = argv[2];
+        UString subModeArg = argv[3];
+        UString patternArg = argv[4];
 
-    if (a.arguments().length() == 5) {
         // Get search mode
         UINT8 mode;
-        if (a.arguments().at(1) == QString("header"))
+        if (modeArg == UString("header"))
             mode = SEARCH_MODE_HEADER;
-        else if (a.arguments().at(1) == QString("body"))
+        else if (modeArg == UString("body"))
             mode = SEARCH_MODE_BODY;
-        else if (a.arguments().at(1) == QString("all"))
+        else if (modeArg == UString("all"))
             mode = SEARCH_MODE_ALL;
         else
             return U_INVALID_PARAMETER;
 
         // Get result type
         bool count;
-        if (a.arguments().at(2) == QString("list"))
+        if (subModeArg == UString("list"))
             count = false;
-        else if (a.arguments().at(2) == QString("count"))
+        else if (subModeArg == UString("count"))
             count = true;
         else
             return U_INVALID_PARAMETER;
 
         // Parse input file
-        result = w.init(a.arguments().at(4));
+        result = w.init(inputArg);
         if (result)
             return result;
 
         // Go find the supplied pattern
-        QString found;
+        UString found;
-        result = w.find(mode, count, a.arguments().at(3), found);
+        result = w.find(mode, count, patternArg, found);
         if (result)
             return result;
 
@@ -61,82 +89,93 @@ int main(int argc, char *argv[])
             return U_ITEM_NOT_FOUND;
 
         // Print result
-        std::cout << found.toStdString();
+        std::cout << found.toLocal8Bit();
         return U_SUCCESS;
     }
-    else if (a.arguments().length() == 4) {
+    else if (argc == 4) {
+        UString inputArg = argv[1];
+        UString modeArg = argv[2];
+        UString patternArg = argv[3];
+
         // Get search mode
-        if (a.arguments().at(1) != QString("file"))
+        if (modeArg != UString("file"))
             return U_INVALID_PARAMETER;
 
         // Open patterns file
-        QFileInfo fileInfo(a.arguments().at(2));
+        if (!isExistOnFs(patternArg))
-        if (!fileInfo.exists())
             return U_FILE_OPEN;
 
-        QFile patternsFile;
+        std::ifstream patternsFile(patternArg.toLocal8Bit());
-        patternsFile.setFileName(a.arguments().at(2));
+        if (!patternsFile)
-        if (!patternsFile.open(QFile::ReadOnly))
             return U_FILE_OPEN;
 
         // Parse input file
-        result = w.init(a.arguments().at(3));
+        result = w.init(inputArg);
         if (result)
             return result;
 
         // Perform searches
         bool somethingFound = false;
-        while (!patternsFile.atEnd()) {
+        while (!patternsFile.eof()) {
-            QByteArray line = patternsFile.readLine();
+            std::string line;
+            std::getline(patternsFile, line);
             // Use sharp symbol as commentary
-            if (line.count() == 0 || line[0] == '#')
+            if (line.size() == 0 || line[0] == '#')
                 continue;
 
             // Split the read line
-            QList<QByteArray> list = line.split(' ');
+            std::vector<UString> list;
-            if (list.count() < 3) {
+            std::string::size_type prev = 0, curr = 0;
-                std::cout << line.constData() << "skipped, too few arguments" << std::endl << std::endl;
+            while ((curr = line.find(' ', curr)) != std::string::npos) {
+                std::string substring( line.substr(prev, curr-prev) );
+                list.push_back(UString(substring.c_str()));
+                prev = ++curr;
+            }
+            list.push_back(UString(line.substr(prev, curr-prev).c_str()));
+
+            if (list.size() < 3) {
+                std::cout << line << std::endl << "skipped, too few arguments" << std::endl << std::endl;
                 continue;
             }
             // Get search mode
             UINT8 mode;
-            if (list.at(0) == QString("header"))
+            if (list.at(0) == UString("header"))
                 mode = SEARCH_MODE_HEADER;
-            else if (list.at(0) == QString("body"))
+            else if (list.at(0) == UString("body"))
                 mode = SEARCH_MODE_BODY;
-            else if (list.at(0) == QString("all"))
+            else if (list.at(0) == UString("all"))
                 mode = SEARCH_MODE_ALL;
             else {
-                std::cout << line.constData() << "skipped, invalid search mode" << std::endl << std::endl;
+                std::cout << line << std::endl << "skipped, invalid search mode" << std::endl << std::endl;
                 continue;
             }
 
             // Get result type
             bool count;
-            if (list.at(1) == QString("list"))
+            if (list.at(1) == UString("list"))
                 count = false;
-            else if (list.at(1) == QString("count"))
+            else if (list.at(1) == UString("count"))
                 count = true;
             else {
-                std::cout << line.constData() << "skipped, invalid result type" << std::endl << std::endl;
+                std::cout << line << std::endl << "skipped, invalid result type" << std::endl << std::endl;
                 continue;
             }
 
             // Go find the supplied pattern
-            QString found;
+            UString found;
             result = w.find(mode, count, list.at(2), found);
             if (result) {
-                std::cout << line.constData() << "skipped, find failed with error " << (UINT32)result << std::endl << std::endl;
+                std::cout << line << std::endl << "skipped, find failed with error " << (UINT32)result << std::endl << std::endl;
                 continue;
             }
 
             if (found.isEmpty()) {
                 // Nothing is found
-                std::cout << line.constData() << "nothing found" << std::endl << std::endl;
+                std::cout << line << std::endl << "nothing found" << std::endl << std::endl;
             }
             else {
                 // Print result
-                std::cout << line.constData() << found.toStdString() << std::endl;
+                std::cout << line << std::endl << found.toLocal8Bit() << std::endl;
                 somethingFound = true;
             }
         }
@@ -147,11 +186,7 @@ int main(int argc, char *argv[])
 
         return U_SUCCESS;
     }
-    else {
-        std::cout << "UEFIFind 0.10.6" << std::endl << std::endl <<
-            "Usage: UEFIFind {header | body | all} {list | count} pattern imagefile" << std::endl <<
-            "    or UEFIFind file patternsfile imagefile" << std::endl;
-        return U_INVALID_PARAMETER;
-    }
-}
 
+    print_usage();
+    return U_INVALID_PARAMETER;
+}

UEFITool/CMakeLists.txt

@@ -0,0 +1,146 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 3.22)
+
+PROJECT(UEFITool LANGUAGES C CXX)
+
+SET(CMAKE_CXX_STANDARD 11)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+SET(CMAKE_CXX_EXTENSIONS OFF)
+
+FIND_PACKAGE(Qt6 REQUIRED COMPONENTS Widgets)
+
+SET(PROJECT_FORMS
+ uefitool.ui
+ searchdialog.ui
+ hexviewdialog.ui
+ gotobasedialog.ui
+ gotoaddressdialog.ui
+ )
+
+SET(PROJECT_HEADERS 
+ uefitool.h
+ hexspinbox.h
+ searchdialog.h
+ hexviewdialog.h
+ gotobasedialog.h
+ gotoaddressdialog.h
+)
+
+SET(PROJECT_SOURCES 
+ icons/uefitool.icns
+ uefitool.rc
+ uefitool_main.cpp
+ uefitool.cpp
+ searchdialog.cpp
+ hexviewdialog.cpp
+ hexlineedit.cpp
+ ffsfinder.cpp
+ hexspinbox.cpp
+ ../common/fitparser.cpp
+ ../common/guiddatabase.cpp
+ ../common/nvram.cpp
+ ../common/nvramparser.cpp
+ ../common/meparser.cpp
+ ../common/ffsops.cpp
+ ../common/types.cpp
+ ../common/descriptor.cpp
+ ../common/ffs.cpp
+ ../common/peimage.cpp
+ ../common/utility.cpp
+ ../common/ffsbuilder.cpp
+ ../common/ffsparser.cpp
+ ../common/ffsreport.cpp
+ ../common/treeitem.cpp
+ ../common/treemodel.cpp
+ ../common/LZMA/LzmaCompress.c
+ ../common/LZMA/LzmaDecompress.c
+ ../common/LZMA/SDK/C/CpuArch.c
+ ../common/LZMA/SDK/C/Bra.c
+ ../common/LZMA/SDK/C/Bra86.c
+ ../common/LZMA/SDK/C/LzFind.c
+ ../common/LZMA/SDK/C/LzmaDec.c
+ ../common/LZMA/SDK/C/LzmaEnc.c
+ ../common/Tiano/EfiTianoDecompress.c
+ ../common/Tiano/EfiTianoCompress.c
+ ../common/Tiano/EfiTianoCompressLegacy.c
+ ../common/ustring.cpp
+ ../common/digest/sha1.c
+ ../common/digest/sha256.c
+ ../common/digest/sha512.c
+ ../common/digest/sm3.c
+ ../common/generated/ami_nvar.cpp
+ ../common/generated/apple_sysf.cpp
+ ../common/generated/dell_dvar.cpp
+ ../common/generated/edk2_vss.cpp
+ ../common/generated/edk2_vss2.cpp
+ ../common/generated/edk2_ftw.cpp
+ ../common/generated/insyde_fdc.cpp
+ ../common/generated/insyde_fdm.cpp
+ ../common/generated/ms_slic_marker.cpp
+ ../common/generated/ms_slic_pubkey.cpp
+ ../common/generated/phoenix_evsa.cpp
+ ../common/generated/phoenix_flm.cpp
+ ../common/generated/intel_acbp_v1.cpp
+ ../common/generated/intel_acbp_v2.cpp
+ ../common/generated/intel_keym_v1.cpp
+ ../common/generated/intel_keym_v2.cpp
+ ../common/generated/intel_acm.cpp
+ ../common/kaitai/kaitaistream.cpp
+ ../common/zlib/adler32.c
+ ../common/zlib/compress.c
+ ../common/zlib/crc32.c
+ ../common/zlib/deflate.c
+ ../common/zlib/gzclose.c
+ ../common/zlib/gzlib.c
+ ../common/zlib/gzread.c
+ ../common/zlib/gzwrite.c
+ ../common/zlib/inflate.c
+ ../common/zlib/infback.c
+ ../common/zlib/inftrees.c
+ ../common/zlib/inffast.c
+ ../common/zlib/trees.c
+ ../common/zlib/uncompr.c
+ ../common/zlib/zutil.c
+)
+
+QT_ADD_RESOURCES(PROJECT_SOURCES 
+ uefitool.qrc
+)
+
+ADD_DEFINITIONS(
+ -DU_ENABLE_NVRAM_PARSING_SUPPORT
+ -DU_ENABLE_ME_PARSING_SUPPORT
+ -DU_ENABLE_FIT_PARSING_SUPPORT
+ -DU_ENABLE_GUID_DATABASE_SUPPORT
+)
+
+SET_SOURCE_FILES_PROPERTIES(icons/uefitool.icns PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
+
+ADD_EXECUTABLE(UEFITool ${PROJECT_HEADERS} ${PROJECT_FORMS} ${PROJECT_SOURCES})
+
+TARGET_INCLUDE_DIRECTORIES(UEFITool PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
+
+TARGET_LINK_LIBRARIES(UEFITool PRIVATE Qt6::Widgets)
+
+ADD_SUBDIRECTORY(QHexView)
+TARGET_LINK_LIBRARIES(UEFITool PRIVATE QHexView)
+
+SET_TARGET_PROPERTIES(UEFITool PROPERTIES
+ WIN32_EXECUTABLE ON
+ MACOSX_BUNDLE ON
+ MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/Info.plist"
+ AUTOMOC ON
+ AUTOUIC ON
+)
+
+IF(UNIX AND (NOT APPLE) AND (NOT CYGWIN))
+ SET_TARGET_PROPERTIES(UEFITool PROPERTIES OUTPUT_NAME uefitool)
+ INSTALL(FILES icons/uefitool_16x16.png   DESTINATION share/icons/hicolor/16x16/apps   RENAME uefitool.png)
+ INSTALL(FILES icons/uefitool_32x32.png   DESTINATION share/icons/hicolor/32x32/apps   RENAME uefitool.png)
+ INSTALL(FILES icons/uefitool_64x64.png   DESTINATION share/icons/hicolor/64x64/apps   RENAME uefitool.png)
+ INSTALL(FILES icons/uefitool_128x128.png DESTINATION share/icons/hicolor/128x128/apps RENAME uefitool.png)
+ INSTALL(FILES icons/uefitool_256x256.png DESTINATION share/icons/hicolor/256x256/apps RENAME uefitool.png)
+ INSTALL(FILES icons/uefitool_512x512.png DESTINATION share/icons/hicolor/512x512/apps RENAME uefitool.png)
+ INSTALL(FILES uefitool.desktop DESTINATION share/applications)
+ENDIF()
+
+INSTALL(TARGETS UEFITool BUNDLE DESTINATION "/Applications" )

UEFITool/Info.plist

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDocumentTypes</key>
+	<array>
+		<dict>
+			<key>CFBundleTypeExtensions</key>
+			<array>
+				<string>*</string>
+			</array>
+			<key>CFBundleTypeRole</key>
+			<string>Viewer</string>
+			<key>LSHandlerRank</key>
+			<string>None</string>
+		</dict>
+	</array>
+	<key>CFBundleExecutable</key>
+	<string>UEFITool</string>
+	<key>CFBundleGetInfoString</key>
+	<string>UEFITool NE</string>
+	<key>CFBundleIconFile</key>
+	<string>uefitool</string>
+	<key>CFBundleIdentifier</key>
+	<string>me.coderush.UEFITool</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>NSPrincipalClass</key>
+	<string>NSApplication</string>
+</dict>
+</plist>

UEFITool/QHexView/CMakeLists.txt

@@ -0,0 +1,91 @@
+cmake_minimum_required(VERSION 3.13)
+
+project(QHexView)
+
+option(QHEXVIEW_BUILD_EXAMPLE "Build Example Application" OFF)
+option(QHEXVIEW_USE_QT5 "Enable Qt5 build" OFF)
+option(QHEXVIEW_ENABLE_DIALOGS "BuiltIn dialogs" OFF)
+
+if(QHEXVIEW_USE_QT5)
+    find_package(Qt5 REQUIRED COMPONENTS Widgets)
+else()
+    find_package(Qt6 COMPONENTS Widgets)
+
+    if(NOT Qt6_FOUND)
+        find_package(Qt5 REQUIRED COMPONENTS Widgets)
+    endif()
+endif()
+
+add_library(${PROJECT_NAME} STATIC)
+
+set_target_properties(${PROJECT_NAME}
+    PROPERTIES
+        CXX_STANDARD_REQUIRED YES
+        CXX_STANDARD 11
+        AUTOMOC ON
+)
+
+target_link_libraries(${PROJECT_NAME}
+    PUBLIC
+        Qt::Widgets
+)
+
+target_include_directories(${PROJECT_NAME}
+    PUBLIC
+        "${PROJECT_SOURCE_DIR}/include"
+)
+
+target_sources(${PROJECT_NAME}
+    PRIVATE 
+        include/QHexView/model/buffer/qdevicebuffer.h
+        include/QHexView/model/buffer/qhexbuffer.h
+        include/QHexView/model/buffer/qmappedfilebuffer.h
+        include/QHexView/model/buffer/qmemorybuffer.h
+        include/QHexView/model/buffer/qmemoryrefbuffer.h
+        include/QHexView/model/commands/hexcommand.h
+        include/QHexView/model/commands/insertcommand.h
+        include/QHexView/model/commands/removecommand.h
+        include/QHexView/model/commands/replacecommand.h
+        include/QHexView/model/commands/replacecommand.h
+        include/QHexView/model/qhexcursor.h
+        include/QHexView/model/qhexdelegate.h
+        include/QHexView/model/qhexdocument.h
+        include/QHexView/model/qhexmetadata.h
+        include/QHexView/model/qhexoptions.h
+        include/QHexView/model/qhexutils.h
+        include/QHexView/qhexview.h
+
+    PRIVATE 
+        src/model/commands/hexcommand.cpp
+        src/model/commands/insertcommand.cpp
+        src/model/commands/removecommand.cpp
+        src/model/commands/replacecommand.cpp
+        src/model/buffer/qdevicebuffer.cpp
+        src/model/buffer/qhexbuffer.cpp
+        src/model/buffer/qmemorybuffer.cpp
+        src/model/buffer/qmemoryrefbuffer.cpp
+        src/model/buffer/qmappedfilebuffer.cpp
+        src/model/qhexdelegate.cpp
+        src/model/qhexutils.cpp
+        src/model/qhexcursor.cpp
+        src/model/qhexmetadata.cpp
+        src/model/qhexdocument.cpp
+        src/qhexview.cpp
+)
+
+if(QHEXVIEW_ENABLE_DIALOGS)
+    target_sources(${PROJECT_NAME}
+        PRIVATE
+            include/QHexView/dialogs/hexfinddialog.h
+            src/dialogs/hexfinddialog.cpp
+    )
+
+    target_compile_definitions(${PROJECT_NAME} 
+        PUBLIC
+            QHEXVIEW_ENABLE_DIALOGS
+    )
+endif()
+
+if(QHEXVIEW_BUILD_EXAMPLE)
+    add_subdirectory(example)
+endif()

UEFITool/QHexView/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Dax89
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

UEFITool/QHexView/include/QHexView/dialogs/hexfinddialog.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <QDialog>
+#include <QHexView/model/qhexutils.h>
+
+class QRegularExpressionValidator;
+class QDoubleValidator;
+class QIntValidator;
+class QHexView;
+
+class HexFindDialog: public QDialog {
+    Q_OBJECT
+
+public:
+    enum class Type { Find, Replace };
+
+public:
+    explicit HexFindDialog(HexFindDialog::Type type = Type::Find,
+                           QHexView* parent = nullptr);
+    QHexView* hexView() const;
+
+private Q_SLOTS:
+    void updateFindOptions(int);
+    void validateActions();
+    void replace();
+    void find();
+
+private:
+    bool prepareOptions(QString& q, QHexFindMode& mode, QHexFindDirection& fd);
+    bool validateIntRange(uint v) const;
+    void checkResult(const QString& q, qint64 offset, QHexFindDirection fd);
+    void prepareTextMode(QLayout* l);
+    void prepareHexMode(QLayout* l);
+    void prepareIntMode(QLayout* l);
+    void prepareFloatMode(QLayout* l);
+
+private:
+    QRegularExpressionValidator *m_hexvalidator, *m_hexpvalidator;
+    QDoubleValidator* m_dblvalidator;
+    QIntValidator* m_intvalidator;
+    int m_oldidxbits{-1}, m_oldidxendian{-1};
+    unsigned int m_findoptions{0};
+    qint64 m_startoffset{-1};
+    Type m_type;
+
+private:
+    static const QString BUTTONBOX;
+    static const QString CBFINDMODE;
+    static const QString LEFIND;
+    static const QString LEREPLACE;
+    static const QString HLAYOUT;
+    static const QString GBOPTIONS;
+    static const QString RBALL;
+    static const QString RBFORWARD;
+    static const QString RBBACKWARD;
+};

UEFITool/QHexView/include/QHexView/model/buffer/qdevicebuffer.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <QHexView/model/buffer/qhexbuffer.h>
+
+class QDeviceBuffer: public QHexBuffer {
+    Q_OBJECT
+
+public:
+    explicit QDeviceBuffer(QObject* parent = nullptr);
+    virtual ~QDeviceBuffer();
+    uchar at(qint64 idx) override;
+    qint64 length() const override;
+    void insert(qint64 offset, const QByteArray& data) override;
+    void replace(qint64 offset, const QByteArray& data) override;
+    void remove(qint64 offset, int length) override;
+    QByteArray read(qint64 offset, int length) override;
+    bool read(QIODevice* device) override;
+    void write(QIODevice* device) override;
+    qint64 indexOf(const QByteArray& ba, qint64 from) override;
+    qint64 lastIndexOf(const QByteArray& ba, qint64 from) override;
+
+protected:
+    QIODevice* m_device{nullptr};
+};

UEFITool/QHexView/include/QHexView/model/buffer/qhexbuffer.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <QIODevice>
+#include <QObject>
+
+class QHexBuffer: public QObject {
+    Q_OBJECT
+
+public:
+    explicit QHexBuffer(QObject* parent = nullptr);
+    bool isEmpty() const;
+
+public:
+    virtual uchar at(qint64 idx);
+    virtual bool accept(qint64 idx) const;
+    virtual void replace(qint64 offset, const QByteArray& data);
+    virtual void read(char* data, int size);
+    virtual void read(const QByteArray& ba);
+
+public:
+    virtual qint64 length() const = 0;
+    virtual void insert(qint64 offset, const QByteArray& data) = 0;
+    virtual void remove(qint64 offset, int length) = 0;
+    virtual QByteArray read(qint64 offset, int length) = 0;
+    virtual bool read(QIODevice* iodevice) = 0;
+    virtual void write(QIODevice* iodevice) = 0;
+    virtual qint64 indexOf(const QByteArray& ba, qint64 from) = 0;
+    virtual qint64 lastIndexOf(const QByteArray& ba, qint64 from) = 0;
+};

UEFITool/QHexView/include/QHexView/model/buffer/qmappedfilebuffer.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <QHexView/model/buffer/qdevicebuffer.h>
+
+class QMappedFileBuffer: public QDeviceBuffer {
+public:
+    explicit QMappedFileBuffer(QObject* parent = nullptr);
+    virtual ~QMappedFileBuffer();
+
+public:
+    QByteArray read(qint64 offset, int length) override;
+    bool read(QIODevice* iodevice) override;
+    void write(QIODevice* iodevice) override;
+
+private:
+    void remap();
+
+private:
+    uchar* m_mappeddata{nullptr};
+};

UEFITool/QHexView/include/QHexView/model/buffer/qmemorybuffer.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <QHexView/model/buffer/qhexbuffer.h>
+
+class QMemoryBuffer: public QHexBuffer {
+    Q_OBJECT
+
+public:
+    explicit QMemoryBuffer(QObject* parent = nullptr);
+    uchar at(qint64 idx) override;
+    qint64 length() const override;
+    void insert(qint64 offset, const QByteArray& data) override;
+    void remove(qint64 offset, int length) override;
+    QByteArray read(qint64 offset, int length) override;
+    bool read(QIODevice* device) override;
+    void write(QIODevice* device) override;
+    qint64 indexOf(const QByteArray& ba, qint64 from) override;
+    qint64 lastIndexOf(const QByteArray& ba, qint64 from) override;
+
+private:
+    QByteArray m_buffer;
+};

UEFITool/QHexView/include/QHexView/model/buffer/qmemoryrefbuffer.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <QHexView/model/buffer/qdevicebuffer.h>
+
+class QMemoryRefBuffer: public QDeviceBuffer {
+    Q_OBJECT
+
+public:
+    explicit QMemoryRefBuffer(QObject* parent = nullptr);
+    bool read(QIODevice* device) override;
+    void write(QIODevice* device) override;
+};

UEFITool/QHexView/include/QHexView/model/commands/hexcommand.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <QHexView/model/buffer/qhexbuffer.h>
+#include <QUndoCommand>
+
+class QHexDocument;
+
+class HexCommand: public QUndoCommand {
+public:
+    HexCommand(QHexBuffer* buffer, QHexDocument* document,
+               QUndoCommand* parent = nullptr);
+
+protected:
+    QHexDocument* m_hexdocument;
+    QHexBuffer* m_buffer;
+    qint64 m_offset;
+    int m_length;
+    QByteArray m_data;
+};

UEFITool/QHexView/include/QHexView/model/commands/insertcommand.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <QHexView/model/commands/hexcommand.h>
+
+class InsertCommand: public HexCommand {
+public:
+    InsertCommand(QHexBuffer* buffer, QHexDocument* document, qint64 offset,
+                  const QByteArray& data, QUndoCommand* parent = nullptr);
+    void undo() override;
+    void redo() override;
+};

UEFITool/QHexView/include/QHexView/model/commands/removecommand.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <QHexView/model/commands/hexcommand.h>
+
+class RemoveCommand: public HexCommand {
+public:
+    RemoveCommand(QHexBuffer* buffer, QHexDocument* document, qint64 offset,
+                  int length, QUndoCommand* parent = nullptr);
+    void undo() override;
+    void redo() override;
+};

UEFITool/QHexView/include/QHexView/model/commands/replacecommand.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <QHexView/model/commands/hexcommand.h>
+
+class ReplaceCommand: public HexCommand {
+public:
+    ReplaceCommand(QHexBuffer* buffer, QHexDocument* document, qint64 offset,
+                   const QByteArray& data, QUndoCommand* parent = nullptr);
+    void undo() override;
+    void redo() override;
+
+private:
+    QByteArray m_olddata;
+};

UEFITool/QHexView/include/QHexView/model/qhexcursor.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <QHexView/model/qhexoptions.h>
+#include <QHexView/model/qhexutils.h>
+#include <QObject>
+
+class QHexView;
+
+class QHexCursor: public QObject {
+    Q_OBJECT
+
+public:
+    enum class Mode { Overwrite, Insert };
+
+private:
+    explicit QHexCursor(const QHexOptions* options, QHexView* parent = nullptr);
+
+public:
+    QHexView* hexView() const;
+    Mode mode() const;
+    qint64 line() const;
+    qint64 column() const;
+    qint64 offset() const;
+    qint64 address() const;
+    quint64 lineAddress() const;
+    qint64 selectionStartOffset() const;
+    qint64 selectionEndOffset() const;
+    qint64 selectionLength() const;
+    QHexPosition position() const;
+    QHexPosition selectionStart() const;
+    QHexPosition selectionEnd() const;
+    QByteArray selectedBytes() const;
+    bool hasSelection() const;
+    bool isSelected(qint64 line, qint64 column) const;
+    void setMode(Mode m);
+    void move(qint64 offset);
+    void move(qint64 line, qint64 column);
+    void move(QHexPosition pos);
+    void select(qint64 offset);
+    void select(qint64 line, qint64 column);
+    void select(QHexPosition pos);
+    void selectSize(qint64 length);
+    qint64 replace(const QVariant& oldvalue, const QVariant& newvalue,
+                   qint64 offset, QHexFindMode mode = QHexFindMode::Text,
+                   unsigned int options = QHexFindOptions::None,
+                   QHexFindDirection fd = QHexFindDirection::Forward) const;
+    qint64 find(const QVariant& value, qint64 offset,
+                QHexFindMode mode = QHexFindMode::Text,
+                unsigned int options = QHexFindOptions::None,
+                QHexFindDirection fd = QHexFindDirection::Forward) const;
+    qint64 positionToOffset(QHexPosition pos) const;
+    QHexPosition offsetToPosition(qint64 offset) const;
+
+public Q_SLOTS:
+    void cut(bool hex = false);
+    void copy(bool hex = false) const;
+    void paste(bool hex = false);
+    void selectAll();
+    void removeSelection();
+    void clearSelection();
+    void switchMode();
+
+Q_SIGNALS:
+    void positionChanged();
+    void modeChanged();
+
+private:
+    const QHexOptions* m_options;
+    Mode m_mode{Mode::Overwrite};
+    QHexPosition m_position{}, m_selection{};
+
+    friend class QHexView;
+};

UEFITool/QHexView/include/QHexView/model/qhexdelegate.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <QHexView/model/qhexutils.h>
+#include <QObject>
+#include <QTextCharFormat>
+
+class QHexView;
+
+class QHexDelegate: public QObject {
+    Q_OBJECT
+
+public:
+    explicit QHexDelegate(QObject* parent = nullptr);
+    virtual ~QHexDelegate() = default;
+    virtual QString addressHeader(const QHexView* hexview) const;
+    virtual QString hexHeader(const QHexView* hexview) const;
+    virtual QString asciiHeader(const QHexView* hexview) const;
+    virtual void renderAddress(quint64 address, QTextCharFormat& cf,
+                               const QHexView* hexview) const;
+    virtual void renderHeader(QTextBlockFormat& bf,
+                              const QHexView* hexview) const;
+    virtual void renderHeaderPart(const QString& s, QHexArea area,
+                                  QTextCharFormat& cf,
+                                  const QHexView* hexview) const;
+    virtual bool render(quint64 offset, quint8 b, QTextCharFormat& outcf,
+                        const QHexView* hexview) const;
+    virtual bool paintSeparator(QPainter* painter, QLineF line,
+                                const QHexView* hexview) const;
+    virtual void paint(QPainter* painter, const QHexView* hexview) const;
+};

UEFITool/QHexView/include/QHexView/model/qhexdocument.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <QHexView/model/buffer/qhexbuffer.h>
+#include <QHexView/model/qhexmetadata.h>
+#include <QUndoStack>
+
+class QHexCursor;
+
+class QHexDocument: public QObject {
+    Q_OBJECT
+
+public:
+    enum class ChangeReason { Insert, Remove, Replace };
+    enum class FindDirection { Forward, Backward };
+    Q_ENUM(ChangeReason);
+    Q_ENUM(FindDirection);
+
+private:
+    explicit QHexDocument(QHexBuffer* buffer, QObject* parent = nullptr);
+    bool accept(qint64 idx) const;
+
+public:
+    bool isEmpty() const;
+    bool isModified() const;
+    bool canUndo() const;
+    bool canRedo() const;
+    void setData(const QByteArray& ba);
+    void setData(QHexBuffer* buffer);
+    qint64 length() const;
+    qint64 indexOf(const QByteArray& ba, qint64 from = 0);
+    qint64 lastIndexOf(const QByteArray& ba, qint64 from = 0);
+    QByteArray read(qint64 offset, int len = 0) const;
+    uchar at(int offset) const;
+
+public Q_SLOTS:
+    void clearModified();
+    void undo();
+    void redo();
+    void insert(qint64 offset, uchar b);
+    void replace(qint64 offset, uchar b);
+    void insert(qint64 offset, const QByteArray& data);
+    void replace(qint64 offset, const QByteArray& data);
+    void remove(qint64 offset, int len);
+    bool saveTo(QIODevice* device);
+
+public:
+    template<typename T, bool Owned = true>
+    static QHexDocument* fromDevice(QIODevice* iodevice,
+                                    QObject* parent = nullptr);
+    template<typename T>
+    static QHexDocument* fromMemory(char* data, int size,
+                                    QObject* parent = nullptr);
+    template<typename T>
+    static QHexDocument* fromMemory(const QByteArray& ba,
+                                    QObject* parent = nullptr);
+    static QHexDocument* fromBuffer(QHexBuffer* buffer,
+                                    QObject* parent = nullptr);
+    static QHexDocument* fromLargeFile(QString filename,
+                                       QObject* parent = nullptr);
+    static QHexDocument* fromMappedFile(QString filename,
+                                        QObject* parent = nullptr);
+    static QHexDocument* fromFile(QString filename, QObject* parent = nullptr);
+    static QHexDocument* create(QObject* parent = nullptr);
+
+Q_SIGNALS:
+    void modifiedChanged(bool modified);
+    void canUndoChanged(bool canundo);
+    void canRedoChanged(bool canredo);
+    void dataChanged(const QByteArray& data, quint64 offset,
+                     QHexDocument::ChangeReason reason);
+    void changed();
+    void reset();
+
+private:
+    QHexBuffer* m_buffer;
+    QUndoStack m_undostack;
+
+    friend class QHexView;
+};
+
+template<typename T, bool Owned>
+QHexDocument* QHexDocument::fromDevice(QIODevice* iodevice, QObject* parent) {
+    QHexBuffer* hexbuffer = new T(parent);
+    if(Owned)
+        iodevice->setParent(hexbuffer);
+    return hexbuffer->read(iodevice) ? new QHexDocument(hexbuffer, parent)
+                                     : nullptr;
+}
+
+template<typename T>
+QHexDocument* QHexDocument::fromMemory(char* data, int size, QObject* parent) {
+    QHexBuffer* hexbuffer = new T();
+    hexbuffer->read(data, size);
+    return new QHexDocument(hexbuffer, parent);
+}
+
+template<typename T>
+QHexDocument* QHexDocument::fromMemory(const QByteArray& ba, QObject* parent) {
+    QHexBuffer* hexbuffer = new T();
+    hexbuffer->read(ba);
+    return new QHexDocument(hexbuffer, parent);
+}

UEFITool/QHexView/include/QHexView/model/qhexmetadata.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <QColor>
+#include <QHash>
+#include <QHexView/model/qhexoptions.h>
+#include <QList>
+#include <QObject>
+#include <functional>
+
+struct QHexMetadataItem {
+    qint64 begin, end;
+    QColor foreground, background;
+    QString comment;
+};
+
+using QHexMetadataLine = QList<QHexMetadataItem>;
+
+class QHexMetadata: public QObject {
+    Q_OBJECT
+
+private:
+    using ClearMetadataCallback = std::function<bool(QHexMetadataItem&)>;
+
+private:
+    explicit QHexMetadata(const QHexOptions* options,
+                          QObject* parent = nullptr);
+
+public:
+    const QHexMetadataLine* find(qint64 line) const;
+    QString getComment(qint64 line, qint64 column) const;
+    void removeMetadata(qint64 line);
+    void removeBackground(qint64 line);
+    void removeForeground(qint64 line);
+    void removeComments(qint64 line);
+    void unhighlight(qint64 line);
+    void clear();
+
+public:
+    inline void setMetadata(qint64 begin, qint64 end, const QColor& fgcolor,
+                            const QColor& bgcolor, const QString& comment) {
+        this->setMetadata({begin, end, fgcolor, bgcolor, comment});
+    }
+
+    inline void setForeground(qint64 begin, qint64 end, const QColor& fgcolor) {
+        this->setMetadata(begin, end, fgcolor, QColor(), QString());
+    }
+
+    inline void setBackground(qint64 begin, qint64 end, const QColor& bgcolor) {
+        this->setMetadata(begin, end, QColor(), bgcolor, QString());
+    }
+
+    inline void setComment(qint64 begin, qint64 end, const QString& comment) {
+        this->setMetadata(begin, end, QColor(), QColor(), comment);
+    };
+
+    inline void setMetadataSize(qint64 begin, qint64 length,
+                                const QColor& fgcolor, const QColor& bgcolor,
+                                const QString& comment) {
+        this->setMetadata({begin, begin + length, fgcolor, bgcolor, comment});
+    }
+
+    inline void setForegroundSize(qint64 begin, qint64 length,
+                                  const QColor& fgcolor) {
+        this->setForeground(begin, begin + length, fgcolor);
+    }
+
+    inline void setBackgroundSize(qint64 begin, qint64 length,
+                                  const QColor& bgcolor) {
+        this->setBackground(begin, begin + length, bgcolor);
+    }
+
+    inline void setCommentSize(qint64 begin, qint64 length,
+                               const QString& comment) {
+        this->setComment(begin, begin + length, comment);
+    };
+
+private:
+    void copy(const QHexMetadata* metadata);
+    void clearMetadata(qint64 line, ClearMetadataCallback&& cb);
+    void setMetadata(const QHexMetadataItem& mi);
+    void invalidate();
+
+Q_SIGNALS:
+    void changed();
+    void cleared();
+
+private:
+    QHash<qint64, QHexMetadataLine> m_metadata;
+    const QHexOptions* m_options;
+
+    friend class QHexView;
+};

UEFITool/QHexView/include/QHexView/model/qhexoptions.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <QChar>
+#include <QColor>
+#include <QHash>
+
+namespace QHexFlags {
+
+enum : unsigned int {
+    None = (1 << 0),
+    HSeparator = (1 << 1),
+    VSeparator = (1 << 2),
+    StyledHeader = (1 << 3),
+    StyledAddress = (1 << 4),
+    NoHeader = (1 << 5),
+    HighlightAddress = (1 << 6),
+    HighlightColumn = (1 << 7),
+
+    Separators = HSeparator | VSeparator,
+    Styled = StyledHeader | StyledAddress,
+};
+
+}
+
+struct QHexColor {
+    QColor foreground;
+    QColor background;
+};
+
+struct QHexOptions {
+    // Appearance
+    QChar unprintablechar{'.'};
+    QChar invalidchar{'?'};
+    QString addresslabel{""};
+    QString hexlabel;
+    QString asciilabel;
+    quint64 baseaddress{0};
+    unsigned int flags{QHexFlags::None};
+    unsigned int linelength{0x10};
+    unsigned int addresswidth{0};
+    unsigned int grouplength{1};
+    int scrollsteps{1};
+
+    // Colors & Styles
+    QHash<quint8, QHexColor> bytecolors;
+    QColor linealternatebackground;
+    QColor linebackground;
+    QColor headercolor;
+    QColor commentcolor;
+    QColor separatorcolor;
+
+    // Misc
+    bool copybreak{true};
+
+    inline bool hasFlag(unsigned int flag) const { return flags & flag; }
+};

UEFITool/QHexView/include/QHexView/model/qhexutils.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <QByteArray>
+#include <QPair>
+#include <QString>
+#include <QVariant>
+
+struct QHexOptions;
+class QHexView;
+
+namespace QHexFindOptions {
+
+enum : unsigned int {
+    None = (1 << 0),
+    CaseSensitive = (1 << 1),
+    Int8 = (1 << 2),
+    Int16 = (1 << 3),
+    Int32 = (1 << 4),
+    Int64 = (1 << 5),
+    Float = (1 << 6),
+    Double = (1 << 7),
+
+    BigEndian = (1 << 11),
+};
+
+}
+
+enum class QHexFindMode { Text, Hex, Int, Float };
+enum class QHexFindDirection { All, Forward, Backward };
+enum class QHexArea { Header, Address, Hex, Ascii, Extra };
+
+struct QHexPosition {
+    qint64 line;
+    qint64 column;
+    static inline QHexPosition invalid() { return {-1, -1}; }
+    inline bool isValid() const { return line >= 0 && column >= 0; }
+    inline bool operator==(const QHexPosition& rhs) const {
+        return (line == rhs.line) && (column == rhs.column);
+    }
+    inline bool operator!=(const QHexPosition& rhs) const {
+        return (line != rhs.line) || (column != rhs.column);
+    }
+};
+
+namespace QHexUtils {
+
+bool isHex(char ch);
+QByteArray toHex(const QByteArray& ba, char sep);
+QByteArray toHex(const QByteArray& ba);
+qint64 positionToOffset(const QHexOptions* options, QHexPosition pos);
+QHexPosition offsetToPosition(const QHexOptions* options, qint64 offset);
+bool checkPattern(QString pattern);
+
+QPair<qint64, qint64> find(const QHexView* hexview, QVariant value,
+                           qint64 startoffset = 0,
+                           QHexFindMode mode = QHexFindMode::Text,
+                           unsigned int options = QHexFindOptions::None,
+                           QHexFindDirection fd = QHexFindDirection::Forward);
+
+QPair<qint64, qint64>
+replace(const QHexView* hexview, QVariant oldvalue, QVariant newvalue,
+        qint64 startoffset = 0, QHexFindMode mode = QHexFindMode::Text,
+        unsigned int options = QHexFindOptions::None,
+        QHexFindDirection fd = QHexFindDirection::Forward);
+
+} // namespace QHexUtils

UEFITool/QHexView/include/QHexView/qhexview.h

@@ -0,0 +1,184 @@
+#pragma once
+
+#define QHEXVIEW_VERSION 5.0
+
+#include <QAbstractScrollArea>
+#include <QFontMetricsF>
+#include <QHexView/model/qhexcursor.h>
+#include <QHexView/model/qhexdelegate.h>
+#include <QHexView/model/qhexdocument.h>
+#include <QList>
+#include <QRectF>
+#include <QTextCharFormat>
+
+#if defined(QHEXVIEW_ENABLE_DIALOGS)
+class HexFindDialog;
+#endif
+
+class QHexView: public QAbstractScrollArea {
+    Q_OBJECT
+
+public:
+    enum class CopyMode { Visual, HexArraySquare, HexArrayCurly, HexArrayChar };
+    Q_ENUM(CopyMode);
+
+public:
+    explicit QHexView(QWidget* parent = nullptr);
+    QRectF headerRect() const;
+    QRectF addressRect() const;
+    QRectF hexRect() const;
+    QRectF asciiRect() const;
+    QHexDocument* hexDocument() const;
+    QHexCursor* hexCursor() const;
+    const QHexMetadata* hexMetadata() const;
+    QHexOptions options() const;
+    QColor getReadableColor(QColor c) const;
+    QByteArray selectedBytes() const;
+    QByteArray getLine(qint64 line) const;
+    unsigned int addressWidth() const;
+    unsigned int lineLength() const;
+    bool isModified() const;
+    bool canUndo() const;
+    bool canRedo() const;
+    quint64 offset() const;
+    quint64 address() const;
+    QHexPosition positionFromOffset(quint64 offset) const;
+    QHexPosition positionFromAddress(quint64 address) const;
+    QHexPosition position() const;
+    QHexPosition selectionStart() const;
+    QHexPosition selectionEnd() const;
+    quint64 selectionStartOffset() const;
+    quint64 selectionEndOffset() const;
+    quint64 baseAddress() const;
+    quint64 lines() const;
+    qint64 replace(const QVariant& oldvalue, const QVariant& newvalue,
+                   qint64 offset, QHexFindMode mode = QHexFindMode::Text,
+                   unsigned int options = QHexFindOptions::None,
+                   QHexFindDirection fd = QHexFindDirection::Forward) const;
+    qint64 find(const QVariant& value, qint64 offset,
+                QHexFindMode mode = QHexFindMode::Text,
+                unsigned int options = QHexFindOptions::None,
+                QHexFindDirection fd = QHexFindDirection::Forward) const;
+    void setOptions(const QHexOptions& options);
+    void setBaseAddress(quint64 baseaddress);
+    void setDelegate(QHexDelegate* rd);
+    void setDocument(QHexDocument* doc);
+    void setData(const QByteArray& ba);
+    void setData(QHexBuffer* buffer);
+    void setCursorMode(QHexCursor::Mode mode);
+    void setByteColor(quint8 b, QHexColor c);
+    void setByteForeground(quint8 b, QColor c);
+    void setByteBackground(quint8 b, QColor c);
+    void setMetadata(qint64 begin, qint64 end, const QColor& fgcolor,
+                     const QColor& bgcolor, const QString& comment);
+    void setForeground(qint64 begin, qint64 end, const QColor& fgcolor);
+    void setBackground(qint64 begin, qint64 end, const QColor& bgcolor);
+    void setComment(qint64 begin, qint64 end, const QString& comment);
+    void setMetadataSize(qint64 begin, qint64 length, const QColor& fgcolor,
+                         const QColor& bgcolor, const QString& comment);
+    void setForegroundSize(qint64 begin, qint64 length, const QColor& fgcolor);
+    void setBackgroundSize(qint64 begin, qint64 length, const QColor& bgcolor);
+    void setCommentSize(qint64 begin, qint64 length, const QString& comment);
+    void removeMetadata(qint64 line);
+    void removeBackground(qint64 line);
+    void removeForeground(qint64 line);
+    void removeComments(qint64 line);
+    void unhighlight(qint64 line);
+    void clearMetadata();
+
+public Q_SLOTS:
+#if defined(QHEXVIEW_ENABLE_DIALOGS)
+    void showFind();
+    void showReplace();
+#endif
+    void undo();
+    void redo();
+    void cut(bool hex = false);
+    void copyAs(CopyMode mode = CopyMode::Visual) const;
+    void copy(bool hex = false) const;
+    void paste(bool hex = false);
+    void clearModified();
+    void selectAll();
+    void removeSelection();
+    void switchMode();
+    void setAddressWidth(unsigned int w);
+    void setLineLength(unsigned int l);
+    void setGroupLength(unsigned int l);
+    void setScrollSteps(int scrollsteps);
+    void setReadOnly(bool r);
+    void setAutoWidth(bool r);
+
+private:
+    void paint(QPainter* painter) const;
+    void checkOptions();
+    void checkState();
+    void checkAndUpdate(bool calccolumns = false);
+    void calcColumns();
+    void ensureVisible();
+    void drawSeparators(QPainter* p) const;
+    void drawHeader(QTextCursor& c) const;
+    void drawDocument(QTextCursor& c) const;
+    QTextCharFormat drawFormat(QTextCursor& c, quint8 b, const QString& s,
+                               QHexArea area, qint64 line, qint64 column,
+                               bool applyformat) const;
+    unsigned int calcAddressWidth() const;
+    int visibleLines(bool absolute = false) const;
+    qint64 getLastColumn(qint64 line) const;
+    qint64 lastLine() const;
+    qreal getNCellsWidth(int n) const;
+    qreal hexColumnWidth() const;
+    qreal hexColumnX() const;
+    qreal asciiColumnX() const;
+    qreal endColumnX() const;
+    qreal cellWidth() const;
+    qreal lineHeight() const;
+    qint64 positionFromLineCol(qint64 line, qint64 col) const;
+    QHexPosition positionFromPoint(QPoint pt) const;
+    QPoint absolutePoint(QPoint pt) const;
+    QHexArea areaFromPoint(QPoint pt) const;
+    void moveNext(bool select = false);
+    void movePrevious(bool select = false);
+    bool keyPressMove(QKeyEvent* e);
+    bool keyPressTextInput(QKeyEvent* e);
+    bool keyPressAction(QKeyEvent* e);
+
+protected:
+    bool event(QEvent* e) override;
+    void showEvent(QShowEvent* e) override;
+    void paintEvent(QPaintEvent*) override;
+    void resizeEvent(QResizeEvent* e) override;
+    void focusInEvent(QFocusEvent* e) override;
+    void focusOutEvent(QFocusEvent* e) override;
+    void mousePressEvent(QMouseEvent* e) override;
+    void mouseMoveEvent(QMouseEvent* e) override;
+    void wheelEvent(QWheelEvent* e) override;
+    void keyPressEvent(QKeyEvent* e) override;
+
+private:
+    static QString reduced(const QString& s, int maxlen);
+    static bool isColorLight(QColor c);
+
+Q_SIGNALS:
+    void dataChanged(const QByteArray& data, quint64 offset,
+                     QHexDocument::ChangeReason reason);
+    void modifiedChanged(bool modified);
+    void positionChanged();
+    void modeChanged();
+
+private:
+    bool m_readonly{false}, m_writing{false}, m_autowidth{false};
+    QHexArea m_currentarea{QHexArea::Ascii};
+    QList<QRectF> m_hexcolumns;
+    QFontMetricsF m_fontmetrics;
+    QHexOptions m_options;
+    QHexCursor* m_hexcursor{nullptr};
+    QHexDocument* m_hexdocument{nullptr};
+    QHexMetadata* m_hexmetadata{nullptr};
+    QHexDelegate* m_hexdelegate{nullptr};
+#if defined(QHEXVIEW_ENABLE_DIALOGS)
+    HexFindDialog *m_hexdlgfind{nullptr}, *m_hexdlgreplace{nullptr};
+#endif
+
+    friend class QHexDelegate;
+    friend class QHexCursor;
+};

UEFITool/QHexView/src/dialogs/hexfinddialog.cpp

@@ -0,0 +1,418 @@
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDialogButtonBox>
+#include <QGridLayout>
+#include <QGroupBox>
+#include <QHBoxLayout>
+#include <QHexView/dialogs/hexfinddialog.h>
+#include <QHexView/qhexview.h>
+#include <QLabel>
+#include <QLineEdit>
+#include <QList>
+#include <QMessageBox>
+#include <QPair>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QRegularExpression>
+#include <QRegularExpressionValidator>
+#include <QSpacerItem>
+#include <QStackedLayout>
+#include <QVBoxLayout>
+#include <limits>
+
+const QString HexFindDialog::BUTTONBOX = "qhexview_buttonbox";
+const QString HexFindDialog::CBFINDMODE = "qhexview_cbfindmode";
+const QString HexFindDialog::LEFIND = "qhexview_lefind";
+const QString HexFindDialog::LEREPLACE = "qhexview_lereplace";
+const QString HexFindDialog::HLAYOUT = "qhexview_hlayout";
+const QString HexFindDialog::GBOPTIONS = "qhexview_gboptions";
+const QString HexFindDialog::RBALL = "qhexview_rball";
+const QString HexFindDialog::RBFORWARD = "qhexview_rbforward";
+const QString HexFindDialog::RBBACKWARD = "qhexview_rbbackward";
+
+HexFindDialog::HexFindDialog(Type type, QHexView* parent)
+    : QDialog{parent}, m_type{type} {
+    m_hexvalidator = new QRegularExpressionValidator(
+        QRegularExpression{"[0-9A-Fa-f ]+"}, this);
+    m_hexpvalidator = new QRegularExpressionValidator(
+        QRegularExpression{"[0-9A-Fa-f \\?]+"}, this);
+    m_dblvalidator = new QDoubleValidator(this);
+    m_intvalidator = new QIntValidator(this);
+
+    this->setWindowTitle(type == Type::Replace ? tr("Replace...")
+                                               : tr("Find..."));
+
+    auto* vlayout = new QVBoxLayout(this);
+    auto* gridlayout = new QGridLayout();
+
+    auto* cbfindmode = new QComboBox(this);
+    cbfindmode->setObjectName(HexFindDialog::CBFINDMODE);
+    cbfindmode->addItem("Text", static_cast<int>(QHexFindMode::Text));
+    cbfindmode->addItem("Hex", static_cast<int>(QHexFindMode::Hex));
+    cbfindmode->addItem("Int", static_cast<int>(QHexFindMode::Int));
+    cbfindmode->addItem("Float", static_cast<int>(QHexFindMode::Float));
+
+    QLineEdit *lereplace = nullptr, *lefind = new QLineEdit(this);
+    lefind->setObjectName(HexFindDialog::LEFIND);
+
+    gridlayout->addWidget(new QLabel(tr("Mode:"), this), 0, 0, Qt::AlignRight);
+    gridlayout->addWidget(cbfindmode, 0, 1);
+    gridlayout->addWidget(new QLabel(tr("Find:"), this), 1, 0, Qt::AlignRight);
+    gridlayout->addWidget(lefind, 1, 1);
+
+    if(type == Type::Replace) {
+        lereplace = new QLineEdit(this);
+        lereplace->setObjectName(HexFindDialog::LEREPLACE);
+
+        gridlayout->addWidget(new QLabel(tr("Replace:"), this), 2, 0,
+                              Qt::AlignRight);
+        gridlayout->addWidget(lereplace, 2, 1);
+    }
+
+    vlayout->addLayout(gridlayout);
+
+    auto* gboptions = new QGroupBox(this);
+    gboptions->setObjectName(HexFindDialog::GBOPTIONS);
+    gboptions->setTitle(tr("Options"));
+    gboptions->setLayout(new QStackedLayout());
+
+    QGroupBox* gbdirection = new QGroupBox(this);
+    gbdirection->setTitle(tr("Find direction"));
+    auto* gbvlayout = new QVBoxLayout(gbdirection);
+
+    auto* rball = new QRadioButton("All", gbdirection);
+    rball->setObjectName(HexFindDialog::RBALL);
+    auto* rbforward = new QRadioButton("Forward", gbdirection);
+    rbforward->setObjectName(HexFindDialog::RBFORWARD);
+    rbforward->setChecked(true);
+    auto* rbbackward = new QRadioButton("Backward", gbdirection);
+    rbbackward->setObjectName(HexFindDialog::RBBACKWARD);
+
+    gbvlayout->addWidget(rball);
+    gbvlayout->addWidget(rbforward);
+    gbvlayout->addWidget(rbbackward);
+    gbvlayout->addSpacerItem(
+        new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding));
+
+    auto* hlayout = new QHBoxLayout();
+    hlayout->setObjectName(HexFindDialog::HLAYOUT);
+    hlayout->addWidget(gboptions, 1);
+    hlayout->addWidget(gbdirection);
+    vlayout->addLayout(hlayout, 1);
+
+    auto* buttonbox = new QDialogButtonBox(this);
+    buttonbox->setOrientation(Qt::Horizontal);
+
+    if(type == Type::Replace)
+        buttonbox->setStandardButtons(QDialogButtonBox::Ok |
+                                      QDialogButtonBox::Apply |
+                                      QDialogButtonBox::Cancel);
+    else
+        buttonbox->setStandardButtons(QDialogButtonBox::Ok |
+                                      QDialogButtonBox::Cancel);
+
+    buttonbox->setObjectName(HexFindDialog::BUTTONBOX);
+    buttonbox->button(QDialogButtonBox::Ok)->setEnabled(false);
+    buttonbox->button(QDialogButtonBox::Ok)->setText(tr("Find"));
+
+    if(type == Type::Replace) {
+        buttonbox->button(QDialogButtonBox::Apply)->setEnabled(false);
+        buttonbox->button(QDialogButtonBox::Apply)->setText(tr("Replace"));
+    }
+
+    vlayout->addWidget(buttonbox);
+
+    connect(lefind, &QLineEdit::textChanged, this,
+            &HexFindDialog::validateActions);
+    connect(cbfindmode, QOverload<int>::of(&QComboBox::currentIndexChanged),
+            this, &HexFindDialog::updateFindOptions);
+    connect(buttonbox, &QDialogButtonBox::accepted, this, &HexFindDialog::find);
+    connect(buttonbox, &QDialogButtonBox::rejected, this, &QDialog::reject);
+    connect(parent, &QHexView::positionChanged, this,
+            [this]() { m_startoffset = -1; });
+
+    if(lereplace) {
+        connect(buttonbox->button(QDialogButtonBox::Apply),
+                &QPushButton::clicked, this, &HexFindDialog::replace);
+        connect(lereplace, &QLineEdit::textChanged, this,
+                &HexFindDialog::validateActions);
+    }
+
+    this->prepareTextMode(gboptions->layout());
+    this->prepareHexMode(gboptions->layout());
+    this->prepareIntMode(gboptions->layout());
+    this->prepareFloatMode(gboptions->layout());
+    this->updateFindOptions(-1);
+}
+
+QHexView* HexFindDialog::hexView() const {
+    return qobject_cast<QHexView*>(this->parentWidget());
+}
+
+void HexFindDialog::updateFindOptions(int) {
+    QGroupBox* gboptions =
+        this->findChild<QGroupBox*>(HexFindDialog::GBOPTIONS);
+
+    QLineEdit* lefind = this->findChild<QLineEdit*>(HexFindDialog::LEFIND);
+    QLineEdit* lereplace =
+        this->findChild<QLineEdit*>(HexFindDialog::LEREPLACE);
+    lefind->clear();
+    if(lereplace)
+        lereplace->clear();
+
+    bool ok = false;
+    QHexFindMode mode = static_cast<QHexFindMode>(
+        this->findChild<QComboBox*>(HexFindDialog::CBFINDMODE)
+            ->currentData()
+            .toInt(&ok));
+    if(!ok)
+        return;
+
+    m_findoptions = QHexFindOptions::None;
+    m_oldidxbits = m_oldidxendian = -1;
+
+    auto* stack = qobject_cast<QStackedLayout*>(gboptions->layout());
+
+    switch(mode) {
+        case QHexFindMode::Text: {
+            lefind->setValidator(nullptr);
+            if(lereplace)
+                lereplace->setValidator(nullptr);
+
+            stack->setCurrentIndex(0);
+            gboptions->setVisible(true);
+            break;
+        }
+
+        case QHexFindMode::Hex: {
+            lefind->setValidator(m_hexpvalidator);
+            if(lereplace)
+                lereplace->setValidator(m_hexvalidator);
+            stack->setCurrentIndex(1);
+            gboptions->setVisible(false);
+            break;
+        }
+
+        case QHexFindMode::Int: {
+            lefind->setValidator(m_intvalidator);
+            if(lereplace)
+                lereplace->setValidator(m_intvalidator);
+
+            stack->setCurrentIndex(2);
+            gboptions->setVisible(true);
+            break;
+        }
+
+        case QHexFindMode::Float: {
+            lefind->setValidator(m_dblvalidator);
+            if(lereplace)
+                lereplace->setValidator(m_dblvalidator);
+
+            stack->setCurrentIndex(3);
+            gboptions->setVisible(true);
+            break;
+        }
+    }
+}
+
+bool HexFindDialog::validateIntRange(uint v) const {
+    if(m_findoptions & QHexFindOptions::Int8)
+        return !(v > std::numeric_limits<quint8>::max());
+    if(m_findoptions & QHexFindOptions::Int16)
+        return !(v > std::numeric_limits<quint16>::max());
+    if(m_findoptions & QHexFindOptions::Int32)
+        return !(v > std::numeric_limits<quint32>::max());
+    return true;
+}
+
+void HexFindDialog::checkResult(const QString& q, qint64 offset,
+                                QHexFindDirection fd) {
+    if(offset == -1) {
+        QMessageBox::information(this, tr("Not found"),
+                                 tr("Cannot find '%1'").arg(q));
+        return;
+    }
+
+    if(fd == QHexFindDirection::Backward)
+        m_startoffset = this->hexView()->selectionStartOffset() - 1;
+    else
+        m_startoffset = this->hexView()->selectionEndOffset() + 1;
+}
+
+void HexFindDialog::validateActions() {
+    auto mode = static_cast<QHexFindMode>(
+        this->findChild<QComboBox*>(HexFindDialog::CBFINDMODE)
+            ->currentData()
+            .toUInt());
+    auto* lefind = this->findChild<QLineEdit*>(HexFindDialog::LEFIND);
+    auto* lereplace = this->findChild<QLineEdit*>(HexFindDialog::LEREPLACE);
+    auto* buttonbox =
+        this->findChild<QDialogButtonBox*>(HexFindDialog::BUTTONBOX);
+
+    bool findenable = false, replaceenable = false;
+
+    switch(mode) {
+        case QHexFindMode::Hex:
+            findenable = QHexUtils::checkPattern(lefind->text());
+            replaceenable = findenable;
+            break;
+
+        case QHexFindMode::Float: {
+            lefind->text().toFloat(&findenable);
+            if(lereplace && findenable)
+                lereplace->text().toFloat(&replaceenable);
+            break;
+        }
+
+        case QHexFindMode::Int: {
+            auto v = lefind->text().toUInt(&findenable);
+            if(findenable && !this->validateIntRange(v))
+                findenable = false;
+            if(lereplace && findenable)
+                lereplace->text().toUInt(&replaceenable);
+            break;
+        }
+
+        default:
+            findenable = !lefind->text().isEmpty();
+            replaceenable = findenable;
+            break;
+    }
+
+    if(lereplace)
+        buttonbox->button(QDialogButtonBox::Apply)->setEnabled(replaceenable);
+    buttonbox->button(QDialogButtonBox::Ok)->setEnabled(findenable);
+}
+
+void HexFindDialog::replace() {
+    QString q1;
+    QHexFindMode mode;
+    QHexFindDirection fd;
+
+    if(!this->prepareOptions(q1, mode, fd))
+        return;
+
+    QString q2 = this->findChild<QLineEdit*>(HexFindDialog::LEREPLACE)->text();
+    auto offset = this->hexView()->hexCursor()->replace(
+        q1, q2, m_startoffset > -1 ? m_startoffset : this->hexView()->offset(),
+        mode, m_findoptions, fd);
+    this->checkResult(q1, offset, fd);
+}
+
+void HexFindDialog::find() {
+    QString q;
+    QHexFindMode mode;
+    QHexFindDirection fd;
+
+    if(!this->prepareOptions(q, mode, fd))
+        return;
+
+    auto offset = this->hexView()->hexCursor()->find(
+        q, m_startoffset > -1 ? m_startoffset : this->hexView()->offset(), mode,
+        m_findoptions, fd);
+    this->checkResult(q, offset, fd);
+}
+
+bool HexFindDialog::prepareOptions(QString& q, QHexFindMode& mode,
+                                   QHexFindDirection& fd) {
+    q = this->findChild<QLineEdit*>(HexFindDialog::LEFIND)->text();
+    mode = static_cast<QHexFindMode>(
+        this->findChild<QComboBox*>(HexFindDialog::CBFINDMODE)
+            ->currentData()
+            .toUInt());
+
+    if(mode == QHexFindMode::Hex && !QHexUtils::checkPattern(q)) {
+        QMessageBox::warning(this, tr("Pattern Error"),
+                             tr("Hex pattern '%1' is not valid").arg(q));
+        return false;
+    }
+
+    if(this->findChild<QRadioButton*>(HexFindDialog::RBBACKWARD)->isChecked())
+        fd = QHexFindDirection::Backward;
+    else if(this->findChild<QRadioButton*>(HexFindDialog::RBFORWARD)
+                ->isChecked())
+        fd = QHexFindDirection::Forward;
+    else
+        fd = QHexFindDirection::All;
+    return true;
+}
+
+void HexFindDialog::prepareTextMode(QLayout* l) {
+    auto* cbcasesensitive = new QCheckBox("Case sensitive");
+
+    connect(cbcasesensitive, &QCheckBox::stateChanged, this, [this](int state) {
+        if(state == Qt::Checked)
+            m_findoptions |= QHexFindOptions::CaseSensitive;
+        else
+            m_findoptions &= ~QHexFindOptions::CaseSensitive;
+    });
+
+    auto* vlayout = new QVBoxLayout(new QWidget());
+    vlayout->addWidget(cbcasesensitive);
+    l->addWidget(vlayout->parentWidget());
+}
+
+void HexFindDialog::prepareHexMode(QLayout* l) { l->addWidget(new QWidget()); }
+
+void HexFindDialog::prepareIntMode(QLayout* l) {
+    static const QList<QPair<QString, unsigned int>> INT_TYPES = {
+        qMakePair<QString, unsigned int>("(any)", 0),
+        qMakePair<QString, unsigned int>("8", QHexFindOptions::Int8),
+        qMakePair<QString, unsigned int>("16", QHexFindOptions::Int16),
+        qMakePair<QString, unsigned int>("32", QHexFindOptions::Int32),
+        qMakePair<QString, unsigned int>("64", QHexFindOptions::Int64)};
+
+    auto* cbbits = new QComboBox();
+    for(const auto& it : INT_TYPES)
+        cbbits->addItem(it.first, it.second);
+
+    connect(cbbits, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
+            [this, cbbits](int index) {
+                if(m_oldidxbits > -1)
+                    m_findoptions &= ~cbbits->itemData(m_oldidxbits).toUInt();
+                m_findoptions |= cbbits->itemData(index).toUInt();
+                m_oldidxbits = index;
+            });
+
+    auto* cbendian = new QComboBox();
+    cbendian->addItem("Little Endian", 0);
+    cbendian->addItem("Big Endian", QHexFindOptions::BigEndian);
+
+    connect(cbendian, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
+            [this, cbendian](int index) {
+                if(m_oldidxendian > -1)
+                    m_findoptions &=
+                        ~cbendian->itemData(m_oldidxendian).toUInt();
+                m_findoptions |= cbendian->itemData(index).toUInt();
+                m_oldidxendian = index;
+            });
+
+    auto* vlayout = new QVBoxLayout(new QWidget());
+
+    QGridLayout* gl = new QGridLayout();
+    gl->addWidget(new QLabel("Type:"), 0, 0, Qt::AlignRight);
+    gl->addWidget(cbbits, 0, 1);
+    gl->addWidget(new QLabel("Endian:"), 1, 0, Qt::AlignRight);
+    gl->addWidget(cbendian, 1, 1);
+    vlayout->addLayout(gl);
+
+    l->addWidget(vlayout->parentWidget());
+}
+
+void HexFindDialog::prepareFloatMode(QLayout* l) {
+    static const QList<QPair<QString, unsigned int>> FLOAT_TYPES = {
+        qMakePair<QString, unsigned int>("float", QHexFindOptions::Float),
+        qMakePair<QString, unsigned int>("double", QHexFindOptions::Double)};
+
+    bool first = true;
+    auto* vlayout = new QVBoxLayout(new QWidget());
+
+    for(const auto& ft : FLOAT_TYPES) {
+        auto* rb = new QRadioButton(ft.first);
+        rb->setChecked(first);
+        vlayout->addWidget(rb);
+        first = false;
+    }
+
+    l->addWidget(vlayout->parentWidget());
+}

UEFITool/QHexView/src/model/buffer/qdevicebuffer.cpp

@@ -0,0 +1,118 @@
+#include <QHexView/model/buffer/qdevicebuffer.h>
+#include <QIODevice>
+#include <limits>
+
+QDeviceBuffer::QDeviceBuffer(QObject* parent): QHexBuffer{parent} {}
+
+QDeviceBuffer::~QDeviceBuffer() {
+    if(!m_device)
+        return;
+
+    if(m_device->parent() == this) {
+        if(m_device->isOpen())
+            m_device->close();
+        m_device->deleteLater();
+    }
+
+    m_device = nullptr;
+}
+
+uchar QDeviceBuffer::at(qint64 idx) {
+    m_device->seek(idx);
+
+    char c = '\0';
+    m_device->getChar(&c);
+    return static_cast<uchar>(c);
+}
+
+qint64 QDeviceBuffer::length() const { return m_device->size(); }
+
+void QDeviceBuffer::insert(qint64 offset, const QByteArray& data) {
+    Q_UNUSED(offset)
+    Q_UNUSED(data)
+    // Not implemented
+}
+
+void QDeviceBuffer::replace(qint64 offset, const QByteArray& data) {
+    m_device->seek(offset);
+    m_device->write(data);
+}
+
+void QDeviceBuffer::remove(qint64 offset, int length) {
+    Q_UNUSED(offset)
+    Q_UNUSED(length)
+    // Not implemented
+}
+
+QByteArray QDeviceBuffer::read(qint64 offset, int length) {
+    m_device->seek(offset);
+    return m_device->read(length);
+}
+
+bool QDeviceBuffer::read(QIODevice* device) {
+    m_device = device;
+    if(!m_device)
+        return false;
+    if(!m_device->isOpen())
+        m_device->open(QIODevice::ReadWrite);
+    return m_device->isOpen();
+}
+
+void QDeviceBuffer::write(QIODevice* device) {
+    Q_UNUSED(device)
+    // Not implemented
+}
+
+qint64 QDeviceBuffer::indexOf(const QByteArray& ba, qint64 from) {
+    const auto MAX = std::numeric_limits<int>::max();
+    qint64 idx = -1;
+
+    if(from < m_device->size()) {
+        idx = from;
+        m_device->seek(from);
+
+        while(idx < m_device->size()) {
+            QByteArray data = m_device->read(MAX);
+            int sidx = data.indexOf(ba);
+
+            if(sidx >= 0) {
+                idx += sidx;
+                break;
+            }
+
+            if(idx + data.size() >= m_device->size())
+                return -1;
+            m_device->seek(m_device->pos() + data.size() - ba.size());
+        }
+    }
+
+    return idx;
+}
+
+qint64 QDeviceBuffer::lastIndexOf(const QByteArray& ba, qint64 from) {
+    const auto MAX = std::numeric_limits<int>::max();
+    qint64 idx = -1;
+
+    if(from >= 0 && ba.size() < MAX) {
+        qint64 currpos = from;
+
+        while(currpos >= 0) {
+            qint64 readpos = (currpos < MAX) ? 0 : currpos - MAX;
+            m_device->seek(readpos);
+
+            QByteArray data = m_device->read(currpos - readpos);
+            int lidx = data.lastIndexOf(ba, from);
+
+            if(lidx >= 0) {
+                idx = readpos + lidx;
+                break;
+            }
+
+            if(readpos <= 0)
+                break;
+            currpos = readpos + ba.size();
+        }
+    }
+
+    return idx;
+}

UEFITool/QHexView/src/model/buffer/qhexbuffer.cpp

@@ -0,0 +1,36 @@
+#include <QBuffer>
+#include <QHexView/model/buffer/qhexbuffer.h>
+
+QHexBuffer::QHexBuffer(QObject* parent): QObject{parent} {}
+uchar QHexBuffer::at(qint64 idx) { return this->read(idx, 1).at(0); }
+bool QHexBuffer::isEmpty() const { return this->length() <= 0; }
+
+void QHexBuffer::replace(qint64 offset, const QByteArray& data) {
+    this->remove(offset, data.length());
+    this->insert(offset, data);
+}
+
+bool QHexBuffer::accept(qint64 idx) const {
+    Q_UNUSED(idx);
+    return true;
+}
+
+void QHexBuffer::read(char* data, int size) {
+    QBuffer* buffer = new QBuffer(this);
+    buffer->setData(data, size);
+
+    if(!buffer->isOpen())
+        buffer->open(QBuffer::ReadWrite);
+
+    this->read(buffer);
+}
+
+void QHexBuffer::read(const QByteArray& ba) {
+    QBuffer* buffer = new QBuffer(this);
+
+    buffer->setData(ba);
+    if(!buffer->isOpen())
+        buffer->open(QBuffer::ReadWrite);
+
+    this->read(buffer);
+}

UEFITool/QHexView/src/model/buffer/qmappedfilebuffer.cpp

@@ -0,0 +1,51 @@
+#include <QFile>
+#include <QHexView/model/buffer/qmappedfilebuffer.h>
+
+QMappedFileBuffer::QMappedFileBuffer(QObject* parent): QDeviceBuffer{parent} {}
+
+QMappedFileBuffer::~QMappedFileBuffer() {
+    if((m_device && (m_device->parent() == this)) && m_mappeddata) {
+        QFile* f = qobject_cast<QFile*>(m_device);
+        f->unmap(m_mappeddata);
+    }
+
+    m_mappeddata = nullptr;
+}
+
+QByteArray QMappedFileBuffer::read(qint64 offset, int length) {
+    if(offset >= this->length())
+        return {};
+
+    if(offset + length >= this->length())
+        length = this->length() - offset;
+
+    return QByteArray::fromRawData(
+        reinterpret_cast<const char*>(m_mappeddata + offset), length);
+}
+
+bool QMappedFileBuffer::read(QIODevice* iodevice) {
+    m_device = qobject_cast<QFile*>(iodevice);
+    if(!m_device || !QDeviceBuffer::read(iodevice))
+        return false;
+
+    this->remap();
+    return m_mappeddata;
+}
+
+void QMappedFileBuffer::write(QIODevice* iodevice) {
+    if(iodevice == m_device)
+        this->remap();
+    else
+        iodevice->write(reinterpret_cast<const char*>(m_mappeddata),
+                        m_device->size());
+}
+
+void QMappedFileBuffer::remap() {
+    QFile* f = qobject_cast<QFile*>(m_device);
+    if(!f)
+        return;
+
+    if(m_mappeddata)
+        f->unmap(m_mappeddata);
+    m_mappeddata = f->map(0, f->size());
+}

UEFITool/QHexView/src/model/buffer/qmemorybuffer.cpp

@@ -0,0 +1,39 @@
+#include <QHexView/model/buffer/qmemorybuffer.h>
+#include <QIODevice>
+
+QMemoryBuffer::QMemoryBuffer(QObject* parent): QHexBuffer{parent} {}
+
+uchar QMemoryBuffer::at(qint64 idx) {
+    return static_cast<uchar>(m_buffer.at(idx));
+}
+
+qint64 QMemoryBuffer::length() const {
+    return static_cast<qint64>(m_buffer.length());
+}
+
+void QMemoryBuffer::insert(qint64 offset, const QByteArray& data) {
+    m_buffer.insert(static_cast<int>(offset), data);
+}
+
+void QMemoryBuffer::remove(qint64 offset, int length) {
+    m_buffer.remove(static_cast<int>(offset), length);
+}
+
+QByteArray QMemoryBuffer::read(qint64 offset, int length) {
+    return m_buffer.mid(static_cast<int>(offset), length);
+}
+
+bool QMemoryBuffer::read(QIODevice* device) {
+    m_buffer = device->readAll();
+    return true;
+}
+
+void QMemoryBuffer::write(QIODevice* device) { device->write(m_buffer); }
+
+qint64 QMemoryBuffer::indexOf(const QByteArray& ba, qint64 from) {
+    return m_buffer.indexOf(ba, static_cast<int>(from));
+}
+
+qint64 QMemoryBuffer::lastIndexOf(const QByteArray& ba, qint64 from) {
+    return m_buffer.lastIndexOf(ba, static_cast<int>(from));
+}

UEFITool/QHexView/src/model/buffer/qmemoryrefbuffer.cpp

@@ -0,0 +1,26 @@
+#include <QBuffer>
+#include <QHexView/model/buffer/qmemoryrefbuffer.h>
+
+QMemoryRefBuffer::QMemoryRefBuffer(QObject* parent): QDeviceBuffer{parent} {}
+
+bool QMemoryRefBuffer::read(QIODevice* device) {
+    m_device = qobject_cast<QBuffer*>(device);
+
+    if(m_device) {
+        m_device->setParent(this);
+        return QDeviceBuffer::read(device);
+    }
+
+    return false;
+}
+
+void QMemoryRefBuffer::write(QIODevice* device) {
+    if(!m_device || m_device == device)
+        return;
+
+    static const int CHUNK_SIZE = 4096;
+    m_device->seek(0);
+
+    while(!m_device->atEnd())
+        device->write(m_device->read(CHUNK_SIZE));
+}

UEFITool/QHexView/src/model/commands/hexcommand.cpp

@@ -0,0 +1,6 @@
+#include <QHexView/model/commands/hexcommand.h>
+
+HexCommand::HexCommand(QHexBuffer* buffer, QHexDocument* document,
+                       QUndoCommand* parent)
+    : QUndoCommand(parent), m_hexdocument(document), m_buffer(buffer),
+      m_offset(0), m_length(0) {}

UEFITool/QHexView/src/model/commands/insertcommand.cpp

@@ -0,0 +1,18 @@
+#include <QHexView/model/commands/insertcommand.h>
+#include <QHexView/model/qhexdocument.h>
+
+InsertCommand::InsertCommand(QHexBuffer* buffer, QHexDocument* document,
+                             qint64 offset, const QByteArray& data,
+                             QUndoCommand* parent)
+    : HexCommand(buffer, document, parent) {
+    m_offset = offset;
+    m_data = data;
+}
+
+void InsertCommand::undo() {
+    m_buffer->remove(m_offset, m_data.length());
+    Q_EMIT m_hexdocument->dataChanged(m_data, m_offset,
+                                      QHexDocument::ChangeReason::Remove);
+}
+
+void InsertCommand::redo() { m_buffer->insert(m_offset, m_data); }

UEFITool/QHexView/src/model/commands/removecommand.cpp

@@ -0,0 +1,20 @@
+#include <QHexView/model/commands/removecommand.h>
+#include <QHexView/model/qhexdocument.h>
+
+RemoveCommand::RemoveCommand(QHexBuffer* buffer, QHexDocument* document,
+                             qint64 offset, int length, QUndoCommand* parent)
+    : HexCommand(buffer, document, parent) {
+    m_offset = offset;
+    m_length = length;
+}
+
+void RemoveCommand::undo() {
+    m_buffer->insert(m_offset, m_data);
+    Q_EMIT m_hexdocument->dataChanged(m_data, m_offset,
+                                      QHexDocument::ChangeReason::Insert);
+}
+
+void RemoveCommand::redo() {
+    m_data = m_buffer->read(m_offset, m_length); // Backup data
+    m_buffer->remove(m_offset, m_length);
+}

UEFITool/QHexView/src/model/commands/replacecommand.cpp

@@ -0,0 +1,21 @@
+#include <QHexView/model/commands/replacecommand.h>
+#include <QHexView/model/qhexdocument.h>
+
+ReplaceCommand::ReplaceCommand(QHexBuffer* buffer, QHexDocument* document,
+                               qint64 offset, const QByteArray& data,
+                               QUndoCommand* parent)
+    : HexCommand(buffer, document, parent) {
+    m_offset = offset;
+    m_data = data;
+}
+
+void ReplaceCommand::undo() {
+    m_buffer->replace(m_offset, m_olddata);
+    Q_EMIT m_hexdocument->dataChanged(m_olddata, m_offset,
+                                      QHexDocument::ChangeReason::Replace);
+}
+
+void ReplaceCommand::redo() {
+    m_olddata = m_buffer->read(m_offset, m_data.length());
+    m_buffer->replace(m_offset, m_data);
+}

UEFITool/QHexView/src/model/qhexcursor.cpp

@@ -0,0 +1,182 @@
+#include <QHexView/model/qhexcursor.h>
+#include <QHexView/model/qhexdocument.h>
+#include <QHexView/qhexview.h>
+
+/*
+ * https://stackoverflow.com/questions/10803043/inverse-column-row-major-order-transformation
+ *
+ *  If the index is calculated as:
+ *      offset = row + column*NUMROWS
+ *  then the inverse would be:
+ *      row = offset % NUMROWS
+ *      column = offset / NUMROWS
+ *  where % is modulus, and / is integer division.
+ */
+
+QHexCursor::QHexCursor(const QHexOptions* options, QHexView* parent)
+    : QObject(parent), m_options(options) {}
+
+QHexView* QHexCursor::hexView() const {
+    return qobject_cast<QHexView*>(this->parent());
+}
+
+QHexCursor::Mode QHexCursor::mode() const { return m_mode; }
+qint64 QHexCursor::offset() const { return this->positionToOffset(m_position); }
+
+qint64 QHexCursor::address() const {
+    return m_options->baseaddress + this->offset();
+}
+
+quint64 QHexCursor::lineAddress() const {
+    return m_options->baseaddress + (m_position.line * m_options->linelength);
+}
+
+qint64 QHexCursor::selectionStartOffset() const {
+    return this->positionToOffset(this->selectionStart());
+}
+
+qint64 QHexCursor::selectionEndOffset() const {
+    return this->positionToOffset(this->selectionEnd());
+}
+
+qint64 QHexCursor::line() const { return m_position.line; }
+qint64 QHexCursor::column() const { return m_position.column; }
+
+QHexPosition QHexCursor::selectionStart() const {
+    if(m_position.line < m_selection.line)
+        return m_position;
+
+    if(m_position.line == m_selection.line) {
+        if(m_position.column < m_selection.column)
+            return m_position;
+    }
+
+    return m_selection;
+}
+
+QHexPosition QHexCursor::selectionEnd() const {
+    if(m_position.line > m_selection.line)
+        return m_position;
+
+    if(m_position.line == m_selection.line) {
+        if(m_position.column > m_selection.column)
+            return m_position;
+    }
+
+    return m_selection;
+}
+
+qint64 QHexCursor::selectionLength() const {
+    auto selstart = this->selectionStartOffset(),
+         selend = this->selectionEndOffset();
+    return selstart == selend ? 0 : selend - selstart + 1;
+}
+
+QHexPosition QHexCursor::position() const { return m_position; }
+
+QByteArray QHexCursor::selectedBytes() const {
+    return this->hexView()->selectedBytes();
+}
+
+bool QHexCursor::hasSelection() const { return m_position != m_selection; }
+
+bool QHexCursor::isSelected(qint64 line, qint64 column) const {
+    if(!this->hasSelection())
+        return false;
+
+    auto selstart = this->selectionStart(), selend = this->selectionEnd();
+    if(line > selstart.line && line < selend.line)
+        return true;
+    if(line == selstart.line && line == selend.line)
+        return column >= selstart.column && column <= selend.column;
+    if(line == selstart.line)
+        return column >= selstart.column;
+    if(line == selend.line)
+        return column <= selend.column;
+    return false;
+}
+
+void QHexCursor::setMode(Mode m) {
+    if(m_mode == m)
+        return;
+    m_mode = m;
+    Q_EMIT modeChanged();
+}
+
+void QHexCursor::switchMode() {
+    switch(m_mode) {
+        case Mode::Insert: this->setMode(Mode::Overwrite); break;
+        case Mode::Overwrite: this->setMode(Mode::Insert); break;
+    }
+}
+
+void QHexCursor::move(qint64 offset) {
+    this->move(this->offsetToPosition(offset));
+}
+
+void QHexCursor::move(qint64 line, qint64 column) {
+    return this->move({line, column});
+}
+
+void QHexCursor::move(QHexPosition pos) {
+    if(pos.line >= 0)
+        m_selection.line = pos.line;
+    if(pos.column >= 0)
+        m_selection.column = pos.column;
+    this->select(pos);
+}
+
+void QHexCursor::select(qint64 offset) {
+    this->select(this->offsetToPosition(offset));
+}
+
+void QHexCursor::select(qint64 line, qint64 column) {
+    this->select({line, column});
+}
+
+void QHexCursor::select(QHexPosition pos) {
+    if(pos.line >= 0)
+        m_position.line = pos.line;
+    if(pos.column >= 0)
+        m_position.column = pos.column;
+    Q_EMIT positionChanged();
+}
+
+void QHexCursor::selectSize(qint64 length) {
+    if(length > 0)
+        length--;
+    else if(length < 0)
+        length++;
+    if(length)
+        this->select(this->offset() + length);
+}
+
+qint64 QHexCursor::replace(const QVariant& oldvalue, const QVariant& newvalue,
+                           qint64 offset, QHexFindMode mode,
+                           unsigned int options, QHexFindDirection fd) const {
+    return this->hexView()->replace(oldvalue, newvalue, offset, mode, options,
+                                    fd);
+}
+qint64 QHexCursor::find(const QVariant& value, qint64 offset, QHexFindMode mode,
+                        unsigned int options, QHexFindDirection fd) const {
+    return this->hexView()->find(value, offset, mode, options, fd);
+}
+
+void QHexCursor::cut(bool hex) { this->hexView()->cut(hex); }
+void QHexCursor::copy(bool hex) const { this->hexView()->copy(hex); }
+void QHexCursor::paste(bool hex) { this->hexView()->paste(hex); }
+void QHexCursor::selectAll() { this->hexView()->selectAll(); }
+void QHexCursor::removeSelection() { this->hexView()->removeSelection(); }
+
+void QHexCursor::clearSelection() {
+    m_position = m_selection;
+    Q_EMIT positionChanged();
+}
+
+qint64 QHexCursor::positionToOffset(QHexPosition pos) const {
+    return QHexUtils::positionToOffset(m_options, pos);
+}
+
+QHexPosition QHexCursor::offsetToPosition(qint64 offset) const {
+    return QHexUtils::offsetToPosition(m_options, offset);
+}

UEFITool/QHexView/src/model/qhexdelegate.cpp

@@ -0,0 +1,65 @@
+#include <QHexView/model/qhexdelegate.h>
+#include <QHexView/qhexview.h>
+
+QHexDelegate::QHexDelegate(QObject* parent): QObject{parent} {}
+
+QString QHexDelegate::addressHeader(const QHexView* hexview) const {
+    Q_UNUSED(hexview);
+    return QString();
+}
+
+QString QHexDelegate::hexHeader(const QHexView* hexview) const {
+    Q_UNUSED(hexview);
+    return QString();
+}
+
+QString QHexDelegate::asciiHeader(const QHexView* hexview) const {
+    Q_UNUSED(hexview);
+    return QString();
+}
+
+void QHexDelegate::renderAddress(quint64 address, QTextCharFormat& cf,
+                                 const QHexView* hexview) const {
+    Q_UNUSED(address);
+    Q_UNUSED(hexview);
+    Q_UNUSED(cf);
+    Q_UNUSED(hexview);
+}
+
+void QHexDelegate::renderHeader(QTextBlockFormat& bf,
+                                const QHexView* hexview) const {
+    Q_UNUSED(bf);
+    Q_UNUSED(hexview);
+}
+
+void QHexDelegate::renderHeaderPart(const QString& s, QHexArea area,
+                                    QTextCharFormat& cf,
+                                    const QHexView* hexview) const {
+    Q_UNUSED(s);
+    Q_UNUSED(area);
+    Q_UNUSED(cf);
+    Q_UNUSED(hexview);
+}
+
+bool QHexDelegate::render(quint64 offset, quint8 b, QTextCharFormat& outcf,
+                          const QHexView* hexview) const {
+    Q_UNUSED(offset);
+    Q_UNUSED(b);
+    Q_UNUSED(outcf);
+    Q_UNUSED(hexview);
+
+    return false;
+}
+
+bool QHexDelegate::paintSeparator(QPainter* painter, QLineF line,
+                                  const QHexView* hexview) const {
+    Q_UNUSED(painter);
+    Q_UNUSED(line);
+    Q_UNUSED(hexview);
+    return false;
+}
+
+void QHexDelegate::paint(QPainter* painter, const QHexView* hexview) const {
+    Q_UNUSED(hexview);
+    hexview->paint(painter);
+}

UEFITool/QHexView/src/model/qhexdocument.cpp

@@ -0,0 +1,142 @@
+#include <QBuffer>
+#include <QFile>
+#include <QHexView/model/buffer/qdevicebuffer.h>
+#include <QHexView/model/buffer/qmappedfilebuffer.h>
+#include <QHexView/model/buffer/qmemorybuffer.h>
+#include <QHexView/model/commands/insertcommand.h>
+#include <QHexView/model/commands/removecommand.h>
+#include <QHexView/model/commands/replacecommand.h>
+#include <QHexView/model/qhexdocument.h>
+#include <cmath>
+
+QHexDocument::QHexDocument(QHexBuffer* buffer, QObject* parent)
+    : QObject(parent) {
+    m_buffer = buffer;
+    m_buffer->setParent(this); // Take Ownership
+
+    connect(&m_undostack, &QUndoStack::canUndoChanged, this,
+            &QHexDocument::canUndoChanged);
+    connect(&m_undostack, &QUndoStack::canRedoChanged, this,
+            &QHexDocument::canRedoChanged);
+    connect(&m_undostack, &QUndoStack::cleanChanged, this,
+            [&](bool clean) { Q_EMIT modifiedChanged(!clean); });
+}
+
+qint64 QHexDocument::indexOf(const QByteArray& ba, qint64 from) {
+    return m_buffer->indexOf(ba, from);
+}
+
+qint64 QHexDocument::lastIndexOf(const QByteArray& ba, qint64 from) {
+    return m_buffer->lastIndexOf(ba, from);
+}
+
+bool QHexDocument::accept(qint64 idx) const { return m_buffer->accept(idx); }
+bool QHexDocument::isEmpty() const { return m_buffer->isEmpty(); }
+bool QHexDocument::isModified() const { return !m_undostack.isClean(); }
+bool QHexDocument::canUndo() const { return m_undostack.canUndo(); }
+bool QHexDocument::canRedo() const { return m_undostack.canRedo(); }
+
+void QHexDocument::setData(const QByteArray& ba) {
+    QHexBuffer* mb = new QMemoryBuffer();
+    mb->read(ba);
+    this->setData(mb);
+}
+
+void QHexDocument::setData(QHexBuffer* buffer) {
+    if(!buffer)
+        return;
+
+    m_undostack.clear();
+    buffer->setParent(this);
+
+    auto* oldbuffer = m_buffer;
+    m_buffer = buffer;
+    if(oldbuffer)
+        oldbuffer->deleteLater();
+
+    Q_EMIT canUndoChanged(false);
+    Q_EMIT canRedoChanged(false);
+    Q_EMIT changed();
+    Q_EMIT reset();
+}
+
+void QHexDocument::clearModified() { m_undostack.setClean(); }
+
+qint64 QHexDocument::length() const {
+    return m_buffer ? m_buffer->length() : 0;
+}
+
+uchar QHexDocument::at(int offset) const { return m_buffer->at(offset); }
+
+QHexDocument* QHexDocument::fromFile(QString filename, QObject* parent) {
+    QFile f(filename);
+    f.open(QFile::ReadOnly);
+    return QHexDocument::fromMemory<QMemoryBuffer>(f.readAll(), parent);
+}
+
+void QHexDocument::undo() {
+    m_undostack.undo();
+    Q_EMIT changed();
+}
+
+void QHexDocument::redo() {
+    m_undostack.redo();
+    Q_EMIT changed();
+}
+
+void QHexDocument::insert(qint64 offset, uchar b) {
+    this->insert(offset, QByteArray(1, b));
+}
+
+void QHexDocument::replace(qint64 offset, uchar b) {
+    this->replace(offset, QByteArray(1, b));
+}
+
+void QHexDocument::insert(qint64 offset, const QByteArray& data) {
+    m_undostack.push(new InsertCommand(m_buffer, this, offset, data));
+
+    Q_EMIT changed();
+    Q_EMIT dataChanged(data, offset, ChangeReason::Insert);
+}
+
+void QHexDocument::replace(qint64 offset, const QByteArray& data) {
+    m_undostack.push(new ReplaceCommand(m_buffer, this, offset, data));
+    Q_EMIT changed();
+    Q_EMIT dataChanged(data, offset, ChangeReason::Replace);
+}
+
+void QHexDocument::remove(qint64 offset, int len) {
+    QByteArray data = m_buffer->read(offset, len);
+
+    m_undostack.push(new RemoveCommand(m_buffer, this, offset, len));
+    Q_EMIT changed();
+    Q_EMIT dataChanged(data, offset, ChangeReason::Remove);
+}
+
+QByteArray QHexDocument::read(qint64 offset, int len) const {
+    return m_buffer->read(offset, len);
+}
+
+bool QHexDocument::saveTo(QIODevice* device) {
+    if(!device->isWritable())
+        return false;
+    m_buffer->write(device);
+    return true;
+}
+
+QHexDocument* QHexDocument::fromBuffer(QHexBuffer* buffer, QObject* parent) {
+    return new QHexDocument(buffer, parent);
+}
+
+QHexDocument* QHexDocument::fromLargeFile(QString filename, QObject* parent) {
+    return QHexDocument::fromDevice<QDeviceBuffer>(new QFile(filename), parent);
+}
+
+QHexDocument* QHexDocument::fromMappedFile(QString filename, QObject* parent) {
+    return QHexDocument::fromDevice<QMappedFileBuffer>(new QFile(filename),
+                                                       parent);
+}
+
+QHexDocument* QHexDocument::create(QObject* parent) {
+    return QHexDocument::fromMemory<QMemoryBuffer>({}, parent);
+}

UEFITool/QHexView/src/model/qhexmetadata.cpp

@@ -0,0 +1,158 @@
+#include <QHexView/model/qhexcursor.h>
+#include <QHexView/model/qhexmetadata.h>
+
+QHexMetadata::QHexMetadata(const QHexOptions* options, QObject* parent)
+    : QObject(parent), m_options(options) {}
+
+const QHexMetadataLine* QHexMetadata::find(qint64 line) const {
+    auto it = m_metadata.find(line);
+    return it != m_metadata.end() ? std::addressof(it.value()) : nullptr;
+}
+
+QString QHexMetadata::getComment(qint64 line, qint64 column) const {
+    auto* metadataline = this->find(line);
+    if(!metadataline)
+        return QString();
+
+    auto offset = QHexUtils::positionToOffset(m_options, {line, column});
+    QStringList comments;
+
+    for(auto& mi : *metadataline) {
+        if((offset < mi.begin || offset > mi.end) || mi.comment.isEmpty())
+            continue;
+        comments.push_back(mi.comment);
+    }
+
+    return comments.join("\n");
+}
+
+void QHexMetadata::removeMetadata(qint64 line) {
+    auto it = m_metadata.find(line);
+    if(it == m_metadata.end())
+        return;
+
+    m_metadata.erase(it);
+    Q_EMIT changed();
+}
+
+void QHexMetadata::removeBackground(qint64 line) {
+    this->clearMetadata(line, [](QHexMetadataItem& mi) -> bool {
+        if(!mi.background.isValid())
+            return false;
+
+        if(mi.foreground.isValid() || !mi.comment.isEmpty()) {
+            mi.background = QColor();
+            return false;
+        }
+
+        return true;
+    });
+}
+
+void QHexMetadata::removeForeground(qint64 line) {
+    this->clearMetadata(line, [](QHexMetadataItem& mi) -> bool {
+        if(!mi.foreground.isValid())
+            return false;
+
+        if(mi.background.isValid() || !mi.comment.isEmpty()) {
+            mi.foreground = QColor();
+            return false;
+        }
+
+        return true;
+    });
+}
+
+void QHexMetadata::removeComments(qint64 line) {
+    this->clearMetadata(line, [](QHexMetadataItem& mi) -> bool {
+        if(mi.comment.isEmpty())
+            return false;
+
+        if(mi.foreground.isValid() || mi.background.isValid()) {
+            mi.comment.clear();
+            return false;
+        }
+
+        return true;
+    });
+}
+
+void QHexMetadata::unhighlight(qint64 line) {
+    this->clearMetadata(line, [](QHexMetadataItem& mi) -> bool {
+        if(!mi.foreground.isValid() && !mi.background.isValid())
+            return false;
+
+        if(!mi.comment.isEmpty()) {
+            mi.foreground = QColor();
+            mi.background = QColor();
+            return false;
+        }
+
+        return true;
+    });
+}
+
+void QHexMetadata::clear() {
+    m_metadata.clear();
+    Q_EMIT changed();
+}
+
+void QHexMetadata::copy(const QHexMetadata* metadata) {
+    m_metadata = metadata->m_metadata;
+}
+
+void QHexMetadata::clearMetadata(qint64 line, ClearMetadataCallback&& cb) {
+    auto iit = m_metadata.find(line);
+    if(iit == m_metadata.end())
+        return;
+
+    auto oldsize = iit->size();
+
+    for(auto it = iit->begin(); it != iit->end();) {
+        if(cb(*it))
+            it = iit->erase(it);
+        else
+            it++;
+    }
+
+    if(iit->empty()) {
+        this->removeMetadata(line);
+        return;
+    }
+
+    if(oldsize != iit->size())
+        Q_EMIT changed();
+}
+
+void QHexMetadata::setMetadata(const QHexMetadataItem& mi) {
+    if(!m_options->linelength)
+        return;
+
+    const qint64 firstline = mi.begin / m_options->linelength;
+    const qint64 lastline = mi.end / m_options->linelength;
+    bool notify = false;
+
+    for(auto line = firstline; line <= lastline; line++) {
+        auto start = line == firstline ? mi.begin % m_options->linelength : 0;
+        auto length = line == lastline
+                          ? (mi.end % m_options->linelength) - start
+                          : m_options->linelength;
+        if(length <= 0)
+            continue;
+
+        notify = true;
+        m_metadata[line].push_back(mi);
+    }
+
+    if(notify)
+        Q_EMIT changed();
+}
+
+void QHexMetadata::invalidate() {
+    auto oldmetadata = m_metadata;
+    m_metadata.clear();
+
+    for(const QHexMetadataLine& line : oldmetadata)
+        for(const QHexMetadataItem& mi : line)
+            this->setMetadata(mi);
+}

UEFITool/QHexView/src/model/qhexutils.cpp

@@ -0,0 +1,384 @@
+#include <QDataStream>
+#include <QGlobalStatic>
+#include <QHash>
+#include <QHexView/model/qhexoptions.h>
+#include <QHexView/model/qhexutils.h>
+#include <QHexView/qhexview.h>
+#include <QList>
+#include <QtEndian>
+#include <limits>
+
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+#define QHEXVIEW_VARIANT_EQ(x, t) ((x).metaType().id() == QMetaType::Q##t)
+#else
+#define QHEXVIEW_VARIANT_EQ(x, t) ((x).type() == QVariant::t)
+#endif
+
+#if defined(_WIN32) && _MSC_VER <= 1916 // v141_xp
+#include <ctype.h>
+namespace std {
+using ::tolower;
+}
+#else
+#include <cctype>
+#endif
+
+namespace QHexUtils {
+
+Q_GLOBAL_STATIC_WITH_ARGS(QList<char>, HEXMAP,
+                          ({'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                            'a', 'b', 'c', 'd', 'e', 'f'}));
+
+bool isHex(char ch) {
+    return (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') ||
+           (ch >= 'a' && ch <= 'f');
+}
+
+namespace PatternUtils {
+
+Q_GLOBAL_STATIC_WITH_ARGS(QString, WILDCARD_BYTE, ("??"))
+
+bool check(QString& p, qint64& len) {
+    static QHash<QString, QPair<QString, size_t>>
+        processed; // Cache processed patterns
+
+    auto it = processed.find(p);
+
+    if(it != processed.end()) {
+        p = it.value().first;
+        len = it.value().second;
+        return true;
+    }
+
+    QString op = p; // Store unprocessed pattern
+    p = p.simplified().replace(" ", "");
+    if(p.isEmpty() || (p.size() % 2))
+        return false;
+
+    int wccount = 0;
+
+    for(auto i = 0; i < p.size() - 2; i += 2) {
+        const auto& hexb = p.mid(i, 2);
+
+        if(hexb == *WILDCARD_BYTE) {
+            wccount++;
+            continue;
+        }
+
+        if(!QHexUtils::isHex(hexb.at(0).toLatin1()) ||
+           !QHexUtils::isHex(hexb.at(1).toLatin1()))
+            return false;
+    }
+
+    if(wccount >= p.size())
+        return false;
+    len = p.size() / 2;
+    processed[op] = qMakePair(p, len); // Cache processed pattern
+    return true;
+}
+
+bool match(const QByteArray& data, const QString& pattern) {
+    for(qint64 i = 0, idx = 0; (i <= (pattern.size() - 2)); i += 2, idx++) {
+        if(idx >= data.size())
+            return false;
+
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+        QStringView hexb = QStringView{pattern}.mid(i, 2);
+#else
+        const QStringRef& hexb = pattern.midRef(i, 2);
+#endif
+
+        if(hexb == *WILDCARD_BYTE)
+            continue;
+
+        bool ok = false;
+        auto b = static_cast<char>(hexb.toUInt(&ok, 16));
+        if(!ok || (b != data.at(idx)))
+            return false;
+    }
+
+    return true;
+}
+
+} // namespace PatternUtils
+
+namespace {
+
+unsigned int countBits(uint val) {
+    if(val <= std::numeric_limits<quint8>::max())
+        return QHexFindOptions::Int8;
+    if(val <= std::numeric_limits<quint16>::max())
+        return QHexFindOptions::Int16;
+    if(val <= std::numeric_limits<quint32>::max())
+        return QHexFindOptions::Int32;
+
+    return QHexFindOptions::Int64;
+}
+
+template<typename Function>
+qint64 findIter(qint64 startoffset, QHexFindDirection fd,
+                const QHexView* hexview, Function&& f) {
+    QHexDocument* hexdocument = hexview->hexDocument();
+    qint64 offset = -1;
+
+    QHexFindDirection cfd = fd;
+    if(cfd == QHexFindDirection::All)
+        cfd = QHexFindDirection::Forward;
+
+    qint64 i = startoffset;
+
+    bool restartLoopOnce = true;
+
+    while(offset == -1 &&
+          (cfd == QHexFindDirection::Backward ? (i >= 0)
+                                              : (i < hexdocument->length()))) {
+        if(!f(i, offset))
+            break;
+
+        if(cfd == QHexFindDirection::Backward)
+            i--;
+        else
+            i++;
+
+        if(fd == QHexFindDirection::All && i >= hexdocument->length() &&
+           restartLoopOnce) {
+            i = 0;
+            restartLoopOnce = false;
+        }
+    }
+
+    return offset;
+}
+
+qint64 findDefault(const QByteArray& value, qint64 startoffset,
+                   const QHexView* hexview, unsigned int options,
+                   QHexFindDirection fd) {
+    QHexDocument* hexdocument = hexview->hexDocument();
+    if(value.size() > hexdocument->length())
+        return -1;
+
+    return findIter(
+        startoffset, fd, hexview,
+        [options, value, hexdocument](qint64 idx, qint64& offset) -> bool {
+            for(auto i = 0; i < value.size(); i++) {
+                qint64 curroffset = idx + i;
+
+                if(curroffset >= hexdocument->length()) {
+                    offset = -1;
+                    return false;
+                }
+
+                uchar ch1 = hexdocument->at(curroffset);
+                uchar ch2 = value.at(i);
+
+                if(!(options & QHexFindOptions::CaseSensitive)) {
+                    ch1 = std::tolower(ch1);
+                    ch2 = std::tolower(ch2);
+                }
+
+                if(ch1 != ch2)
+                    break;
+                if(i == value.size() - 1)
+                    offset = idx;
+            }
+
+            return true;
+        });
+}
+
+qint64 findWildcard(QString pattern, qint64 startoffset,
+                    const QHexView* hexview, QHexFindDirection fd,
+                    qint64& patternlen) {
+    QHexDocument* hexdocument = hexview->hexDocument();
+    if(!PatternUtils::check(pattern, patternlen) ||
+       (patternlen >= hexdocument->length()))
+        return -1;
+
+    return findIter(
+        startoffset, fd, hexview,
+        [hexdocument, pattern, patternlen](qint64 idx, qint64& offset) -> bool {
+            if(PatternUtils::match(hexdocument->read(idx, patternlen), pattern))
+                offset = idx;
+            return true;
+        });
+}
+
+QByteArray variantToByteArray(QVariant value, QHexFindMode mode,
+                              unsigned int options) {
+    QByteArray v;
+
+    switch(mode) {
+        case QHexFindMode::Text:
+            if(QHEXVIEW_VARIANT_EQ(value, String))
+                v = value.toString().toUtf8();
+            else if(QHEXVIEW_VARIANT_EQ(value, ByteArray))
+                v = value.toByteArray();
+            break;
+
+        case QHexFindMode::Hex: {
+            if(QHEXVIEW_VARIANT_EQ(value, String)) {
+                qint64 len = 0;
+                auto s = value.toString();
+                if(!PatternUtils::check(s, len))
+                    return {};
+
+                bool ok = true;
+
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+                for(auto i = 0; ok && i < s.size(); i += 2)
+                    v.push_back(static_cast<char>(
+                        QStringView{s}.mid(i, 2).toUInt(&ok, 16)));
+#else
+                for(auto i = 0; ok && i < s.size(); i += 2)
+                    v.push_back(
+                        static_cast<char>(s.midRef(i, 2).toUInt(&ok, 16)));
+#endif
+
+                if(!ok)
+                    return {};
+            }
+            else if(QHEXVIEW_VARIANT_EQ(value, ByteArray))
+                v = value.toByteArray();
+            break;
+        }
+
+        case QHexFindMode::Int: {
+            bool ok = false;
+            uint val = value.toUInt(&ok);
+            if(!ok)
+                return QByteArray{};
+
+            QDataStream ds(&v, QIODevice::WriteOnly);
+
+            if(options & QHexFindOptions::BigEndian) {
+                if(options & QHexFindOptions::Int8)
+                    ds << qToBigEndian<quint8>(val);
+                else if(options & QHexFindOptions::Int16)
+                    ds << qToBigEndian<quint16>(val);
+                else if(options & QHexFindOptions::Int32)
+                    ds << qToBigEndian<quint32>(val);
+                else if(options & QHexFindOptions::Int64)
+                    ds << qToBigEndian<quint64>(val);
+                else
+                    return variantToByteArray(value, mode,
+                                              options | countBits(val));
+            }
+            else {
+                if(options & QHexFindOptions::Int8)
+                    ds << static_cast<quint8>(val);
+                else if(options & QHexFindOptions::Int16)
+                    ds << static_cast<quint16>(val);
+                else if(options & QHexFindOptions::Int32)
+                    ds << static_cast<quint32>(val);
+                else if(options & QHexFindOptions::Int64)
+                    ds << static_cast<quint64>(val);
+                else
+                    return variantToByteArray(value, mode,
+                                              options | countBits(val));
+            }
+
+            break;
+        }
+
+        case QHexFindMode::Float: {
+            bool ok = false;
+            QDataStream ds(&v, QIODevice::WriteOnly);
+            if(options & QHexFindOptions::Float)
+                ds << value.toFloat(&ok);
+            else if(options & QHexFindOptions::Double)
+                ds << value.toDouble(&ok);
+            if(!ok)
+                return {};
+        }
+
+        default: break;
+    }
+
+    return v;
+}
+
+} // namespace
+
+QByteArray toHex(const QByteArray& ba, char sep) {
+    if(ba.isEmpty()) {
+        return QByteArray();
+    }
+
+    QByteArray hex(sep ? (ba.size() * 3 - 1) : (ba.size() * 2),
+                   Qt::Uninitialized);
+
+    for(auto i = 0, o = 0; i < ba.size(); i++) {
+        if(sep && i)
+            hex[o++] = static_cast<uchar>(sep);
+        hex[o++] = HEXMAP->at((ba.at(i) & 0xf0) >> 4);
+        hex[o++] = HEXMAP->at(ba.at(i) & 0x0f);
+    }
+
+    return hex;
+}
+
+QByteArray toHex(const QByteArray& ba) { return QHexUtils::toHex(ba, '\0'); }
+qint64 positionToOffset(const QHexOptions* options, QHexPosition pos) {
+    return options->linelength * pos.line + pos.column;
+}
+QHexPosition offsetToPosition(const QHexOptions* options, qint64 offset) {
+    return {offset / options->linelength, offset % options->linelength};
+}
+
+QPair<qint64, qint64> find(const QHexView* hexview, QVariant value,
+                           qint64 startoffset, QHexFindMode mode,
+                           unsigned int options, QHexFindDirection fd) {
+    qint64 offset = -1, size = 0;
+    if(startoffset == -1)
+        startoffset = static_cast<qint64>(hexview->offset());
+
+    if(mode == QHexFindMode::Hex && QHEXVIEW_VARIANT_EQ(value, String)) {
+        offset = QHexUtils::findWildcard(value.toString(), startoffset, hexview,
+                                         fd, size);
+    }
+    else {
+        auto ba = variantToByteArray(value, mode, options);
+
+        if(!ba.isEmpty()) {
+            offset =
+                QHexUtils::findDefault(ba, startoffset, hexview, options, fd);
+            size = ba.size();
+        }
+        else
+            offset = -1;
+    }
+
+    return {offset, offset > -1 ? size : 0};
+}
+
+bool checkPattern(QString pattern) {
+    qint64 len = 0;
+    return PatternUtils::check(pattern, len);
+}
+
+QPair<qint64, qint64> replace(const QHexView* hexview, QVariant oldvalue,
+                              QVariant newvalue, qint64 startoffset,
+                              QHexFindMode mode, unsigned int options,
+                              QHexFindDirection fd) {
+    auto res =
+        QHexUtils::find(hexview, oldvalue, startoffset, mode, options, fd);
+
+    if(res.first != -1 && res.second > 0) {
+        QHexDocument* hexdocument = hexview->hexDocument();
+        auto ba = variantToByteArray(newvalue, mode, options);
+
+        if(!ba.isEmpty()) {
+            hexdocument->remove(res.first, res.second);
+            hexdocument->insert(res.first, ba);
+            res.second = ba.size();
+        }
+        else {
+            res.first = -1;
+            res.second = 0;
+        }
+    }
+
+    return res;
+}
+
+} // namespace QHexUtils

UEFITool/ffsfinder.cpp

@@ -1,18 +1,32 @@
-/* fssfinder.cpp
+/* ffsfinder.cpp
 
-Copyright (c) 2015, Nikolaj Schlej. All rights reserved.
+ Copyright (c) 2015, Nikolaj Schlej. All rights reserved.
-This program and the accompanying materials
+ This program and the accompanying materials
-are licensed and made available under the terms and conditions of the BSD License
+ are licensed and made available under the terms and conditions of the BSD License
-which accompanies this distribution.  The full text of the license may be found at
+ which accompanies this distribution.  The full text of the license may be found at
-http://opensource.org/licenses/bsd-license.php
+ http://opensource.org/licenses/bsd-license.php
  
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  
-*/
+ */
 
 #include "ffsfinder.h"
 
+#if QT_VERSION_MAJOR >= 6
+#include <QRegularExpression>
+#else
+#include <QRegExp>
+#endif
+
+USTATUS FfsFinder::findHexPattern(const UByteArray & hexPattern, const UINT8 mode) {
+    const UModelIndex rootIndex = model->index(0, 0);
+    USTATUS ret = findHexPattern(rootIndex, hexPattern, mode);
+    if (ret != U_SUCCESS)
+        msg(UString("Hex pattern \"") + UString(hexPattern) + UString("\" could not be found"), rootIndex);
+    return ret;
+}
+
 USTATUS FfsFinder::findHexPattern(const UModelIndex & index, const UByteArray & hexPattern, const UINT8 mode)
 {
     if (!index.isValid())
@@ -25,40 +39,80 @@ USTATUS FfsFinder::findHexPattern(const UModelIndex & index, const UByteArray &
     if (hexPattern.count('.') == hexPattern.length())
         return U_SUCCESS;
     
+    USTATUS ret = U_ITEM_NOT_FOUND;
     bool hasChildren = (model->rowCount(index) > 0);
     for (int i = 0; i < model->rowCount(index); i++) {
-        findHexPattern(index.child(i, index.column()), hexPattern, mode);
+        if (U_SUCCESS == findHexPattern(index.model()->index(i, index.column(), index), hexPattern, mode))
+            ret = U_SUCCESS;
     }
     
     UByteArray data;
     if (hasChildren) {
-        if (mode != SEARCH_MODE_BODY)
+        if (mode == SEARCH_MODE_HEADER)
             data = model->header(index);
+        else if (mode == SEARCH_MODE_ALL)
+            data = model->header(index) + model->body(index);
     }
     else {
         if (mode == SEARCH_MODE_HEADER)
-            data.append(model->header(index));
+            data = model->header(index);
         else if (mode == SEARCH_MODE_BODY)
-            data.append(model->body(index));
+            data = model->body(index);
         else
-            data.append(model->header(index)).append(model->body(index));
+            data = model->header(index) + model->body(index);
     }
     
     UString hexBody = UString(data.toHex());
+#if QT_VERSION_MAJOR >= 6
+    QRegularExpression regexp = QRegularExpression(UString(hexPattern));
+    regexp.setPatternOptions(QRegularExpression::CaseInsensitiveOption);
+    QRegularExpressionMatch regexpmatch;
+    
+    INT32 offset = (INT32)hexBody.indexOf(regexp, 0, &regexpmatch);
+#else
     QRegExp regexp = QRegExp(UString(hexPattern), Qt::CaseInsensitive);
+
     INT32 offset = regexp.indexIn(hexBody);
+#endif
     while (offset >= 0) {
         if (offset % 2 == 0) {
-            msg(UString("Hex pattern \"") + UString(hexPattern) 
+            // For patterns that cross header|body boundary, skip patterns entirely located in body, since
-                + UString("\" found as \"") + hexBody.mid(offset, hexPattern.length()).toUpper() 
+            // children search above has already found them.
-                + UString("\" in ") + model->name(index) 
+            if (!(hasChildren && mode == SEARCH_MODE_ALL && offset/2 >= model->header(index).size())) {
-                + usprintf(" at %s-offset %02Xh", mode == SEARCH_MODE_BODY ? "body" : "header", offset / 2),
+                UModelIndex parentFileIndex = model->findParentOfType(index, Types::File);
-                index);
+                UString name = model->name(index);
+                if (model->parent(index) == parentFileIndex) {
+                    name = model->name(parentFileIndex) + UString("/") + name;
                 }
-        offset = regexp.indexIn(hexBody, offset + 1);
+                else if (parentFileIndex.isValid()) {
+                    name = model->name(parentFileIndex) + UString("/.../") + name;
                 }
 
-    return U_SUCCESS;
+                msg(UString("Hex pattern \"") + UString(hexPattern)
+                    + UString("\" found as \"") + hexBody.mid(offset, hexPattern.length()).toUpper()
+                    + UString("\" in ") + name
+                    + usprintf(" at %s-offset %02Xh", mode == SEARCH_MODE_BODY ? "body" : "header", offset / 2),
+                    index);
+                ret = U_SUCCESS;
+            }
+        }
+
+#if QT_VERSION_MAJOR >= 6
+        offset = (INT32)hexBody.indexOf(regexp, (qsizetype)offset + 1, &regexpmatch);
+#else
+        offset = regexp.indexIn(hexBody, offset + 1);
+#endif
+    }
+
+    return ret;
+}
+
+USTATUS FfsFinder::findGuidPattern(const UByteArray & guidPattern, const UINT8 mode) {
+    const UModelIndex rootIndex = model->index(0, 0);
+    USTATUS ret = findGuidPattern(rootIndex, guidPattern, mode);
+    if (ret != U_SUCCESS)
+        msg(UString("GUID pattern \"") + UString(guidPattern) + UString("\" could not be found"), rootIndex);
+    return ret;
 }
 
 USTATUS FfsFinder::findGuidPattern(const UModelIndex & index, const UByteArray & guidPattern, const UINT8 mode)
@@ -69,9 +123,11 @@ USTATUS FfsFinder::findGuidPattern(const UModelIndex & index, const UByteArray &
     if (!index.isValid())
         return U_SUCCESS;
 
+    USTATUS ret = U_ITEM_NOT_FOUND;
     bool hasChildren = (model->rowCount(index) > 0);
     for (int i = 0; i < model->rowCount(index); i++) {
-        findGuidPattern(index.child(i, index.column()), guidPattern, mode);
+        if (U_SUCCESS == findGuidPattern(index.model()->index(i, index.column(), index), guidPattern, mode))
+            ret = U_SUCCESS;
     }
 
     UByteArray data;
@@ -112,20 +168,53 @@ USTATUS FfsFinder::findGuidPattern(const UModelIndex & index, const UByteArray &
     if (hexPattern.count('.') == hexPattern.length())
         return U_SUCCESS;
 
+#if QT_VERSION_MAJOR >= 6
+    QRegularExpression regexp((QString)UString(hexPattern));
+    regexp.setPatternOptions(QRegularExpression::CaseInsensitiveOption);
+    QRegularExpressionMatch regexpmatch;
+
+    INT32 offset = (INT32)hexBody.indexOf(regexp, 0, &regexpmatch);
+#else
     QRegExp regexp(UString(hexPattern), Qt::CaseInsensitive);
+
     INT32 offset = regexp.indexIn(hexBody);
+#endif
     while (offset >= 0) {
         if (offset % 2 == 0) {
-            msg(UString("GUID pattern \"") + UString(guidPattern)
+            UModelIndex parentFileIndex = model->findParentOfType(index, Types::File);
-                + UString("\" found as \"") + hexBody.mid(offset, hexPattern.length()).toUpper()
+            UString name = model->name(index);
-                + UString("\" in ") + model->name(index)
+            if (model->parent(index) == parentFileIndex) {
-                + usprintf(" at %s-offset %02Xh", mode == SEARCH_MODE_BODY ? "body" : "header", offset / 2),
+                name = model->name(parentFileIndex) + UString("/") + name;
-                index);
             }
-        offset = regexp.indexIn(hexBody, offset + 1);
+            else if (parentFileIndex.isValid()) {
+                name = model->name(parentFileIndex) + UString("/.../") + name;
             }
 
-    return U_SUCCESS;
+            msg(UString("GUID pattern \"") + UString(guidPattern)
+                + UString("\" found as \"") + hexBody.mid(offset, hexPattern.length()).toUpper()
+                + UString("\" in ") + name
+                + usprintf(" at %s-offset %02Xh", mode == SEARCH_MODE_BODY ? "body" : "header", offset / 2),
+                index);
+            ret = U_SUCCESS;
+        }
+
+#if QT_VERSION_MAJOR >= 6
+        offset = (INT32)hexBody.indexOf(regexp, (qsizetype)offset + 1, &regexpmatch);
+#else
+        offset = regexp.indexIn(hexBody, offset + 1);
+#endif
+    }
+
+    return ret;
+}
+
+USTATUS FfsFinder::findTextPattern(const UString & pattern, const UINT8 mode, const bool unicode, const Qt::CaseSensitivity caseSensitive) {
+    const UModelIndex rootIndex = model->index(0, 0);
+    USTATUS ret = findTextPattern(rootIndex, pattern, mode, unicode, caseSensitive);
+    if (ret != U_SUCCESS)
+        msg((unicode ? UString("Unicode") : UString("ASCII")) + UString(" text \"")
+            + UString(pattern) + UString("\" could not be found"), rootIndex);
+    return ret;
 }
 
 USTATUS FfsFinder::findTextPattern(const UModelIndex & index, const UString & pattern, const UINT8 mode, const bool unicode, const Qt::CaseSensitivity caseSensitive)
@@ -136,9 +225,11 @@ USTATUS FfsFinder::findTextPattern(const UModelIndex & index, const UString & pa
     if (!index.isValid())
         return U_SUCCESS;
 
+    USTATUS ret = U_ITEM_NOT_FOUND;
     bool hasChildren = (model->rowCount(index) > 0);
     for (int i = 0; i < model->rowCount(index); i++) {
-        findTextPattern(index.child(i, index.column()), pattern, mode, unicode, caseSensitive);
+        if (U_SUCCESS == findTextPattern(index.model()->index(i, index.column(), index), pattern, mode, unicode, caseSensitive))
+            ret = U_SUCCESS;
     }
 
     UByteArray body;
@@ -155,20 +246,31 @@ USTATUS FfsFinder::findTextPattern(const UModelIndex & index, const UString & pa
             body.append(model->header(index)).append(model->body(index));
     }
 
-    UString data;
+    UString data = UString::fromLatin1((const char*)body.constData(), body.length());
+
+    UString searchPattern;
     if (unicode)
-        data = UString::fromUtf16((const ushort*)body.constData(), body.length() / 2);
+        searchPattern = UString::fromLatin1((const char*)pattern.utf16(), pattern.length() * 2);
     else
-        data = UString::fromLatin1((const char*)body.constData(), body.length());
+        searchPattern = pattern;
 
     int offset = -1;
-    while ((offset = data.indexOf(pattern, offset + 1, caseSensitive)) >= 0) {
+    while ((offset = (int)data.indexOf(searchPattern, (int)(offset + 1), caseSensitive)) >= 0) {
-
+        UModelIndex parentFileIndex = model->findParentOfType(index, Types::File);
-        msg((unicode ? UString("Unicode") : UString("ASCII")) + UString(" text \"") + UString(pattern)
+        UString name = model->name(index);
-            + UString("\" found in ") + model->name(index)
+        if (model->parent(index) == parentFileIndex) {
-            + usprintf(" at %s-offset %02Xh", mode == SEARCH_MODE_BODY ? "body" : "header", (unicode ? offset * 2 : offset)),
+            name = model->name(parentFileIndex) + UString("/") + name;
-            index);
+        }
+        else if (parentFileIndex.isValid()) {
+            name = model->name(parentFileIndex) + UString("/.../") + name;
         }
 
-    return U_SUCCESS;
+        msg((unicode ? UString("Unicode") : UString("ASCII")) + UString(" text \"") + UString(pattern)
+            + UString("\" found in ") + name
+            + usprintf(" at %s-offset %02Xh", mode == SEARCH_MODE_BODY ? "body" : "header", offset),
+            index);
+        ret = U_SUCCESS;
+    }
+
+    return ret;
 }

UEFITool/ffsfinder.h

@@ -15,7 +15,6 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #define FFSFINDER_H
 
 #include <vector>
-#include <QRegExp>
 
 #include "../common/ubytearray.h"
 #include "../common/ustring.h"
@@ -31,9 +30,9 @@ public:
     std::vector<std::pair<UString, UModelIndex> > getMessages() const { return messagesVector; }
     void clearMessages() { messagesVector.clear(); }
 
-    USTATUS findHexPattern(const UModelIndex & index, const UByteArray & hexPattern, const UINT8 mode);
+    USTATUS findHexPattern(const UByteArray & hexPattern, const UINT8 mode);
-    USTATUS findGuidPattern(const UModelIndex & index, const UByteArray & guidPattern, const UINT8 mode);
+    USTATUS findGuidPattern(const UByteArray & guidPattern, const UINT8 mode);
-    USTATUS findTextPattern(const UModelIndex & index, const UString & pattern, const UINT8 mode, const bool unicode, const Qt::CaseSensitivity caseSensitive);
+    USTATUS findTextPattern(const UString & pattern, const UINT8 mode, const bool unicode, const Qt::CaseSensitivity caseSensitive);
 
 private:
     const TreeModel* model;
@@ -42,6 +41,10 @@ private:
     void msg(const UString & message, const UModelIndex &index = UModelIndex()) {
         messagesVector.push_back(std::pair<UString, UModelIndex>(message, index));
     }
+
+    USTATUS findHexPattern(const UModelIndex & index, const UByteArray & hexPattern, const UINT8 mode);
+    USTATUS findGuidPattern(const UModelIndex & index, const UByteArray & guidPattern, const UINT8 mode);
+    USTATUS findTextPattern(const UModelIndex & index, const UString & pattern, const UINT8 mode, const bool unicode, const Qt::CaseSensitivity caseSensitive);
 };
 
 #endif // FFSFINDER_H

UEFITool/gotoaddressdialog.h

@@ -0,0 +1,36 @@
+/* gotoaddressdialog.h
+
+  Copyright (c) 2018, Nikolaj Schlej. All rights reserved.
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+  */
+
+#ifndef GOTOADDRESSDIALOG_H
+#define GOTOADDRESSDIALOG_H
+
+#include <QObject>
+#include <QDialog>
+#include "ui_gotoaddressdialog.h"
+class GoToAddressDialog : public QDialog
+{
+    Q_OBJECT
+
+public:
+    GoToAddressDialog(QWidget* parent = NULL) :
+        QDialog(parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint),
+        ui(new Ui::GoToAddressDialog) {
+        ui->setupUi(this);
+    }
+
+    ~GoToAddressDialog() { delete ui; }
+
+    Ui::GoToAddressDialog* ui;
+};
+
+#endif // GOTOADDRESSDIALOG_H

UEFITool/gotoaddressdialog.ui

@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>GoToAddressDialog</class>
+ <widget class="QDialog" name="GoToAddressDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>270</width>
+    <height>86</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Select item at address</string>
+  </property>
+  <property name="modal">
+   <bool>false</bool>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <property name="spacing">
+    <number>5</number>
+   </property>
+   <property name="leftMargin">
+    <number>5</number>
+   </property>
+   <property name="topMargin">
+    <number>5</number>
+   </property>
+   <property name="rightMargin">
+    <number>5</number>
+   </property>
+   <property name="bottomMargin">
+    <number>5</number>
+   </property>
+   <item>
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string/>
+     </property>
+     <layout class="QHBoxLayout" name="horizontalLayout">
+      <property name="spacing">
+       <number>5</number>
+      </property>
+      <property name="leftMargin">
+       <number>5</number>
+      </property>
+      <property name="topMargin">
+       <number>5</number>
+      </property>
+      <property name="rightMargin">
+       <number>5</number>
+      </property>
+      <property name="bottomMargin">
+       <number>5</number>
+      </property>
+      <item>
+       <widget class="QLabel" name="label">
+        <property name="text">
+         <string>Select item at address:</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="HexSpinBox" name="hexSpinBox">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>HexSpinBox</class>
+   <extends>QSpinBox</extends>
+   <header>hexspinbox.h</header>
+  </customwidget>
+ </customwidgets>
+ <tabstops>
+  <tabstop>buttonBox</tabstop>
+ </tabstops>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>GoToAddressDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>182</x>
+     <y>185</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>194</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>GoToAddressDialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>182</x>
+     <y>185</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>194</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

UEFITool/gotobasedialog.h

@@ -0,0 +1,36 @@
+/* gotobasedialog.h
+
+  Copyright (c) 2018, Nikolaj Schlej. All rights reserved.
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+  */
+
+#ifndef GOTOBASEDIALOG_H
+#define GOTOBASEDIALOG_H
+
+#include <QObject>
+#include <QDialog>
+#include "ui_gotobasedialog.h"
+class GoToBaseDialog : public QDialog
+{
+    Q_OBJECT
+
+public:
+    GoToBaseDialog(QWidget* parent = NULL):
+        QDialog(parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint),
+        ui(new Ui::GoToBaseDialog) {
+        ui->setupUi(this);
+    }
+
+    ~GoToBaseDialog() {delete ui;}
+
+    Ui::GoToBaseDialog* ui;
+};
+
+#endif // GOTOBASEDIALOG_H

UEFITool/gotobasedialog.ui

@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>GoToBaseDialog</class>
+ <widget class="QDialog" name="GoToBaseDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>270</width>
+    <height>86</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Select item at base</string>
+  </property>
+  <property name="modal">
+   <bool>false</bool>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <property name="spacing">
+    <number>5</number>
+   </property>
+   <property name="leftMargin">
+    <number>5</number>
+   </property>
+   <property name="topMargin">
+    <number>5</number>
+   </property>
+   <property name="rightMargin">
+    <number>5</number>
+   </property>
+   <property name="bottomMargin">
+    <number>5</number>
+   </property>
+   <item>
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string/>
+     </property>
+     <layout class="QHBoxLayout" name="horizontalLayout">
+      <property name="spacing">
+       <number>5</number>
+      </property>
+      <property name="leftMargin">
+       <number>5</number>
+      </property>
+      <property name="topMargin">
+       <number>5</number>
+      </property>
+      <property name="rightMargin">
+       <number>5</number>
+      </property>
+      <property name="bottomMargin">
+       <number>5</number>
+      </property>
+      <item>
+       <widget class="QLabel" name="label">
+        <property name="text">
+         <string>Select item at base:</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="HexSpinBox" name="hexSpinBox">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>HexSpinBox</class>
+   <extends>QSpinBox</extends>
+   <header>hexspinbox.h</header>
+  </customwidget>
+ </customwidgets>
+ <tabstops>
+  <tabstop>buttonBox</tabstop>
+ </tabstops>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>GoToBaseDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>182</x>
+     <y>185</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>194</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>GoToBaseDialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>182</x>
+     <y>185</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>194</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

UEFITool/guidlineedit.cpp

@@ -1,61 +0,0 @@
-/* guidlineedit.cpp
-
-  Copyright (c) 2014, Nikolaj Schlej. All rights reserved.
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-  */
-
-#include "guidlineedit.h"
-
-GuidLineEdit::GuidLineEdit(QWidget * parent)
-    :QLineEdit(parent)
-{
-}
-
-GuidLineEdit::GuidLineEdit(const QString & contents, QWidget * parent)
-    :QLineEdit(contents, parent)
-{
-}
-
-GuidLineEdit::~GuidLineEdit()
-{
-}
-
-void GuidLineEdit::keyPressEvent(QKeyEvent * event)
-{
-    if (event == QKeySequence::Delete || event->key() == Qt::Key_Backspace)
-    {
-        int pos = cursorPosition();
-        if (event->key() == Qt::Key_Backspace && pos > 0) {
-            cursorBackward(false);
-            pos = cursorPosition();
-        }
-        
-        QString txt = text();
-        QString selected = selectedText();
-
-        if (!selected.isEmpty()) {
-            pos = QLineEdit::selectionStart();
-            for (int i = pos; i < pos + selected.count(); i++)
-                if (txt[i] != QChar('-'))
-                    txt[i] = QChar('.');
-        }
-        else 
-            txt[pos] = QChar('.');
-
-        setCursorPosition(0);
-        insert(txt);
-        setCursorPosition(pos);
-
-        return;
-    }
-
-    // Call original event handler
-    QLineEdit::keyPressEvent(event);
-}

UEFITool/hexlineedit.cpp

@@ -0,0 +1,86 @@
+/* hexlineedit.cpp
+ 
+ Copyright (c) 2014, Nikolaj Schlej. All rights reserved.
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution.  The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+ 
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+ 
+ */
+
+#include "hexlineedit.h"
+
+#if QT_VERSION_MAJOR >= 6
+#include <QRegularExpression>
+#else
+#include <QRegExp>
+#endif
+
+HexLineEdit::HexLineEdit(QWidget * parent)
+:QLineEdit(parent)
+{
+    m_editAsGuid = false;
+}
+
+HexLineEdit::HexLineEdit(const QString & contents, QWidget * parent)
+:QLineEdit(contents, parent)
+{
+    m_editAsGuid = false;
+}
+
+HexLineEdit::~HexLineEdit()
+{
+}
+
+void HexLineEdit::keyPressEvent(QKeyEvent * event)
+{
+    QClipboard *clipboard;
+    QString originalText;
+
+    if (m_editAsGuid && (event == QKeySequence::Delete || event->key() == Qt::Key_Backspace))
+    {
+        int pos = cursorPosition();
+        if (event->key() == Qt::Key_Backspace && pos > 0) {
+            cursorBackward(false);
+            pos = cursorPosition();
+        }
+        
+        QString txt = text();
+        QString selected = selectedText();
+        
+        if (!selected.isEmpty()) {
+            pos = QLineEdit::selectionStart();
+            for (int i = pos; i < pos + selected.length(); i++)
+                if (txt[i] != QChar('-'))
+                    txt[i] = QChar('.');
+        }
+        else {
+            txt[pos] = QChar('.');
+        }
+        
+        setCursorPosition(0);
+        insert(txt);
+        setCursorPosition(pos);
+        
+        return;
+    }
+
+    if (event == QKeySequence::Paste)
+    {
+        clipboard = QApplication::clipboard();
+        originalText = clipboard->text();
+        QString cleanedHex = QString(originalText).replace(QString("0x"), QString(""), Qt::CaseInsensitive);
+#if QT_VERSION_MAJOR >= 6
+        cleanedHex.remove(QRegularExpression("[^a-fA-F\\d]+"));
+#else
+        cleanedHex.remove(QRegExp("[^a-fA-F\\d]+"));
+#endif
+        clipboard->setText(cleanedHex);
+    }
+    
+    // Call original event handler
+    QLineEdit::keyPressEvent(event);
+}

UEFITool/hexlineedit.h

@@ -1,4 +1,4 @@
-/* guidlineedit.h
+/* hexlineedit.h
 
   Copyright (c) 2014, Nikolaj Schlej. All rights reserved.
   This program and the accompanying materials
@@ -11,9 +11,11 @@
 
   */
 
-#ifndef GUIDLINEEDIT_H
+#ifndef HEXLINEEDIT_H
-#define GUIDLINEEDIT_H
+#define HEXLINEEDIT_H
 
+#include <QApplication>
+#include <QClipboard>
 #include <QLineEdit>
 #include <QKeyEvent>
 #include <QKeySequence>
@@ -21,16 +23,29 @@
 
 #include "../common/basetypes.h"
 
-class GuidLineEdit : public QLineEdit
+class HexLineEdit : public QLineEdit
 {
+     Q_OBJECT
+     Q_PROPERTY(bool editAsGuid READ editAsGuid WRITE setEditAsGuid)
+
 public:
-    GuidLineEdit(QWidget * parent = 0);
+    HexLineEdit(QWidget * parent = 0);
-    GuidLineEdit(const QString & contents, QWidget * parent = 0);
+    HexLineEdit(const QString & contents, QWidget * parent = 0);
-    ~GuidLineEdit();
+    ~HexLineEdit();
+
+    void setEditAsGuid(bool editAsGuid)
+    {
+        m_editAsGuid = editAsGuid;
+    }
+    bool editAsGuid() const
+    { return m_editAsGuid; }
+
+private:
+    bool m_editAsGuid;
 
 protected:
     void keyPressEvent(QKeyEvent * event);
 
 };
 
-#endif // GUIDLINEEDIT_H
+#endif // HEXLINEEDIT_H

UEFITool/hexspinbox.cpp

@@ -0,0 +1,41 @@
+/* hexspinbox.cpp
+ 
+ Copyright (c) 2016, Nikolaj Schlej. All rights reserved.
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution.  The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+ 
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+ 
+ */
+
+#include "hexspinbox.h"
+#include <QDebug>
+
+HexSpinBox::HexSpinBox(QWidget *parent) :
+#if QT_VERSION_MAJOR >= 6
+QSpinBox(parent), validator(QRegularExpression("0x([0-9a-fA-F]){1,8}"))
+#else
+QSpinBox(parent), validator(QRegExp("0x([0-9a-fA-F]){1,8}"))
+#endif
+{
+    this->setRange(INT_MIN, INT_MAX);
+    this->setPrefix("0x");
+}
+
+QValidator::State HexSpinBox::validate(QString &text, int &pos) const
+{
+    return validator.validate(text, pos);
+}
+
+QString HexSpinBox::textFromValue(int val) const
+{
+    return QString::number((uint)val, 16).toUpper();
+}
+
+int HexSpinBox::valueFromText(const QString &text) const
+{
+    return (int)text.toUInt(NULL, 16);
+}

UEFITool/hexspinbox.h

@@ -0,0 +1,45 @@
+/* hexspinbox.h
+
+  Copyright (c) 2016, Nikolaj Schlej. All rights reserved.
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+  */
+
+#ifndef HEXSPINBOX_H
+#define HEXSPINBOX_H
+
+#include <QSpinBox>
+
+#if QT_VERSION_MAJOR >= 6
+#include <QRegularExpressionValidator>
+#else
+#include <QRegExpValidator>
+#endif
+
+class HexSpinBox : public QSpinBox
+{
+    Q_OBJECT
+
+public:
+    HexSpinBox(QWidget *parent = 0);
+
+protected:
+    QValidator::State validate(QString &text, int &pos) const;
+    int valueFromText(const QString &text) const;
+    QString textFromValue(int value) const;
+
+private:
+#if QT_VERSION_MAJOR >= 6
+    QRegularExpressionValidator validator;
+#else
+    QRegExpValidator validator;
+#endif
+};
+
+#endif // HEXSPINBOX_H

UEFITool/hexviewdialog.cpp

@@ -20,9 +20,8 @@ hexView(NULL)
 {
     // Create UI
     ui->setupUi(this);
-    hexView = new QHexEdit(this);
+    hexView = new QHexView(this);
     hexView->setReadOnly(true);
-    hexView->setUpperCase(true);
     ui->layout->addWidget(hexView);
 }
 
@@ -37,16 +36,33 @@ void HexViewDialog::setFont(const QFont &font)
     hexView->setFont(font);
 }
 
-void HexViewDialog::setItem(const UModelIndex & index)
+void HexViewDialog::setItem(const UModelIndex & index, HexViewType type)
 {
     const TreeModel * model = (const TreeModel*)index.model();
-    
-    // Set dialog title
     UString itemName = model->name(index);
     UString itemText = model->text(index);
-    setWindowTitle(UString("Hex view: ") + (itemText.isEmpty() ? itemName : itemName + " | " + itemText));
     
-    // Set hex data
+    // Set hex data and dialog title
-    QByteArray data = model->header(index) + model->body(index) + model->tail(index);
+    QByteArray hexdata;
-    hexView->setData(data);
+    UString dialogTitle;
+    
+    switch (type) {
+        case fullHexView:
+            dialogTitle = UString("Hex view: ");
+            hexdata = model->header(index) + model->body(index) + model->tail(index);
+            break;
+        case bodyHexView:
+            dialogTitle = UString("Body hex view: ");
+            hexdata = model->body(index);
+            break;
+        case uncompressedHexView:
+            dialogTitle = UString("Uncompressed hex view: ");
+            hexdata = model->uncompressedData(index);
+            break;
+    }
+    
+    dialogTitle += itemText.isEmpty() ? itemName : itemName + " | " + itemText;
+    setWindowTitle(dialogTitle);
+    hexView->setData(hexdata);
+    hexView->setFont(QApplication::font());
 }

UEFITool/hexviewdialog.h

@@ -15,8 +15,8 @@
 #define HEXVIEWDIALOG_H
 
 #include <QDialog>
+#include <QHexView/qhexview.h>
 #include "../common/treemodel.h"
-#include "../qhexedit2/qhexedit.h"
 #include "ui_hexviewdialog.h"
 
 class HexViewDialog : public QDialog
@@ -24,15 +24,21 @@ class HexViewDialog : public QDialog
     Q_OBJECT
 
 public:
+    enum HexViewType {
+        fullHexView,
+        bodyHexView,
+        uncompressedHexView
+    };
+    
     HexViewDialog(QWidget *parent = 0);
     ~HexViewDialog();
     Ui::HexViewDialog* ui;
 
-    void setItem(const UModelIndex & index);
+    void setItem(const UModelIndex & index, HexViewType dataType);
     void setFont(const QFont &font);
     
 private:
-    QHexEdit * hexView;
+    QHexView * hexView;
 };
 
 #endif // HEXVIEWDIALOG_H

UEFITool/messagelistitem.cpp

@@ -1,44 +0,0 @@
-/* messagelistitem.cpp
-
-  Copyright (c) 2013, Nikolaj Schlej. All rights reserved.
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-  */
-
-#include "messagelistitem.h"
-
-MessageListItem::MessageListItem(QListWidget * parent, int type, const QModelIndex & index)
-    : QListWidgetItem(parent, type)
-{
-    itemIndex = index;
-}
-
-MessageListItem::MessageListItem(const QString & text, QListWidget * parent, int type, const QModelIndex & index)
-    : QListWidgetItem(text, parent, type), itemIndex(index)
-{
-}
-
-MessageListItem::MessageListItem(const QIcon & icon, const QString & text, QListWidget * parent, int type, const QModelIndex & index)
-    : QListWidgetItem(icon, text, parent, type), itemIndex(index)
-{
-}
-
-MessageListItem::~MessageListItem()
-{
-}
-
-QModelIndex MessageListItem::index() const
-{
-    return itemIndex;
-}
-
-void MessageListItem::setIndex(QModelIndex & index)
-{
-    itemIndex = index;
-}

UEFITool/messagelistitem.h

@@ -1,37 +0,0 @@
-/* messagelistitem.h
-
-  Copyright (c) 2014, Nikolaj Schlej. All rights reserved.
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-  */
-
-#ifndef MESSAGELISTITEM_H
-#define MESSAGELISTITEM_H
-
-#include <QModelIndex>
-#include <QListWidgetItem>
-
-#include "../common/basetypes.h"
-
-class MessageListItem : public QListWidgetItem
-{
-public:
-    MessageListItem(QListWidget * parent = 0, int type = Type, const QModelIndex & index = QModelIndex());
-    MessageListItem(const QString & text, QListWidget * parent = 0, int type = Type, const QModelIndex & index = QModelIndex());
-    MessageListItem(const QIcon & icon, const QString & text, QListWidget * parent = 0, int type = Type, const QModelIndex & index = QModelIndex());
-    ~MessageListItem();
-
-    QModelIndex index() const;
-    void setIndex(QModelIndex & index);
-
-private:
-    QModelIndex itemIndex;
-};
-
-#endif // MESSAGELISTITEM_H

UEFITool/searchdialog.cpp

@@ -14,10 +14,15 @@
 #include "searchdialog.h"
 
 SearchDialog::SearchDialog(QWidget *parent) :
-QDialog(parent),
+QDialog(parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint),
 ui(new Ui::SearchDialog),
+#if QT_VERSION_MAJOR >= 6
+hexValidator(QRegularExpression("([0-9a-fA-F\\. ])*")),
+guidValidator(QRegularExpression("[0-9a-fA-F\\.]{8}-[0-9a-fA-F\\.]{4}-[0-9a-fA-F\\.]{4}-[0-9a-fA-F\\.]{4}-[0-9a-fA-F\\.]{12}"))
+#else
 hexValidator(QRegExp("([0-9a-fA-F\\. ])*")),
 guidValidator(QRegExp("[0-9a-fA-F\\.]{8}-[0-9a-fA-F\\.]{4}-[0-9a-fA-F\\.]{4}-[0-9a-fA-F\\.]{4}-[0-9a-fA-F\\.]{12}"))
+#endif
 {
     // Create UI
     ui->setupUi(this);

UEFITool/searchdialog.h

@@ -15,7 +15,13 @@
 #define SEARCHDIALOG_H
 
 #include <QDialog>
+
+#if QT_VERSION_MAJOR >= 6
+#include <QRegularExpressionValidator>
+#else
 #include <QRegExpValidator>
+#endif
+
 #include "ui_searchdialog.h"
 
 class SearchDialog : public QDialog
@@ -31,8 +37,13 @@ private slots:
     void setEditFocus(int index);
 
 private:
+#if QT_VERSION_MAJOR >= 6
+    QRegularExpressionValidator hexValidator;
+    QRegularExpressionValidator guidValidator;
+#else
     QRegExpValidator hexValidator;
     QRegExpValidator guidValidator;
+#endif
 };
 
 #endif // SEARCHDIALOG_H

UEFITool/searchdialog.ui

@@ -35,7 +35,10 @@
         </widget>
        </item>
        <item row="0" column="1">
-        <widget class="QLineEdit" name="hexEdit">
+        <widget class="HexLineEdit" name="hexEdit">
+         <property name="editAsGuid">
+          <bool>false</bool>
+         </property>
          <property name="inputMask">
           <string/>
          </property>
@@ -89,7 +92,10 @@
         </widget>
        </item>
        <item row="0" column="1">
-        <widget class="GuidLineEdit" name="guidEdit">
+        <widget class="HexLineEdit" name="guidEdit">
+         <property name="editAsGuid">
+          <bool>true</bool>
+         </property>
          <property name="inputMask">
           <string>xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx</string>
          </property>
@@ -241,9 +247,9 @@
  </widget>
  <customwidgets>
   <customwidget>
-   <class>GuidLineEdit</class>
+   <class>HexLineEdit</class>
    <extends>QLineEdit</extends>
-   <header>guidlineedit.h</header>
+   <header>hexlineedit.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>

UEFITool/uefitool.desktop

@@ -3,9 +3,8 @@ Type=Application
 Version=1.0
 Name=UEFITool
 Comment=UEFI firmware image viewer and editor
-Path=/usr/bin
 Exec=uefitool
 Icon=uefitool
 Terminal=false
 Categories=Development;System;Utility;HardwareSettings;Electronics;Engineering;
-Keywords=BIOS;
+Keywords=BIOS;UEFI;

UEFITool/uefitool.entitlements

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.app-sandbox</key>
+	<true/>
+	<key>com.apple.security.assets.movies.read-write</key>
+	<true/>
+	<key>com.apple.security.assets.music.read-write</key>
+	<true/>
+	<key>com.apple.security.assets.pictures.read-write</key>
+	<true/>
+	<key>com.apple.security.files.downloads.read-write</key>
+	<true/>
+	<key>com.apple.security.files.user-selected.read-write</key>
+	<true/>
+	<key>com.apple.security.print</key>
+	<true/>
+</dict>
+</plist>

UEFITool/uefitool.h

@@ -22,15 +22,19 @@
 #include <QFile>
 #include <QFileDialog>
 #include <QFileInfo>
+#include <QFont>
 #include <QListWidget>
 #include <QMenu>
 #include <QMessageBox>
 #include <QMimeData>
+#include <QPalette>
 #include <QPlainTextEdit>
 #include <QProcess>
 #include <QSettings>
 #include <QSplitter>
+#include <QStyleFactory>
 #include <QString>
+#include <QTableWidget>
 #include <QTreeView>
 #include <QUrl>
 
@@ -40,10 +44,13 @@
 #include "../common/ffsparser.h"
 #include "../common/ffsops.h"
 #include "../common/ffsbuilder.h"
+#include "../common/ffsreport.h"
+#include "../common/guiddatabase.h"
 
 #include "searchdialog.h"
+#include "gotobasedialog.h"
+#include "gotoaddressdialog.h"
 #include "hexviewdialog.h"
-#include "messagelistitem.h"
 #include "ffsfinder.h"
 
 namespace Ui {
@@ -63,16 +70,22 @@ public:
 
 private slots:
     void init();
+    void populateUi(const QItemSelection &selected);
     void populateUi(const QModelIndex &current);
-    void scrollTreeView(QListWidgetItem* item);
+    void scrollTreeView(QListWidgetItem* item); // For messages
+    void scrollTreeView(QTableWidgetItem* item); // For FIT table entries
 
     void openImageFile();
     void openImageFileInNewWindow();
     void saveImageFile();
+
     void search();
+    void goToBase();
+    void goToAddress();
 
     void hexView();
-
+    void bodyHexView();
+    void uncompressedHexView();
     void goToData();
 
     void extract(const UINT8 mode);
@@ -98,28 +111,47 @@ private slots:
     void enableMessagesCopyActions(QListWidgetItem* item);
     void clearMessages();
 
+    void toggleBootGuardMarking(bool enabled);
+
     void about();
     void aboutQt();
 
     void exit();
     void writeSettings();
 
+    void loadGuidDatabase();
+    void unloadGuidDatabase();
+    void loadDefaultGuidDatabase();
+    void exportDiscoveredGuids();
+    void generateReport();
+
+    void currentTabChanged(int index);
+
+#if QT_VERSION_MAJOR >= 6 && QT_VERSION_MINOR >= 5
+    void updateUiForNewColorScheme(Qt::ColorScheme scheme);
+#endif
+
 private:
     Ui::UEFITool* ui;
     TreeModel* model;
     FfsParser* ffsParser;
     FfsFinder* ffsFinder;
+    FfsReport* ffsReport;
     FfsOperations* ffsOps;
     FfsBuilder* ffsBuilder;
     SearchDialog* searchDialog;
     HexViewDialog* hexViewDialog;
+    GoToBaseDialog* goToBaseDialog;
+    GoToAddressDialog* goToAddressDialog;
     QClipboard* clipboard;
     QString currentDir;
+    QString currentPath;
     QString currentProgramPath;
+    QFont currentFont;
     const QString version;
+    bool markingEnabled;
 
-    bool enableExtractBodyUncompressed(const QModelIndex &current);
+    bool eventFilter(QObject* obj, QEvent* event);
-
     void dragEnterEvent(QDragEnterEvent* event);
     void dropEvent(QDropEvent* event);
     void contextMenuEvent(QContextMenuEvent* event);
@@ -127,7 +159,16 @@ private:
     void showParserMessages();
     void showFinderMessages();
     void showFitTable();
+    void showSecurityInfo();
     void showBuilderMessages();
+
+    enum {
+        TAB_PARSER,
+        TAB_FIT,
+        TAB_SECURITY,
+        TAB_SEARCH,
+        TAB_BUILDER
+    };
 };
 
 #endif // UEFITOOL_H

UEFITool/uefitool.pro

@@ -1,30 +1,44 @@
-QT += core gui
+QT += core gui widgets
-greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
 TARGET = UEFITool
 TEMPLATE = app
 
+CONFIG += c++11
+
+DEFINES += "U_ENABLE_FIT_PARSING_SUPPORT"
+DEFINES += "U_ENABLE_NVRAM_PARSING_SUPPORT"
+DEFINES += "U_ENABLE_ME_PARSING_SUPPORT"
+DEFINES += "U_ENABLE_GUID_DATABASE_SUPPORT"
+
 HEADERS += uefitool.h \
  searchdialog.h \
  hexviewdialog.h \
- messagelistitem.h \
+ gotobasedialog.h \
- guidlineedit.h \
+ gotoaddressdialog.h \
+ hexlineedit.h \
  ffsfinder.h \
+ hexspinbox.h \
+ ../common/fitparser.h \
+ ../common/guiddatabase.h \
  ../common/nvram.h \
+ ../common/nvramparser.h \
+ ../common/meparser.h \
  ../common/ffsops.h \
  ../common/basetypes.h \
  ../common/descriptor.h \
  ../common/gbe.h \
  ../common/me.h \
  ../common/ffs.h \
- ../common/fit.h \
  ../common/peimage.h \
  ../common/types.h \
  ../common/utility.h \
  ../common/parsingdata.h \
  ../common/ffsbuilder.h \
  ../common/ffsparser.h \
+ ../common/ffsreport.h \
  ../common/treeitem.h \
+ ../common/intel_fit.h \
+ ../common/intel_microcode.h \
  ../common/treemodel.h \
  ../common/LZMA/LzmaCompress.h \
  ../common/LZMA/LzmaDecompress.h \
@@ -32,18 +46,61 @@ HEADERS += uefitool.h \
  ../common/Tiano/EfiTianoCompress.h \
  ../common/ustring.h \
  ../common/ubytearray.h \
- ../qhexedit2/qhexedit.h \
+ ../common/umemstream.h \
- ../qhexedit2/chunks.h \
+ ../common/digest/sha1.h \
- ../qhexedit2/commands.h 
+ ../common/digest/sha2.h \
+ ../common/digest/sm3.h \
+ ../common/generated/ami_nvar.h \
+ ../common/generated/apple_sysf.h \
+ ../common/generated/dell_dvar.h \
+ ../common/generated/edk2_vss.h \
+ ../common/generated/edk2_vss2.h \
+ ../common/generated/edk2_ftw.h \
+ ../common/generated/insyde_fdc.h \
+ ../common/generated/insyde_fdm.h \
+ ../common/generated/ms_slic_marker.h \
+ ../common/generated/ms_slic_pubkey.h \
+ ../common/generated/phoenix_flm.h \
+ ../common/generated/phoenix_evsa.h \
+ ../common/generated/intel_acbp_v1.h \
+ ../common/generated/intel_acbp_v2.h \
+ ../common/generated/intel_keym_v1.h \
+ ../common/generated/intel_keym_v2.h \
+ ../common/generated/intel_acm.h \
+ ../common/kaitai/kaitaistream.h \
+ ../common/kaitai/kaitaistruct.h \
+ ../common/kaitai/exceptions.h \
+ ../common/zlib/zlib.h \
+ ../common/zlib/crc32.h \
+ ../version.h \
+ QHexView/include/QHexView/model/buffer/qhexbuffer.h \
+ QHexView/include/QHexView/model/buffer/qdevicebuffer.h \
+ QHexView/include/QHexView/model/buffer/qmemorybuffer.h \
+ QHexView/include/QHexView/model/buffer/qmappedfilebuffer.h \
+ QHexView/include/QHexView/model/commands/hexcommand.h \
+ QHexView/include/QHexView/model/commands/insertcommand.h \
+ QHexView/include/QHexView/model/commands/removecommand.h \
+ QHexView/include/QHexView/model/commands/replacecommand.h \
+ QHexView/include/QHexView/model/qhexcursor.h \
+ QHexView/include/QHexView/model/qhexdelegate.h \
+ QHexView/include/QHexView/model/qhexdocument.h \
+ QHexView/include/QHexView/model/qhexmetadata.h \
+ QHexView/include/QHexView/model/qhexoptions.h \
+ QHexView/include/QHexView/model/qhexutils.h \
+ QHexView/include/QHexView/qhexview.h
 
 SOURCES += uefitool_main.cpp \
  uefitool.cpp \
  searchdialog.cpp \
  hexviewdialog.cpp \
- messagelistitem.cpp \
+ hexlineedit.cpp \
- guidlineedit.cpp \
  ffsfinder.cpp \
+ hexspinbox.cpp \
+ ../common/fitparser.cpp \
+ ../common/guiddatabase.cpp \
  ../common/nvram.cpp \
+ ../common/nvramparser.cpp \
+ ../common/meparser.cpp \
  ../common/ffsops.cpp \
  ../common/types.cpp \
  ../common/descriptor.cpp \
@@ -52,10 +109,14 @@ SOURCES += uefitool_main.cpp \
  ../common/utility.cpp \
  ../common/ffsbuilder.cpp \
  ../common/ffsparser.cpp \
+ ../common/ffsreport.cpp \
  ../common/treeitem.cpp \
  ../common/treemodel.cpp \
  ../common/LZMA/LzmaCompress.c \
  ../common/LZMA/LzmaDecompress.c \
+ ../common/LZMA/SDK/C/CpuArch.c \
+ ../common/LZMA/SDK/C/Bra.c \
+ ../common/LZMA/SDK/C/Bra86.c \
  ../common/LZMA/SDK/C/LzFind.c \
  ../common/LZMA/SDK/C/LzmaDec.c \
  ../common/LZMA/SDK/C/LzmaEnc.c \
@@ -63,15 +124,68 @@ SOURCES += uefitool_main.cpp \
  ../common/Tiano/EfiTianoCompress.c \
  ../common/Tiano/EfiTianoCompressLegacy.c \
  ../common/ustring.cpp \
- ../qhexedit2/qhexedit.cpp \
+ ../common/digest/sha1.c \
- ../qhexedit2/chunks.cpp \
+ ../common/digest/sha256.c \
- ../qhexedit2/commands.cpp
+ ../common/digest/sha512.c \
+ ../common/digest/sm3.c \
+ ../common/generated/ami_nvar.cpp \
+ ../common/generated/apple_sysf.cpp \
+ ../common/generated/dell_dvar.cpp \
+ ../common/generated/edk2_vss.cpp \
+ ../common/generated/edk2_vss2.cpp \
+ ../common/generated/edk2_ftw.cpp \
+ ../common/generated/insyde_fdc.cpp \
+ ../common/generated/insyde_fdm.cpp \
+ ../common/generated/ms_slic_marker.cpp \
+ ../common/generated/ms_slic_pubkey.cpp \
+ ../common/generated/phoenix_flm.cpp \
+ ../common/generated/phoenix_evsa.cpp \
+ ../common/generated/intel_acbp_v1.cpp \
+ ../common/generated/intel_acbp_v2.cpp \
+ ../common/generated/intel_keym_v1.cpp \
+ ../common/generated/intel_keym_v2.cpp \
+ ../common/generated/intel_acm.cpp \
+ ../common/kaitai/kaitaistream.cpp \
+ ../common/zlib/adler32.c \
+ ../common/zlib/compress.c \
+ ../common/zlib/crc32.c \
+ ../common/zlib/deflate.c \
+ ../common/zlib/gzclose.c \
+ ../common/zlib/gzlib.c \
+ ../common/zlib/gzread.c \
+ ../common/zlib/gzwrite.c \
+ ../common/zlib/inflate.c \
+ ../common/zlib/infback.c \
+ ../common/zlib/inftrees.c \
+ ../common/zlib/inffast.c \
+ ../common/zlib/trees.c \
+ ../common/zlib/uncompr.c \
+ ../common/zlib/zutil.c \
+ QHexView/src/model/buffer/qhexbuffer.cpp \
+ QHexView/src/model/buffer/qdevicebuffer.cpp \
+ QHexView/src/model/buffer/qmemorybuffer.cpp \
+ QHexView/src/model/buffer/qmappedfilebuffer.cpp \
+ QHexView/src/model/commands/hexcommand.cpp \
+ QHexView/src/model/commands/insertcommand.cpp \
+ QHexView/src/model/commands/removecommand.cpp \
+ QHexView/src/model/commands/replacecommand.cpp \
+ QHexView/src/model/qhexcursor.cpp \
+ QHexView/src/model/qhexdelegate.cpp \
+ QHexView/src/model/qhexdocument.cpp \
+ QHexView/src/model/qhexmetadata.cpp \
+ QHexView/src/model/qhexutils.cpp \
+ QHexView/src/qhexview.cpp
+
+INCLUDEPATH += QHexView/include/
 
 FORMS += uefitool.ui \
  searchdialog.ui \
- hexviewdialog.ui
+ hexviewdialog.ui \
+ gotobasedialog.ui \
+ gotoaddressdialog.ui
 
+RESOURCES += uefitool.qrc
 RC_FILE = uefitool.rc
-
 ICON = icons/uefitool.icns
-
+QMAKE_BUNDLE_DATA += ICONFILE
+QMAKE_INFO_PLIST = Info.plist

UEFITool/uefitool.qrc

@@ -0,0 +1,5 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+    <file alias="guids.csv">../common/guids.csv</file>
+</qresource>
+</RCC>

UEFITool/uefitool.ui

@@ -132,15 +132,15 @@
            <property name="readOnly">
             <bool>true</bool>
            </property>
-           <property name="centerOnScroll">
-            <bool>false</bool>
-           </property>
           </widget>
          </item>
         </layout>
        </widget>
       </widget>
       <widget class="QTabWidget" name="messagesTabWidget">
+       <property name="enabled">
+        <bool>true</bool>
+       </property>
        <property name="currentIndex">
         <number>0</number>
        </property>
@@ -203,6 +203,44 @@
          </item>
         </layout>
        </widget>
+       <widget class="QWidget" name="securityTab">
+        <property name="enabled">
+         <bool>true</bool>
+        </property>
+        <attribute name="title">
+         <string>Security</string>
+        </attribute>
+        <layout class="QHBoxLayout" name="horizontalLayout">
+         <property name="spacing">
+          <number>0</number>
+         </property>
+         <property name="leftMargin">
+          <number>5</number>
+         </property>
+         <property name="topMargin">
+          <number>5</number>
+         </property>
+         <property name="rightMargin">
+          <number>5</number>
+         </property>
+         <property name="bottomMargin">
+          <number>5</number>
+         </property>
+         <item>
+          <widget class="QPlainTextEdit" name="securityEdit">
+           <property name="acceptDrops">
+            <bool>false</bool>
+           </property>
+           <property name="undoRedoEnabled">
+            <bool>false</bool>
+           </property>
+           <property name="readOnly">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
        <widget class="QWidget" name="finderTab">
         <attribute name="title">
          <string>Search</string>
@@ -273,7 +311,7 @@
      <x>0</x>
      <y>0</y>
      <width>851</width>
-     <height>21</height>
+     <height>31</height>
     </rect>
    </property>
    <widget class="QMenu" name="menuFile">
@@ -284,7 +322,12 @@
     <addaction name="actionOpenImageFileInNewWindow"/>
     <addaction name="actionSaveImageFile"/>
     <addaction name="separator"/>
-    <addaction name="actionSearch"/>
+    <addaction name="actionGenerateReport"/>
+    <addaction name="separator"/>
+    <addaction name="actionLoadGuidDatabase"/>
+    <addaction name="actionLoadDefaultGuidDatabase"/>
+    <addaction name="actionUnloadGuidDatabase"/>
+    <addaction name="actionExportDiscoveredGuids"/>
     <addaction name="separator"/>
     <addaction name="actionQuit"/>
    </widget>
@@ -300,15 +343,23 @@
      <string>&amp;Action</string>
     </property>
     <widget class="QMenu" name="menuCapsuleActions">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="title">
       <string>&amp;Capsule</string>
      </property>
      <addaction name="actionHexView"/>
+     <addaction name="actionBodyHexView"/>
+     <addaction name="actionUncompressedHexView"/>
      <addaction name="separator"/>
      <addaction name="actionExtract"/>
      <addaction name="actionExtractBody"/>
     </widget>
     <widget class="QMenu" name="menuImageActions">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="title">
       <string>&amp;Image</string>
      </property>
@@ -317,6 +368,9 @@
      <addaction name="actionExtract"/>
     </widget>
     <widget class="QMenu" name="menuRegionActions">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="title">
       <string>&amp;Region</string>
      </property>
@@ -329,6 +383,9 @@
      <addaction name="actionReplace"/>
     </widget>
     <widget class="QMenu" name="menuPaddingActions">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="title">
       <string>&amp;Padding</string>
      </property>
@@ -337,10 +394,15 @@
      <addaction name="actionExtract"/>
     </widget>
     <widget class="QMenu" name="menuVolumeActions">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="title">
       <string>&amp;Volume</string>
      </property>
      <addaction name="actionHexView"/>
+     <addaction name="actionBodyHexView"/>
+     <addaction name="actionUncompressedHexView"/>
      <addaction name="separator"/>
      <addaction name="actionExtract"/>
      <addaction name="actionExtractBody"/>
@@ -353,10 +415,15 @@
      <addaction name="actionReplaceBody"/>
     </widget>
     <widget class="QMenu" name="menuFileActions">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="title">
       <string>&amp;File</string>
      </property>
      <addaction name="actionHexView"/>
+     <addaction name="actionBodyHexView"/>
+     <addaction name="actionUncompressedHexView"/>
      <addaction name="separator"/>
      <addaction name="actionExtract"/>
      <addaction name="actionExtractBody"/>
@@ -373,10 +440,15 @@
      <addaction name="actionRemove"/>
     </widget>
     <widget class="QMenu" name="menuSectionActions">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="title">
       <string>&amp;Section</string>
      </property>
      <addaction name="actionHexView"/>
+     <addaction name="actionBodyHexView"/>
+     <addaction name="actionUncompressedHexView"/>
      <addaction name="separator"/>
      <addaction name="actionExtract"/>
      <addaction name="actionExtractBody"/>
@@ -393,7 +465,10 @@
      <addaction name="separator"/>
      <addaction name="actionRemove"/>
     </widget>
-    <widget class="QMenu" name="menuMessages">
+    <widget class="QMenu" name="menuMessageActions">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="title">
       <string>&amp;Messages</string>
      </property>
@@ -402,11 +477,16 @@
      <addaction name="separator"/>
      <addaction name="actionMessagesClear"/>
     </widget>
-    <widget class="QMenu" name="menuVariableActions">
+    <widget class="QMenu" name="menuEntryActions">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="title">
-      <string>Variable</string>
+      <string>&amp;Entry</string>
      </property>
      <addaction name="actionHexView"/>
+     <addaction name="actionBodyHexView"/>
+     <addaction name="actionUncompressedHexView"/>
      <addaction name="separator"/>
      <addaction name="actionGoToData"/>
      <addaction name="separator"/>
@@ -424,10 +504,15 @@
      <addaction name="actionRemove"/>
     </widget>
     <widget class="QMenu" name="menuStoreActions">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="title">
       <string>S&amp;tore</string>
      </property>
      <addaction name="actionHexView"/>
+     <addaction name="actionBodyHexView"/>
+     <addaction name="actionUncompressedHexView"/>
      <addaction name="separator"/>
      <addaction name="actionExtract"/>
      <addaction name="actionExtractBody"/>
@@ -441,6 +526,10 @@
      <addaction name="actionReplace"/>
      <addaction name="actionReplaceBody"/>
     </widget>
+    <addaction name="actionGoToBase"/>
+    <addaction name="actionGoToAddress"/>
+    <addaction name="actionSearch"/>
+    <addaction name="separator"/>
     <addaction name="menuCapsuleActions"/>
     <addaction name="menuImageActions"/>
     <addaction name="menuRegionActions"/>
@@ -448,13 +537,21 @@
     <addaction name="menuVolumeActions"/>
     <addaction name="menuFileActions"/>
     <addaction name="menuSectionActions"/>
-    <addaction name="menuStoreActions"/>
-    <addaction name="menuVariableActions"/>
     <addaction name="separator"/>
-    <addaction name="menuMessages"/>
+    <addaction name="menuStoreActions"/>
+    <addaction name="menuEntryActions"/>
+    <addaction name="separator"/>
+    <addaction name="menuMessageActions"/>
+   </widget>
+   <widget class="QMenu" name="menuView">
+    <property name="title">
+     <string>&amp;View</string>
+    </property>
+    <addaction name="actionToggleBootGuardMarking"/>
    </widget>
    <addaction name="menuFile"/>
    <addaction name="menuAction"/>
+   <addaction name="menuView"/>
    <addaction name="menuHelp"/>
   </widget>
   <action name="actionInsertAfter">
@@ -609,6 +706,9 @@
    <property name="text">
     <string>About &amp;Qt</string>
    </property>
+   <property name="shortcut">
+    <string>Shift+F1</string>
+   </property>
    <property name="menuRole">
     <enum>QAction::AboutQtRole</enum>
    </property>
@@ -617,6 +717,9 @@
    <property name="text">
     <string>&amp;Quit</string>
    </property>
+   <property name="shortcut">
+    <string>Alt+X</string>
+   </property>
    <property name="menuRole">
     <enum>QAction::QuitRole</enum>
    </property>
@@ -626,13 +729,16 @@
     <bool>false</bool>
    </property>
    <property name="text">
-    <string>Sear&amp;ch...</string>
+    <string>Searc&amp;h...</string>
    </property>
    <property name="shortcut">
     <string>Ctrl+F</string>
    </property>
   </action>
   <action name="actionMessagesClear">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
    <property name="text">
     <string>Clea&amp;r</string>
    </property>
@@ -658,6 +764,9 @@
    </property>
   </action>
   <action name="actionMessagesCopy">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
    <property name="text">
     <string>&amp;Copy</string>
    </property>
@@ -666,6 +775,9 @@
    </property>
   </action>
   <action name="actionMessagesCopyAll">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
    <property name="text">
     <string>Copy &amp;all</string>
    </property>
@@ -700,7 +812,10 @@
     <bool>false</bool>
    </property>
    <property name="text">
-    <string>Go to &amp;data</string>
+    <string>Go &amp;to data</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+T</string>
    </property>
   </action>
   <action name="actionHexView">
@@ -714,6 +829,113 @@
     <string>Ctrl+D</string>
    </property>
   </action>
+  <action name="actionGoToBase">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>&amp;Select item at base...</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+G</string>
+   </property>
+  </action>
+  <action name="actionBodyHexView">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>Body hex vie&amp;w...</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Shift+D</string>
+   </property>
+  </action>
+  <action name="actionUncompressedHexView">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>Un&amp;compressed hex view...</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Alt+D</string>
+   </property>
+  </action>
+  <action name="actionLoadGuidDatabase">
+   <property name="text">
+    <string>Load &amp;GUID database...</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Alt+G</string>
+   </property>
+  </action>
+  <action name="actionGoToAddress">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>Select item at &amp;address...</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Shift+G</string>
+   </property>
+  </action>
+  <action name="actionToggleBootGuardMarking">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="checked">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>BootGuard &amp;markings</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Shift+B</string>
+   </property>
+  </action>
+  <action name="actionGenerateReport">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>Generate &amp;report...</string>
+   </property>
+   <property name="toolTip">
+    <string>Generate report</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Alt+R</string>
+   </property>
+  </action>
+  <action name="actionUnloadGuidDatabase">
+   <property name="text">
+    <string>&amp;Unload GUID database</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Alt+U</string>
+   </property>
+  </action>
+  <action name="actionLoadDefaultGuidDatabase">
+   <property name="text">
+    <string>Load &amp;default GUID database</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Alt+D</string>
+   </property>
+  </action>
+  <action name="actionExportDiscoveredGuids">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>&amp;Export discovered GUIDs...</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Alt+E</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources/>

UEFITool/uefitool_main.cpp

@@ -1,6 +1,6 @@
 /* uefitool_main.cpp
  
-  Copyright (c) 2014, Nikolaj Schlej. All rights reserved.
+ Copyright (c) 2022, Nikolaj Schlej. All rights reserved.
  This program and the accompanying materials
  are licensed and made available under the terms and conditions of the BSD License
  which accompanies this distribution.  The full text of the license may be found at
@@ -15,18 +15,50 @@
 #include <QString>
 #include "uefitool.h"
 
+class UEFIToolApplication : public QApplication
+{
+    UEFITool* tool;
+    
+public:
+    UEFIToolApplication(int &argc, char **argv)
+    : QApplication(argc, argv)
+    {
+        setOrganizationName("CodeRush");
+        setOrganizationDomain("coderush.me");
+        setApplicationName("UEFITool");
+#if QT_VERSION >= QT_VERSION_CHECK(5, 7, 0)
+        setDesktopFileName("uefitool");
+#endif
+        tool = new UEFITool();
+    }
+    
+    virtual ~UEFIToolApplication() {
+        delete tool;
+    }
+    
+    virtual bool event(QEvent *event)
+    {
+        if (event->type() == QEvent::FileOpen) {
+            QFileOpenEvent *openEvent = static_cast<QFileOpenEvent *>(event);
+            tool->openImageFile(openEvent->file());
+        }
+        
+        return QApplication::event(event);
+    }
+    
+    int startup()
+    {
+        tool->setProgramPath(arguments().at(0));
+        if (arguments().length() > 1)
+            tool->openImageFile(arguments().at(1));
+        tool->show();
+        
+        return exec();
+    }
+};
+
 int main(int argc, char *argv[])
 {
-    QApplication a(argc, argv);
+    UEFIToolApplication a(argc, argv);
-    a.setOrganizationName("CodeRush");
+    return a.startup();
-    a.setOrganizationDomain("coderush.me");
-    a.setApplicationName("UEFITool");
-
-    UEFITool w;
-    w.setProgramPath(a.arguments().at(0));
-    if (a.arguments().length() > 1)
-        w.openImageFile(a.arguments().at(1));
-    w.show();
-
-    return a.exec();
 }

appstream/appdata.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component type="desktop">
+  <id>com.github.LongSoft.UEFITool</id>
+  <launchable type="desktop-id">com.github.LongSoft.UEFITool.desktop</launchable>
+  <name>UEFITool</name>
+  <summary>UEFI firmware image viewer and editor</summary>
+  <description>
+    <p>UEFITool is a cross-platform open source application, that parses UEFI PI-compatible firmware image into a tree structure, verifies image integrity and provides a GUI to manipulate image elements.</p>
+  </description>
+  <screenshots>
+    <screenshot type="default">
+      <image type="source">https://github.com/LongSoft/UEFITool/raw/new_engine/appstream/UEFITool.png</image>
+    </screenshot>
+  </screenshots>
+  <releases>
+    <release version="A70" date="2025-03-13" />
+  </releases>
+  <url type="homepage">https://github.com/LongSoft/UEFITool</url>
+  <developer_name>LongSoft</developer_name>
+  <metadata_license>CC0-1.0</metadata_license>
+  <project_license>BSD-2-Clause</project_license>
+  <content_rating type="oars-1.1" />
+</component>

bstrlib/README.md

@@ -1,34 +0,0 @@
-The Better String Library
-
-The Better String Library is an abstraction of a string data type which is
-superior to the C library char buffer string type, or C++'s std::string.
-Among the features achieved are:
-
-  - Substantial mitigation of buffer overflow/overrun problems and other
-    failures that result from erroneous usage of the common C string
-    library functions
-
-  - Significantly simplified string manipulation
-
-  - High performance interoperability with other source/libraries which
-    expect '\0' terminated char buffers
-
-  - Improved overall performance of common string operations
-
-  - Functional equivalency with other more modern languages
-
-The library is totally stand alone, portable (known to work with gcc/g++,
-MSVC++, Intel C++, WATCOM C/C++, Turbo C, Borland C++, IBM's native CC
-compiler on Windows, Linux and Mac OS X), high performance, easy to use and
-is not part of some other collection of data structures. Even the file I/O
-functions are totally abstracted (so that other stream-like mechanisms, like
-sockets, can be used.) Nevertheless, it is adequate as a complete
-replacement of the C string library for string manipulation in any C program.
-
-The library includes a robust C++ wrapper that uses overloaded operators,
-rich constructors, exceptions, stream I/O and STL to make the CBString
-struct a natural and powerful string abstraction with more functionality and
-higher performance than std::string.
-
-Bstrlib is stable, well tested and suitable for any software production
-environment.

bstrlib/bsafe.c

@@ -1,82 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source
- * license. Refer to the accompanying documentation for details on usage and
- * license.
- */
-
-/*
- * bsafe.c
- *
- * This is an optional module that can be used to help enforce a safety
- * standard based on pervasive usage of bstrlib.  This file is not necessarily
- * portable, however, it has been tested to work correctly with Intel's C/C++
- * compiler, WATCOM C/C++ v11.x and Microsoft Visual C++.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "bsafe.h"
-
-static int bsafeShouldExit = 1;
-
-char * strcpy (char *dst, const char *src);
-char * strcat (char *dst, const char *src);
-
-char * strcpy (char *dst, const char *src) {
-	(void) dst;
-	(void) src;
-	fprintf (stderr, "bsafe error: strcpy() is not safe, use bstrcpy instead.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-char * strcat (char *dst, const char *src) {
-	(void) dst;
-	(void) src;
-	fprintf (stderr, "bsafe error: strcat() is not safe, use bstrcat instead.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-#if !defined (__GNUC__) && (!defined(_MSC_VER) || (_MSC_VER <= 1310))
-char * (gets) (char * buf) {
-	(void) buf;
-	fprintf (stderr, "bsafe error: gets() is not safe, use bgets.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-#endif
-
-char * (strncpy) (char *dst, const char *src, size_t n) {
-	(void) dst;
-	(void) src;
-	(void) n;
-	fprintf (stderr, "bsafe error: strncpy() is not safe, use bmidstr instead.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-char * (strncat) (char *dst, const char *src, size_t n) {
-	(void) dst;
-	(void) src;
-	(void) n;
-	fprintf (stderr, "bsafe error: strncat() is not safe, use bstrcat then btrunc\n\tor cstr2tbstr, btrunc then bstrcat instead.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-char * (strtok) (char *s1, const char *s2) {
-	(void) s1;
-	(void) s2;
-	fprintf (stderr, "bsafe error: strtok() is not safe, use bsplit or bsplits instead.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-char * (strdup) (const char *s) {
-	(void) s;
-	fprintf (stderr, "bsafe error: strdup() is not safe, use bstrcpy.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}

bstrlib/bsafe.h

@@ -1,43 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2004, and is covered by the BSD open source 
- * license. Refer to the accompanying documentation for details on usage and 
- * license.
- */
-
-/*
- * bsafe.h
- *
- * This is an optional module that can be used to help enforce a safety
- * standard based on pervasive usage of bstrlib.  This file is not necessarily
- * portable, however, it has been tested to work correctly with Intel's C/C++
- * compiler, WATCOM C/C++ v11.x and Microsoft Visual C++.
- */
-
-#ifndef BSTRLIB_BSAFE_INCLUDE
-#define BSTRLIB_BSAFE_INCLUDE
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined (__GNUC__) && (!defined(_MSC_VER) || (_MSC_VER <= 1310))
-/* This is caught in the linker, so its not necessary for gcc. */
-extern char * (gets) (char * buf);
-#endif
-
-extern char * (strncpy) (char *dst, const char *src, size_t n);
-extern char * (strncat) (char *dst, const char *src, size_t n);
-extern char * (strtok) (char *s1, const char *s2);
-extern char * (strdup) (const char *s);
-
-#undef strcpy
-#undef strcat
-#define strcpy(a,b) bsafe_strcpy(a,b) 
-#define strcat(a,b) bsafe_strcat(a,b) 
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

bstrlib/bstraux.h

@@ -1,115 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source
- * license and the GPL. Refer to the accompanying documentation for details
- * on usage and license.
- */
-
-/*
- * bstraux.h
- *
- * This file is not a necessary part of the core bstring library itself, but
- * is just an auxilliary module which includes miscellaneous or trivial
- * functions.
- */
-
-#ifndef BSTRAUX_INCLUDE
-#define BSTRAUX_INCLUDE
-
-#include <time.h>
-#include "bstrlib.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Safety mechanisms */
-#define bstrDeclare(b)               bstring (b) = NULL;
-#define bstrFree(b)                  {if ((b) != NULL && (b)->slen >= 0 && (b)->mlen >= (b)->slen) { bdestroy (b); (b) = NULL; }}
-
-/* Backward compatibilty with previous versions of Bstrlib */
-#if !defined(BSTRLIB_REDUCE_NAMESPACE_POLLUTION)
-#define bAssign(a,b)                 ((bassign)((a), (b)))
-#define bSubs(b,pos,len,a,c)         ((breplace)((b),(pos),(len),(a),(unsigned char)(c)))
-#define bStrchr(b,c)                 ((bstrchr)((b), (c)))
-#define bStrchrFast(b,c)             ((bstrchr)((b), (c)))
-#define bCatCstr(b,s)                ((bcatcstr)((b), (s)))
-#define bCatBlk(b,s,len)             ((bcatblk)((b),(s),(len)))
-#define bCatStatic(b,s)              bcatStatic(b,s)
-#define bTrunc(b,n)                  ((btrunc)((b), (n)))
-#define bReplaceAll(b,find,repl,pos) ((bfindreplace)((b),(find),(repl),(pos)))
-#define bUppercase(b)                ((btoupper)(b))
-#define bLowercase(b)                ((btolower)(b))
-#define bCaselessCmp(a,b)            ((bstricmp)((a), (b)))
-#define bCaselessNCmp(a,b,n)         ((bstrnicmp)((a), (b), (n)))
-#define bBase64Decode(b)             (bBase64DecodeEx ((b), NULL))
-#define bUuDecode(b)                 (bUuDecodeEx ((b), NULL))
-#endif
-
-/* Unusual functions */
-extern struct bStream * bsFromBstr (const_bstring b);
-extern bstring bTail (bstring b, int n);
-extern bstring bHead (bstring b, int n);
-extern int bSetCstrChar (bstring a, int pos, char c);
-extern int bSetChar (bstring b, int pos, char c);
-extern int bFill (bstring a, char c, int len);
-extern int bReplicate (bstring b, int n);
-extern int bReverse (bstring b);
-extern int bInsertChrs (bstring b, int pos, int len, unsigned char c, unsigned char fill);
-extern bstring bStrfTime (const char * fmt, const struct tm * timeptr);
-#define bAscTime(t) (bStrfTime ("%c\n", (t)))
-#define bCTime(t)   ((t) ? bAscTime (localtime (t)) : NULL)
-
-/* Spacing formatting */
-extern int bJustifyLeft (bstring b, int space);
-extern int bJustifyRight (bstring b, int width, int space);
-extern int bJustifyMargin (bstring b, int width, int space);
-extern int bJustifyCenter (bstring b, int width, int space);
-
-/* Esoteric standards specific functions */
-extern char * bStr2NetStr (const_bstring b);
-extern bstring bNetStr2Bstr (const char * buf);
-extern bstring bBase64Encode (const_bstring b);
-extern bstring bBase64DecodeEx (const_bstring b, int * boolTruncError);
-extern struct bStream * bsUuDecode (struct bStream * sInp, int * badlines);
-extern bstring bUuDecodeEx (const_bstring src, int * badlines);
-extern bstring bUuEncode (const_bstring src);
-extern bstring bYEncode (const_bstring src);
-extern bstring bYDecode (const_bstring src);
-extern int bSGMLEncode (bstring b);
-
-/* Writable stream */
-typedef int (* bNwrite) (const void * buf, size_t elsize, size_t nelem, void * parm);
-
-struct bwriteStream * bwsOpen (bNwrite writeFn, void * parm);
-int bwsWriteBstr (struct bwriteStream * stream, const_bstring b);
-int bwsWriteBlk (struct bwriteStream * stream, void * blk, int len);
-int bwsWriteFlush (struct bwriteStream * stream);
-int bwsIsEOF (const struct bwriteStream * stream);
-int bwsBuffLength (struct bwriteStream * stream, int sz);
-void * bwsClose (struct bwriteStream * stream);
-
-/* Security functions */
-#define bSecureDestroy(b) {                                             \
-bstring bstr__tmp = (b);                                                \
-    if (bstr__tmp && bstr__tmp->mlen > 0 && bstr__tmp->data) {          \
-        (void) memset (bstr__tmp->data, 0, (size_t) bstr__tmp->mlen);   \
-        bdestroy (bstr__tmp);                                           \
-    }                                                                   \
-}
-#define bSecureWriteProtect(t) {                                                  \
-    if ((t).mlen >= 0) {                                                          \
-        if ((t).mlen > (t).slen)) {                                               \
-            (void) memset ((t).data + (t).slen, 0, (size_t) (t).mlen - (t).slen); \
-        }                                                                         \
-        (t).mlen = -1;                                                            \
-    }                                                                             \
-}
-extern bstring bSecureInput (int maxlen, int termchar,
-                             bNgetc vgetchar, void * vgcCtx);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

bstrlib/buniutil.c

@@ -1,274 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source
- * license and the GPL. Refer to the accompanying documentation for details
- * on usage and license.
- */
-
-/*
- * buniutil.c
- *
- * This file is not necessarily part of the core bstring library itself, but
- * is just an implementation of basic utf8 processing for bstrlib.  Note that
- * this module is dependent upon bstrlib.c and utf8util.c
- */
-
-#include "bstrlib.h"
-#include "buniutil.h"
-
-#define UNICODE__CODE_POINT__REPLACEMENT_CHARACTER (0xFFFDL)
-
-/*  int buIsUTF8Content (const_bstring bu)
- *
- *  Scan string and return 1 if its entire contents is entirely UTF8 code
- *  points.  Otherwise return 0.
- */
-int buIsUTF8Content (const_bstring bu) {
-struct utf8Iterator iter;
-
-	if (NULL == bdata (bu)) return 0;
-	for (utf8IteratorInit (&iter, bu->data, bu->slen);
-	     iter.next < iter.slen;) {
-		if (0 >= utf8IteratorGetNextCodePoint (&iter, -1)) return 0;
-	}
-	return 1;
-}
-
-/*  int buGetBlkUTF16 (cpUcs2* ucs2, int len, cpUcs4 errCh, const_bstring bu,
- *                     int pos)
- *
- *  Convert a string of UTF8 codepoints (bu) skipping the first pos, into a
- *  sequence of UTF16 encoded code points.  Returns the number of UCS2 16-bit
- *  words written to the output.  No more than len words are written to the
- *  target array ucs2.  If any code point in bu is unparsable, it will be
- *  translated to errCh.
- */
-int buGetBlkUTF16 (/* @out */ cpUcs2* ucs2, int len, cpUcs4 errCh, const_bstring bu, int pos) {
-struct tagbstring t;
-struct utf8Iterator iter;
-cpUcs4 ucs4;
-int i, j;
-
-	if (!isLegalUnicodeCodePoint (errCh)) errCh = UNICODE__CODE_POINT__REPLACEMENT_CHARACTER;
-	if (NULL == ucs2 || 0 >= len || NULL == bdata (bu) || 0 > pos) return BSTR_ERR;
-
-	for (j=0, i=0; j < bu->slen; j++) {
-		if (0x80 != (0xC0 & bu->data[j])) {
-			if (i >= pos) break;
-			i++;
-		}
-	}
-
-	t.mlen = -1;
-	t.data = bu->data + j;
-	t.slen = bu->slen - j;
-
-	utf8IteratorInit (&iter, t.data, t.slen);
-
-	ucs4 = BSTR_ERR;
-	for (i=0; 0 < len && iter.next < iter.slen &&
-	          0 <= (ucs4 = utf8IteratorGetNextCodePoint (&iter, errCh)); i++) {
-		if (ucs4 < 0x10000) {
-			*ucs2++ = (cpUcs2) ucs4;
-			len--;
-		} else {
-			if (len < 2) {
-				*ucs2++ = UNICODE__CODE_POINT__REPLACEMENT_CHARACTER;
-				len--;
-			} else {
-				long y = ucs4 - 0x10000;
-				ucs2[0] = (cpUcs2) (0xD800 | (y >> 10));
-				ucs2[1] = (cpUcs2) (0xDC00 | (y & 0x03FF));
-				len -= 2;
-				ucs2 += 2;
-				i++;
-			}
-		}
-	}
-	while (0 < len) {
-		*ucs2++ = 0;
-		len--;
-	}
-
-	utf8IteratorUninit (&iter);
-	if (0 > ucs4) return BSTR_ERR;
-	return i;
-}
-
-/*
-
-Unicode                   UTF-8
--------                   -----
-U-00000000 - U-0000007F:  0xxxxxxx
-U-00000080 - U-000007FF:  110xxxxx 10xxxxxx
-U-00000800 - U-0000FFFF:  1110xxxx 10xxxxxx 10xxxxxx
-U-00010000 - U-001FFFFF:  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-
-U-00200000 - U-03FFFFFF:  111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
-U-04000000 - U-7FFFFFFF:  1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
-
-UTF-32: U-000000 - U-10FFFF
-
-*/
-
-/*  int buAppendBlkUcs4 (bstring b, const cpUcs4* bu, int len, cpUcs4 errCh)
- *
- *  Convert an array of UCS4 code points (bu) to UTF8 codepoints b.  Any
- *  invalid code point is replaced by errCh.  If errCh is itself not a
- *  valid code point, then this translation will halt upon the first error
- *  and return BSTR_ERR.  Otherwise BSTR_OK is returned.
- */
-int buAppendBlkUcs4 (bstring b, const cpUcs4* bu, int len, cpUcs4 errCh) {
-int i, oldSlen;
-
-	if (NULL == bu || NULL == b || 0 > len || 0 > (oldSlen = blengthe (b, -1))) return BSTR_ERR;
-	if (!isLegalUnicodeCodePoint (errCh)) errCh = ~0;
-
-	for (i=0; i < len; i++) {
-		unsigned char c[6];
-		cpUcs4 v = bu[i];
-
-		if (!isLegalUnicodeCodePoint (v)) {
-			if (~0 == errCh) {
-				b->slen = oldSlen;
-				return BSTR_ERR;
-			}
-			v = errCh;
-		}
-
-		if (v < 0x80) {
-			if (BSTR_OK != bconchar (b, (char) v)) {
-				b->slen = oldSlen;
-				return BSTR_ERR;
-			}
-		} else if (v < 0x800) {
-			c[0] = (unsigned char) ( (v >>  6)         + 0xc0);
-			c[1] = (unsigned char) ((        v & 0x3f) + 0x80);
-			if (BSTR_OK != bcatblk (b, c, 2)) {
-				b->slen = oldSlen;
-				return BSTR_ERR;
-			}
-		} else if (v < 0x10000) {
-			c[0] = (unsigned char) ( (v >> 12)         + 0xe0);
-			c[1] = (unsigned char) (((v >>  6) & 0x3f) + 0x80);
-			c[2] = (unsigned char) ((        v & 0x3f) + 0x80);
-			if (BSTR_OK != bcatblk (b, c, 3)) {
-				b->slen = oldSlen;
-				return BSTR_ERR;
-			}
-		} else
-#if 0
-			if (v < 0x200000)
-#endif
-		{
-			c[0] = (unsigned char) ( (v >> 18)         + 0xf0);
-			c[1] = (unsigned char) (((v >> 12) & 0x3f) + 0x80);
-			c[2] = (unsigned char) (((v >>  6) & 0x3f) + 0x80);
-			c[3] = (unsigned char) ((        v & 0x3f) + 0x80);
-			if (BSTR_OK != bcatblk (b, c, 4)) {
-				b->slen = oldSlen;
-				return BSTR_ERR;
-			}
-		}
-#if 0
-		else if (v < 0x4000000) {
-			c[0] = (unsigned char) ( (v >> 24)         + 0xf8);
-			c[1] = (unsigned char) (((v >> 18) & 0x3f) + 0x80);
-			c[2] = (unsigned char) (((v >> 12) & 0x3f) + 0x80);
-			c[3] = (unsigned char) (((v >>  6) & 0x3f) + 0x80);
-			c[4] = (unsigned char) ((        v & 0x3f) + 0x80);
-			if (BSTR_OK != bcatblk (b, c, 5)) {
-				b->slen = oldSlen;
-				return BSTR_ERR;
-			}
-		} else {
-			c[0] = (unsigned char) ( (v >> 30)         + 0xfc);
-			c[1] = (unsigned char) (((v >> 24) & 0x3f) + 0x80);
-			c[2] = (unsigned char) (((v >> 18) & 0x3f) + 0x80);
-			c[3] = (unsigned char) (((v >> 12) & 0x3f) + 0x80);
-			c[4] = (unsigned char) (((v >>  6) & 0x3f) + 0x80);
-			c[5] = (unsigned char) ((        v & 0x3f) + 0x80);
-			if (BSTR_OK != bcatblk (b, c, 6)) {
-				b->slen = oldSlen;
-				return BSTR_ERR;
-			}
-		}
-#endif
-	}
-	return BSTR_OK;
-}
-
-#define endSwap(cs,mode) ((mode) ? ((((cs) & 0xFF) << 8) | (((cs) >> 8) & 0xFF)) : (cs))
-#define TEMP_UCS4_BUFFER_SIZE (64)
-
-/*  int buAppendBlkUTF16 (bstring bu, const cpUcs2* utf16, int len,
- *                        cpUcs2* bom, cpUcs4 errCh)
- *
- *  Append an array of UCS2 code points (utf16) to UTF8 codepoints (bu).  Any
- *  invalid code point is replaced by errCh.  If errCh is itself not a
- *  valid code point, then this translation will halt upon the first error
- *  and return BSTR_ERR.  Otherwise BSTR_OK is returned.  If a byte order mark
- *  has been previously read, it may be passed in as bom, otherwise if *bom is
- *  set to 0, it will be filled in with the BOM as read from the first
- *  character if it is a BOM.
- */
-int buAppendBlkUTF16 (bstring bu, const cpUcs2* utf16, int len, cpUcs2* bom, cpUcs4 errCh) {
-cpUcs4 buff[TEMP_UCS4_BUFFER_SIZE];
-int cc, i, sm, oldSlen;
-
-	if (NULL == bdata(bu) || NULL == utf16 || len < 0) return BSTR_ERR;
-	if (!isLegalUnicodeCodePoint (errCh)) errCh = ~0;
-	if (len == 0) return BSTR_OK;
-
-	oldSlen = bu->slen;
-	i = 0;
-
-	/* Check for BOM character and select endianess.  Also remove the
-	   BOM from the stream, since there is no need for it in a UTF-8 encoding. */
-	if (bom && (cpUcs2) 0xFFFE == *bom) {
-		sm = 8;
-	} else if (bom && (cpUcs2) 0xFEFF == *bom) {
-		sm = 0;
-	} else if (utf16[i] == (cpUcs2) 0xFFFE) {
-		if (bom) *bom = utf16[i];
-		sm = 8;
-		i++;
-	} else if (utf16[i] == (cpUcs2) 0xFEFF) {
-		if (bom) *bom = utf16[i];
-		sm = 0;
-		i++;
-	} else {
-		sm = 0; /* Assume local endianness. */
-	}
-
-	cc = 0;
-	for (;i < len; i++) {
-		cpUcs4 c, v;
-		v = endSwap (utf16[i], sm);
-
-		if ((v | 0x7FF) == 0xDFFF) { /* Deal with surrogate pairs */
-			if (v >= 0xDC00 || i >= len) {
-				ErrMode:;
-				if (~0 == errCh) {
-					ErrReturn:;
-					bu->slen = oldSlen;
-					return BSTR_ERR;
-				}
-				v = errCh;
-			} else {
-				i++;
-				if ((c = endSwap (utf16[i], sm) - 0xDC00) > 0x3FF) goto ErrMode;
-				v = ((v - 0xD800) << 10) + c + 0x10000;
-			}
-		}
-		buff[cc] = v;
-		cc++;
-		if (cc >= TEMP_UCS4_BUFFER_SIZE) {
-			if (0 > buAppendBlkUcs4 (bu, buff, cc, errCh)) goto ErrReturn;
-			cc = 0;
-		}
-	}
-	if (cc > 0 && 0 > buAppendBlkUcs4 (bu, buff, cc, errCh)) goto ErrReturn;
-
-	return BSTR_OK;
-}

bstrlib/buniutil.h

@@ -1,37 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source
- * license and the GPL. Refer to the accompanying documentation for details
- * on usage and license.
- */
-
-/*
- * buniutil.h
- *
- * This file is the interface for the buniutil basic "Unicode for bstrings"
- * functions.  Note that there are dependencies on bstrlib.h and utf8util.h .
- */
-
-#ifndef BSTRLIB_UNICODE_UTILITIES
-#define BSTRLIB_UNICODE_UTILITIES
-
-#include "utf8util.h"
-#include "bstrlib.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern int buIsUTF8Content (const_bstring bu);
-extern int buAppendBlkUcs4 (bstring b, const cpUcs4* bu, int len, cpUcs4 errCh);
-
-/* For those unfortunate enough to be stuck supporting UTF16. */
-extern int buGetBlkUTF16 (/* @out */ cpUcs2* ucs2, int len, cpUcs4 errCh, const_bstring bu, int pos);
-extern int buAppendBlkUTF16 (bstring bu, const cpUcs2* utf16, int len, cpUcs2* bom, cpUcs4 errCh);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* BSTRLIB_UNICODE_UTILITIES */
-

bstrlib/gpl.txt

@@ -1,339 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-	    How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.

bstrlib/porting.txt

@@ -1,172 +0,0 @@
-Better String library Porting Guide
------------------------------------
-
-by Paul Hsieh
-
-The bstring library is an attempt to provide improved string processing 
-functionality to the C and C++ language.  At the heart of the bstring library 
-is the management of "bstring"s which are a significant improvement over '\0'
-terminated char buffers.  See the accompanying documenation file bstrlib.txt
-for more information.
-
-===============================================================================
-
-Identifying the Compiler
-------------------------
-
-Bstrlib has been tested on the following compilers:
-
-    Microsoft Visual C++
-    Watcom C/C++ (32 bit flat)
-    Intel's C/C++ compiler (on Windows)
-    The GNU C/C++ compiler (on Windows/Linux on x86 and PPC64)
-    Borland C++
-    Turbo C
-
-There are slight differences in these compilers which requires slight 
-differences in the implementation of Bstrlib.  These are accomodated in the
-same sources using #ifdef/#if defined() on compiler specific macros.  To
-port Bstrlib to a new compiler not listed above, it is recommended that the
-same strategy be followed.  If you are unaware of the compiler specific 
-identifying preprocessor macro for your compiler you might find it here:
-
-http://predef.sourceforge.net/precomp.html
-
-Note that Intel C/C++ on Windows sets the Microsoft identifier: _MSC_VER.
-
-16-bit vs. 32-bit vs. 64-bit Systems
-------------------------------------
-
-Bstrlib has been architected to deal with strings of length between 0 and
-INT_MAX (inclusive).  Since the values of int are never higher than size_t
-there will be no issue here.  Note that on most 64-bit systems int is 32-bit.
-
-Dependency on The C-Library
----------------------------
-
-Bstrlib uses the functions memcpy, memmove, malloc, realloc, free and 
-vsnprintf.  Many free standing C compiler implementations that have a mode in 
-which the C library is not available will typically not include these 
-functions which will make porting Bstrlib to it onerous.  Bstrlib is not 
-designed for such bare bones compiler environments.  This usually includes 
-compilers that target ROM environments.
-
-Porting Issues
---------------
-
-Bstrlib has been written completely in ANSI/ISO C and ISO C++, however, there 
-are still a few porting issues.  These are described below.
-
-1. The vsnprintf () function.
-
-Unfortunately, the earlier ANSI/ISO C standards did not include this function.
-If the compiler of interest does not support this function then the 
-BSTRLIB_NOVSNP should be defined via something like:
-
-    #if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP)
-    # if defined (__TURBOC__) || defined (__COMPILERVENDORSPECIFICMACRO__)
-    #  define BSTRLIB_NOVSNP
-    # endif
-    #endif
-
-which appears at the top of bstrlib.h.  Note that the bformat(a) functions 
-will not be declared or implemented if the BSTRLIB_NOVSNP macro is set.  If 
-the compiler has renamed vsnprintf() to some other named function, then 
-search for the definition of the exvsnprintf macro in bstrlib.c file and be 
-sure its defined appropriately:
-
-    #if defined (__COMPILERVENDORSPECIFICMACRO__)
-    # define exvsnprintf(r,b,n,f,a) {r=__compiler_specific_vsnprintf(b,n,f,a);}
-    #else
-    # define exvsnprintf(r,b,n,f,a) {r=vsnprintf(b,n,f,a);}
-    #endif
-
-Take notice of the return value being captured in the variable r.  It is 
-assumed that r exceeds n if and only if the underlying vsnprintf function has
-determined what the true maximal output length would be for output if the 
-buffer were large enough to hold it.  Non-modern implementations must output a
-lesser number (the macro can and should be modified to ensure this).
-
-2. Weak C++ compiler.
-
-C++ is a much more complicated language to implement than C.  This has lead 
-to varying quality of compiler implementations.  The weaknesses isolated in
-the initial ports are inclusion of the Standard Template Library, 
-std::iostream and exception handling.  By default it is assumed that the C++
-compiler supports all of these things correctly.  If your compiler does not
-support one or more of these define the corresponding macro:
-
-    BSTRLIB_CANNOT_USE_STL
-    BSTRLIB_CANNOT_USE_IOSTREAM
-    BSTRLIB_DOESNT_THROW_EXCEPTIONS
-
-The compiler specific detected macro should be defined at the top of 
-bstrwrap.h in the Configuration defines section.  Note that these disabling
-macros can be overrided with the associated enabling macro if a subsequent
-version of the compiler gains support.  (For example, its possible to rig
-up STLport to provide STL support for WATCOM C/C++, so -DBSTRLIB_CAN_USE_STL
-can be passed in as a compiler option.)
-
-3. The bsafe module, and reserved words.
-
-The bsafe module is in gross violation of the ANSI/ISO C standard in the 
-sense that it redefines what could be implemented as reserved words on a 
-given compiler.  The typical problem is that a compiler may inline some of the 
-functions and thus not be properly overridden by the definitions in the bsafe 
-module.  It is also possible that a compiler may prohibit the redefinitions in 
-the bsafe module.  Compiler specific action will be required to deal with 
-these situations.
-
-Platform Specific Files
------------------------
-
-The makefiles for the examples are basically setup of for particular 
-environments for each platform.  In general these makefiles are not portable
-and should be constructed as necessary from scratch for each platform.
-
-Testing a port
---------------
-
-To test that a port compiles correctly do the following:
-
-1. Build a sample project that includes the bstrlib, bstraux, bstrwrap, and 
-   bsafe modules.
-2. Compile bstest against the bstrlib module.
-3. Run bstest and ensure that 0 errors are reported.
-4. Compile test against the bstrlib and bstrwrap modules.
-5. Run test and ensure that 0 errors are reported.
-6. Compile each of the examples (except for the "re" example, which may be 
-   complicated and is not a real test of bstrlib and except for the mfcbench 
-   example which is Windows specific.)
-7. Run each of the examples.
-
-The builds must have 0 errors, and should have the absolute minimum number of
-warnings (in most cases can be reduced to 0.)  The result of execution should 
-be essentially identical on each platform.
-
-Performance
------------
-
-Different CPU and compilers have different capabilities in terms of 
-performance.  It is possible for Bstrlib to assume performance 
-characteristics that a platform doesn't have (since it was primarily 
-developed on just one platform).  The goal of Bstrlib is to provide very good 
-performance on all platforms regardless of this but without resorting to 
-extreme measures (such as using assembly language, or non-portable intrinsics 
-or library extensions.)
-
-There are two performance benchmarks that can be found in the example/ 
-directory.  They are: cbench.c and cppbench.cpp.  These are variations and 
-expansions of a benchmark for another string library.  They don't cover all
-string functionality, but do include the most basic functions which will be
-common in most string manipulation kernels.
-
-...............................................................................
-
-Feedback
---------
-
-In all cases, you may email issues found to the primary author of Bstrlib at 
-the email address: websnarf@users.sourceforge.net
-
-===============================================================================