.github/workflows/main.yml

@@ -1,418 +0,0 @@
-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,7 +3,6 @@
 #################
 moc_*.*
 ui_*.*
-qrc_*.*
 
 #################
 ## Qt Creator
@@ -232,23 +231,3 @@ 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

@@ -1,7 +0,0 @@
-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")
-![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)
+![Coverity badge](https://scan.coverity.com/projects/1812/badge.svg?flat=1 "Coverity badge")
 
 
 ## Very Brief Introduction to UEFI
@@ -29,37 +29,28 @@ 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.
-* 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.
+* 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](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:
-* **[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.
+* **[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.  
 * **[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](https://github.com/LongSoft/UEFITool/releases) or build a binary yourself.  
-* 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 (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.
+You can either use [pre-built binaries for Windows and OSX](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 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).
 
 ## 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](https://edc.intel.com/content/www/us/en/design/products-and-solutions/software-and-services/firmware-and-bios/firmware-interface-table/firmware-interface-table/).
-* 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).
+* 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).
+* Builder code is still not ready, but I'm working hard on it.

UEFIDump/CMakeLists.txt

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

@@ -0,0 +1,204 @@
+/* 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.h

@@ -1,6 +1,6 @@
 /* uefidump.h
 
-Copyright (c) 2018, LongSoft. All rights reserved.
+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

UEFIDump/uefidump_main.cpp

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

@@ -1,92 +0,0 @@
-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,219 +13,81 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 
 #include "ffsdumper.h"
 
-#include <fstream>
-
-USTATUS FfsDumper::dump(const UModelIndex & root, const UString & path, const DumpMode dumpMode, const UINT8 sectionType, const UString & guid)
+USTATUS FfsDumper::dump(const QModelIndex & root, const QString & path, const bool dumpAll, const QString & guid)
 {
     dumped = false;
-    counterHeader = counterBody = counterRaw = counterInfo = 0;
-    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());
+    UINT8 result = recursiveDump(root, path, dumpAll, guid);
+    if (result)
         return result;
-    } else if (!dumped) {
-        if (removeDirectory(path)) {
-            printf("Removed directory \"%s\" since nothing was dumped.\n", (const char*)path.toLocal8Bit());
-        }
+    else if (!dumped)
         return U_ITEM_NOT_FOUND;
-    }
-
     return U_SUCCESS;
 }
 
-USTATUS FfsDumper::recursiveDump(const UModelIndex & index, const UString & path, const DumpMode dumpMode, const UINT8 sectionType, const UString & guid)
+USTATUS FfsDumper::recursiveDump(const QModelIndex & index, const QString & path, const bool dumpAll, const QString & guid)
 {
     if (!index.isValid())
         return U_INVALID_PARAMETER;
 
+    QDir dir;
     if (guid.isEmpty() ||
-        (model->subtype(index) == EFI_SECTION_FREEFORM_SUBTYPE_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) {
+        guidToUString(*(const EFI_GUID*)model->header(index).constData()) == guid ||
+        guidToUString(*(const EFI_GUID*)model->header(model->findParentOfType(index, Types::File)).constData()) == guid) {
 
-        if (!changeDirectory(path) && !makeDirectory(path)) {
-            printf("Cannot use directory \"%s\" (recursiveDump part 1).\n", (const char*)path.toLocal8Bit());
+        if (dir.cd(path))
+            return U_DIR_ALREADY_EXIST;
+
+        if (!dir.mkpath(path))
             return U_DIR_CREATE;
-        }
 
-        if (currentPath != path) {
-            counterHeader = counterBody = counterUncData = counterRaw = counterInfo = 0;
-            currentPath = path;
-        }
-
-        if (fileList.count(index) == 0
-            && (dumpMode == DUMP_ALL || model->rowCount(index) == 0)
-            && (sectionType == IgnoreSectionType || model->subtype(index) == sectionType)) {
-
-            if ((dumpMode == DUMP_ALL || dumpMode == DUMP_CURRENT || dumpMode == DUMP_HEADER)
-                && !model->hasEmptyHeader(index)) {
-                fileList.insert(index);
-
-                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());
+        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();
             }
 
-                const UByteArray &data = model->header(index);
-                file.write(data.constData(), data.size());
+            if (!model->body(index).isEmpty()) {
+                file.setFileName(QObject::tr("%1/body.bin").arg(path));
+                if (!file.open(QFile::WriteOnly))
+                    return U_FILE_OPEN;
 
+                file.write(model->body(index));
+                file.close();
+            }
+        }
+
+        // Always dump info
+        QString info = QObject::tr("Type: %1\nSubtype: %2\n%3%4\n")
+            .arg(itemTypeToUString(model->type(index)))
+            .arg(itemSubtypeToUString(model->type(index), model->subtype(index)))
+            .arg(model->text(index).isEmpty() ? QObject::tr("") : QObject::tr("Text: %1\n").arg(model->text(index)))
+            .arg(model->info(index));
+        file.setFileName(QObject::tr("%1/info.txt").arg(path));
+        if (!file.open(QFile::Text | QFile::WriteOnly))
+            return U_FILE_OPEN;
+
+        file.write(info.toLatin1());
+        file.close();
         dumped = true;
     }
 
-            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;
-
+    UINT8 result;
     for (int i = 0; i < model->rowCount(index); i++) {
-        UModelIndex childIndex = index.child(i, 0);
+        QModelIndex childIndex = index.child(i, 0);
         bool useText = FALSE;
         if (model->type(childIndex) != Types::Volume)
             useText = !model->text(childIndex).isEmpty();
 
-        UString childPath = path;
-        if (dumpMode == DUMP_ALL || dumpMode == DUMP_CURRENT) {
-            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());
+        QString childPath = QString("%1/%2 %3").arg(path).arg(i).arg(useText ? model->text(childIndex) : model->name(childIndex));
+        result = recursiveDump(childIndex, childPath, dumpAll, guid);
+        if (result)
             return result;
     }
-    }
 
     return U_SUCCESS;
 }

UEFIExtract/ffsdumper.h

@@ -14,42 +14,27 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #ifndef FFSDUMPER_H
 #define FFSDUMPER_H
 
-#include <set>
+#include <QObject>
+#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:
-    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) {}
+    explicit FfsDumper(TreeModel * treeModel) : model(treeModel), dumped(false) {}
     ~FfsDumper() {};
 
-    USTATUS dump(const UModelIndex & root, const UString & path, const DumpMode dumpMode = DUMP_CURRENT, const UINT8 sectionType = IgnoreSectionType, const UString & guid = UString());
+    USTATUS dump(const QModelIndex & root, const QString & path, const bool dumpAll = false, const QString & guid = QString());
 
 private:
-    USTATUS recursiveDump(const UModelIndex & root, const UString & path, const DumpMode dumpMode, const UINT8 sectionType, const UString & guid);
+    USTATUS recursiveDump(const QModelIndex & root, const QString & path, const bool dumpAll, const QString & guid);
     TreeModel* model;
-    UString currentPath;
     bool dumped;
-    int counterHeader, counterBody, counterUncData, counterRaw, counterInfo;
-    std::set<UModelIndex> fileList;
 };
 #endif // FFSDUMPER_H

UEFIExtract/meson.build

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

UEFIExtract/uefidump.cpp

@@ -1,151 +0,0 @@
-/* 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/uefiextract.manifest

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

@@ -0,0 +1,46 @@
+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) 2018, LongSoft. All rights reserved.
+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
@@ -7,213 +7,125 @@ 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[])
 {
-    initGuidDatabase("guids.csv");
+    QCoreApplication a(argc, argv);
+    a.setOrganizationName("CodeRush");
+    a.setOrganizationDomain("coderush.me");
+    a.setApplicationName("UEFIExtract");
 
-    if (argc <= 1) {
-        print_usage();
+    if (a.arguments().length() > 32) {
+        std::cout << "Too many arguments" << std::endl;
         return 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;
-        }
-    }
-    
+    if (a.arguments().length() > 1) {
         // Check that input file exists
-    USTATUS result;
-    UByteArray buffer;
-    UString path = getAbsPath(argv[1]);
-    if (false == readFileIntoBuffer(path, buffer))
+        QString path = a.arguments().at(1);
+        QFileInfo fileInfo(path);
+        if (!fileInfo.exists())
             return U_FILE_OPEN;
 
-    // Hack to support legacy UEFIDump mode
-    if (argc == 3 && !std::strcmp(argv[2], "unpack")) {
-        UEFIDumper uefidumper;
-        return (uefidumper.dump(buffer, UString(argv[1])) != U_SUCCESS);
-    }
+        // Open the input file
+        QFile inputFile;
+        inputFile.setFileName(path);
+        if (!inputFile.open(QFile::ReadOnly))
+            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
-    result = ffsParser.parse(buffer);
+        USTATUS result = ffsParser.parse(buffer);
         if (result)
-        return (int)result;
+            return 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 or GUID database
-    if (argc == 3 && !std::strcmp(argv[2], "dump")) {
-        return (ffsDumper.dump(model.index(0, 0), path + UString(".dump")) != U_SUCCESS);
+        // Dump only leaf elements, no report
+        if (a.arguments().length() == 3 && a.arguments().at(2) == QString("dump")) {
+            return (ffsDumper.dump(model.index(0, 0), fileInfo.fileName().append(".dump")) != U_SUCCESS);
         }
-    // Dump named GUIDs found in the image, no dump or report
-    else if (argc == 3 && !std::strcmp(argv[2], "guids")) {
-        GuidDatabase db = guidDatabaseFromTreeRecursive(&model, model.index(0, 0));
-        if (!db.empty()) {
-            return (int)guidDatabaseExportToFile(path + UString(".guids.csv"), db);
+        else if (a.arguments().length() > 3 || 
+            (a.arguments().length() == 3 && a.arguments().at(2) != QString("all") && a.arguments().at(2) != QString("report"))) { // Dump specific files, without report
+            UINT32 returned = 0;
+            for (int i = 2; i < a.arguments().length(); i++) {
+                result = ffsDumper.dump(model.index(0, 0), fileInfo.fileName().append(".dump"), true, a.arguments().at(i));
+                if (result)
+                    returned |= (1 << (i - 1));
             }
+            return returned;
         }
-    // Generate report, no dump or GUID database
-    else if (argc == 3 && !std::strcmp(argv[2], "report")) {
+                
+        // Create ffsReport
         FfsReport ffsReport(&model);
-        std::vector<UString> report = ffsReport.generate();
+        std::vector<QString> 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';
+            QFile file;
+            file.setFileName(fileInfo.fileName().append(".report.txt"));
+            if (file.open(QFile::Text | QFile::WriteOnly)) {
+                for (size_t i = 0; i < report.size(); i++) {
+                    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
-    print_usage();
+    std::cout << "UEFIExtract 0.13.0" << std::endl << std::endl
+              << "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

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

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

UEFIFind/uefifind.cpp

@@ -12,9 +12,6 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 */
 
 #include "uefifind.h"
-#include <fstream>
-#include <set>
-
 
 UEFIFind::UEFIFind()
 {
@@ -30,13 +27,25 @@ UEFIFind::~UEFIFind()
     model = NULL;
 }
 
-USTATUS UEFIFind::init(const UString & path)
+USTATUS UEFIFind::init(const QString & path)
 {
-    UByteArray buffer;
-    if (false == readFileIntoBuffer(path, buffer))
+    USTATUS result;
+    
+    fileInfo = QFileInfo(path);
+
+    if (!fileInfo.exists())
         return U_FILE_OPEN;
 
-    USTATUS result = ffsParser->parse(buffer);
+    QFile inputFile;
+    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;
 
@@ -44,78 +53,10 @@ USTATUS UEFIFind::init(const UString & path)
     return U_SUCCESS;
 }
 
-USTATUS UEFIFind::findFileRecursive(const UModelIndex index, const UString & hexPattern, const UINT8 mode, std::set<std::pair<UModelIndex, UModelIndex> > & files)
+USTATUS UEFIFind::find(const UINT8 mode, const bool count, const QString & hexPattern, QString & result)
 {
-    if (!index.isValid())
-        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;
+    QModelIndex root = model->index(0, 0);
+    std::set<std::pair<QModelIndex, QModelIndex> > files;
 
     result.clear();
 
@@ -125,24 +66,78 @@ USTATUS UEFIFind::find(const UINT8 mode, const bool count, const UString & hexPa
     
     if (count) {
         if (!files.empty())
-            result += usprintf("%lu\n", files.size());
+            result.append(QString("%1\n").arg(files.size()));
         return U_SUCCESS;
     }
 
-    for (std::set<std::pair<UModelIndex, UModelIndex> >::const_iterator citer = files.begin(); citer != files.end(); ++citer) {
-        UByteArray data(16, '\x00');
-        std::pair<UModelIndex, UModelIndex> indexes = *citer;
+    for (std::set<std::pair<QModelIndex, QModelIndex> >::const_iterator citer = files.cbegin(); citer != files.cend(); ++citer) {
+        QByteArray data(16, '\x00');
+        std::pair<QModelIndex, QModelIndex> indexes = *citer;
         if (!model->hasEmptyHeader(indexes.first))
             data = model->header(indexes.first).left(16);
-        result += guidToUString(readUnaligned((const EFI_GUID*)data.constData()));
+        result.append(guidToUString(*(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);
-            result += UString(" ") + (guidToUString(readUnaligned((const EFI_GUID*)(data.constData() + sizeof(EFI_COMMON_SECTION_HEADER)))));
+            data = model->header(indexes.second).left(sizeof(EFI_FREEFORM_SUBTYPE_GUID_SECTION));
+            result.append(" ").append(guidToUString(*(const EFI_GUID*)(data.constData() + sizeof(EFI_COMMON_SECTION_HEADER))));
         }
         
-        result += UString("\n");
+        result.append("\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,15 +14,19 @@ 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
 {
@@ -30,14 +34,16 @@ public:
     explicit UEFIFind();
     ~UEFIFind();
 
-    USTATUS init(const UString & path);
-    USTATUS find(const UINT8 mode, const bool count, const UString & hexPattern, UString & result);
+    USTATUS init(const QString & path);
+    USTATUS find(const UINT8 mode, const bool count, const QString & hexPattern, QString & result);
 
 private:
-    USTATUS findFileRecursive(const UModelIndex index, const UString & hexPattern, const UINT8 mode, std::set<std::pair<UModelIndex, UModelIndex> > & files);
+    USTATUS findFileRecursive(const QModelIndex index, const QString & hexPattern, const UINT8 mode, std::set<std::pair<QModelIndex, QModelIndex> > & files);
+    QString guidToQString(const UINT8* guid);
 
     FfsParser* ffsParser;
     TreeModel* model;
+    QFileInfo fileInfo;
     bool initDone;
 };
 

UEFIFind/uefifind.manifest

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

@@ -0,0 +1,42 @@
+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) 2018, LongSoft. All rights reserved.
+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
@@ -10,77 +10,49 @@ 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;
-    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];
+    UINT8 result;
 
+    if (a.arguments().length() == 5) {
         // Get search mode
         UINT8 mode;
-        if (modeArg == UString("header"))
+        if (a.arguments().at(1) == QString("header"))
             mode = SEARCH_MODE_HEADER;
-        else if (modeArg == UString("body"))
+        else if (a.arguments().at(1) == QString("body"))
             mode = SEARCH_MODE_BODY;
-        else if (modeArg == UString("all"))
+        else if (a.arguments().at(1) == QString("all"))
             mode = SEARCH_MODE_ALL;
         else
             return U_INVALID_PARAMETER;
 
         // Get result type
         bool count;
-        if (subModeArg == UString("list"))
+        if (a.arguments().at(2) == QString("list"))
             count = false;
-        else if (subModeArg == UString("count"))
+        else if (a.arguments().at(2) == QString("count"))
             count = true;
         else
             return U_INVALID_PARAMETER;
 
         // Parse input file
-        result = w.init(inputArg);
+        result = w.init(a.arguments().at(4));
         if (result)
             return result;
 
         // Go find the supplied pattern
-        UString found;
-        result = w.find(mode, count, patternArg, found);
+        QString found;
+        result = w.find(mode, count, a.arguments().at(3), found);
         if (result)
             return result;
 
@@ -89,93 +61,82 @@ int main(int argc, char *argv[])
             return U_ITEM_NOT_FOUND;
 
         // Print result
-        std::cout << found.toLocal8Bit();
+        std::cout << found.toStdString();
         return U_SUCCESS;
     }
-    else if (argc == 4) {
-        UString inputArg = argv[1];
-        UString modeArg = argv[2];
-        UString patternArg = argv[3];
-
+    else if (a.arguments().length() == 4) {
         // Get search mode
-        if (modeArg != UString("file"))
+        if (a.arguments().at(1) != QString("file"))
             return U_INVALID_PARAMETER;
 
         // Open patterns file
-        if (!isExistOnFs(patternArg))
+        QFileInfo fileInfo(a.arguments().at(2));
+        if (!fileInfo.exists())
             return U_FILE_OPEN;
 
-        std::ifstream patternsFile(patternArg.toLocal8Bit());
-        if (!patternsFile)
+        QFile patternsFile;
+        patternsFile.setFileName(a.arguments().at(2));
+        if (!patternsFile.open(QFile::ReadOnly))
             return U_FILE_OPEN;
 
         // Parse input file
-        result = w.init(inputArg);
+        result = w.init(a.arguments().at(3));
         if (result)
             return result;
 
         // Perform searches
         bool somethingFound = false;
-        while (!patternsFile.eof()) {
-            std::string line;
-            std::getline(patternsFile, line);
+        while (!patternsFile.atEnd()) {
+            QByteArray line = patternsFile.readLine();
             // Use sharp symbol as commentary
-            if (line.size() == 0 || line[0] == '#')
+            if (line.count() == 0 || line[0] == '#')
                 continue;
 
             // Split the read line
-            std::vector<UString> list;
-            std::string::size_type prev = 0, curr = 0;
-            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;
+            QList<QByteArray> list = line.split(' ');
+            if (list.count() < 3) {
+                std::cout << line.constData() << "skipped, too few arguments" << std::endl << std::endl;
                 continue;
             }
             // Get search mode
             UINT8 mode;
-            if (list.at(0) == UString("header"))
+            if (list.at(0) == QString("header"))
                 mode = SEARCH_MODE_HEADER;
-            else if (list.at(0) == UString("body"))
+            else if (list.at(0) == QString("body"))
                 mode = SEARCH_MODE_BODY;
-            else if (list.at(0) == UString("all"))
+            else if (list.at(0) == QString("all"))
                 mode = SEARCH_MODE_ALL;
             else {
-                std::cout << line << std::endl << "skipped, invalid search mode" << std::endl << std::endl;
+                std::cout << line.constData() << "skipped, invalid search mode" << std::endl << std::endl;
                 continue;
             }
 
             // Get result type
             bool count;
-            if (list.at(1) == UString("list"))
+            if (list.at(1) == QString("list"))
                 count = false;
-            else if (list.at(1) == UString("count"))
+            else if (list.at(1) == QString("count"))
                 count = true;
             else {
-                std::cout << line << std::endl << "skipped, invalid result type" << std::endl << std::endl;
+                std::cout << line.constData() << "skipped, invalid result type" << std::endl << std::endl;
                 continue;
             }
 
             // Go find the supplied pattern
-            UString found;
+            QString found;
             result = w.find(mode, count, list.at(2), found);
             if (result) {
-                std::cout << line << std::endl << "skipped, find failed with error " << (UINT32)result << std::endl << std::endl;
+                std::cout << line.constData() << "skipped, find failed with error " << (UINT32)result << std::endl << std::endl;
                 continue;
             }
 
             if (found.isEmpty()) {
                 // Nothing is found
-                std::cout << line << std::endl << "nothing found" << std::endl << std::endl;
+                std::cout << line.constData() << "nothing found" << std::endl << std::endl;
             }
             else {
                 // Print result
-                std::cout << line << std::endl << found.toLocal8Bit() << std::endl;
+                std::cout << line.constData() << found.toStdString() << std::endl;
                 somethingFound = true;
             }
         }
@@ -186,7 +147,11 @@ int main(int argc, char *argv[])
 
         return U_SUCCESS;
     }
-
-    print_usage();
+    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;
     }
+}
+

UEFITool/CMakeLists.txt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,384 +0,0 @@
-#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,4 +1,4 @@
-/* ffsfinder.cpp
+/* fssfinder.cpp
 
 Copyright (c) 2015, Nikolaj Schlej. All rights reserved.
 This program and the accompanying materials
@@ -13,20 +13,6 @@
 
 #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())
@@ -39,80 +25,40 @@ 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++) {
-        if (U_SUCCESS == findHexPattern(index.model()->index(i, index.column(), index), hexPattern, mode))
-            ret = U_SUCCESS;
+        findHexPattern(index.child(i, index.column()), hexPattern, mode);
     }
 
     UByteArray data;
     if (hasChildren) {
-        if (mode == SEARCH_MODE_HEADER)
+        if (mode != SEARCH_MODE_BODY)
             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);
+            data.append(model->header(index));
         else if (mode == SEARCH_MODE_BODY)
-            data = model->body(index);
+            data.append(model->body(index));
         else
-            data = model->header(index) + model->body(index);
+            data.append(model->header(index)).append(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) {
-            // 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/2 >= model->header(index).size())) {
-                UModelIndex parentFileIndex = model->findParentOfType(index, Types::File);
-                UString name = model->name(index);
-                if (model->parent(index) == parentFileIndex) {
-                    name = model->name(parentFileIndex) + UString("/") + name;
-                }
-                else if (parentFileIndex.isValid()) {
-                    name = model->name(parentFileIndex) + UString("/.../") + name;
-                }
-
             msg(UString("Hex pattern \"") + UString(hexPattern) 
                 + UString("\" found as \"") + hexBody.mid(offset, hexPattern.length()).toUpper() 
-                    + UString("\" in ") + name
+                + UString("\" in ") + model->name(index) 
                 + 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;
+    return U_SUCCESS;
 }
 
 USTATUS FfsFinder::findGuidPattern(const UModelIndex & index, const UByteArray & guidPattern, const UINT8 mode)
@@ -123,11 +69,9 @@ 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++) {
-        if (U_SUCCESS == findGuidPattern(index.model()->index(i, index.column(), index), guidPattern, mode))
-            ret = U_SUCCESS;
+        findGuidPattern(index.child(i, index.column()), guidPattern, mode);
     }
 
     UByteArray data;
@@ -168,53 +112,20 @@ 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) {
-            UModelIndex parentFileIndex = model->findParentOfType(index, Types::File);
-            UString name = model->name(index);
-            if (model->parent(index) == parentFileIndex) {
-                name = model->name(parentFileIndex) + UString("/") + name;
-            }
-            else if (parentFileIndex.isValid()) {
-                name = model->name(parentFileIndex) + UString("/.../") + name;
-            }
-
             msg(UString("GUID pattern \"") + UString(guidPattern)
                 + UString("\" found as \"") + hexBody.mid(offset, hexPattern.length()).toUpper()
-                + UString("\" in ") + name
+                + UString("\" in ") + model->name(index)
                 + 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;
+    return U_SUCCESS;
 }
 
 USTATUS FfsFinder::findTextPattern(const UModelIndex & index, const UString & pattern, const UINT8 mode, const bool unicode, const Qt::CaseSensitivity caseSensitive)
@@ -225,11 +136,9 @@ 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++) {
-        if (U_SUCCESS == findTextPattern(index.model()->index(i, index.column(), index), pattern, mode, unicode, caseSensitive))
-            ret = U_SUCCESS;
+        findTextPattern(index.child(i, index.column()), pattern, mode, unicode, caseSensitive);
     }
 
     UByteArray body;
@@ -246,31 +155,20 @@ USTATUS FfsFinder::findTextPattern(const UModelIndex & index, const UString & pa
             body.append(model->header(index)).append(model->body(index));
     }
 
-    UString data = UString::fromLatin1((const char*)body.constData(), body.length());
-
-    UString searchPattern;
+    UString data;
     if (unicode)
-        searchPattern = UString::fromLatin1((const char*)pattern.utf16(), pattern.length() * 2);
+        data = UString::fromUtf16((const ushort*)body.constData(), body.length() / 2);
     else
-        searchPattern = pattern;
+        data = UString::fromLatin1((const char*)body.constData(), body.length());
 
     int offset = -1;
-    while ((offset = (int)data.indexOf(searchPattern, (int)(offset + 1), caseSensitive)) >= 0) {
-        UModelIndex parentFileIndex = model->findParentOfType(index, Types::File);
-        UString name = model->name(index);
-        if (model->parent(index) == parentFileIndex) {
-            name = model->name(parentFileIndex) + UString("/") + name;
-        }
-        else if (parentFileIndex.isValid()) {
-            name = model->name(parentFileIndex) + UString("/.../") + name;
-        }
+    while ((offset = data.indexOf(pattern, offset + 1, caseSensitive)) >= 0) {
 
         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),
+            + UString("\" found in ") + model->name(index)
+            + usprintf(" at %s-offset %02Xh", mode == SEARCH_MODE_BODY ? "body" : "header", (unicode ? offset * 2 : offset)),
             index);
-        ret = U_SUCCESS;
     }
 
-    return ret;
+    return U_SUCCESS;
 }

UEFITool/ffsfinder.h

@@ -15,6 +15,7 @@ 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"
@@ -30,9 +31,9 @@ public:
     std::vector<std::pair<UString, UModelIndex> > getMessages() const { return messagesVector; }
     void clearMessages() { messagesVector.clear(); }
 
-    USTATUS findHexPattern(const UByteArray & hexPattern, const UINT8 mode);
-    USTATUS findGuidPattern(const UByteArray & guidPattern, const UINT8 mode);
-    USTATUS findTextPattern(const UString & pattern, const UINT8 mode, const bool unicode, const Qt::CaseSensitivity caseSensitive);
+    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);
 
 private:
     const TreeModel* model;
@@ -41,10 +42,6 @@ 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

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

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

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

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

@@ -0,0 +1,61 @@
+/* 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/guidlineedit.h

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

UEFITool/hexlineedit.cpp

@@ -1,86 +0,0 @@
-/* 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/hexspinbox.cpp

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

@@ -1,45 +0,0 @@
-/* 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,8 +20,9 @@ hexView(NULL)
 {
     // Create UI
     ui->setupUi(this);
-    hexView = new QHexView(this);
+    hexView = new QHexEdit(this);
     hexView->setReadOnly(true);
+    hexView->setUpperCase(true);
     ui->layout->addWidget(hexView);
 }
 
@@ -36,33 +37,16 @@ void HexViewDialog::setFont(const QFont &font)
     hexView->setFont(font);
 }
 
-void HexViewDialog::setItem(const UModelIndex & index, HexViewType type)
+void HexViewDialog::setItem(const UModelIndex & index)
 {
     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 and dialog title
-    QByteArray hexdata;
-    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());
+    // Set hex data
+    QByteArray data = model->header(index) + model->body(index) + model->tail(index);
+    hexView->setData(data);
 }

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,21 +24,15 @@ 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, HexViewType dataType);
+    void setItem(const UModelIndex & index);
     void setFont(const QFont &font);
 
 private:
-    QHexView * hexView;
+    QHexEdit * hexView;
 };
 
 #endif // HEXVIEWDIALOG_H

UEFITool/messagelistitem.cpp

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

@@ -0,0 +1,37 @@
+/* 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,15 +14,10 @@
 #include "searchdialog.h"
 
 SearchDialog::SearchDialog(QWidget *parent) :
-QDialog(parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint),
+QDialog(parent),
 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,13 +15,7 @@
 #define SEARCHDIALOG_H
 
 #include <QDialog>
-
-#if QT_VERSION_MAJOR >= 6
-#include <QRegularExpressionValidator>
-#else
 #include <QRegExpValidator>
-#endif
-
 #include "ui_searchdialog.h"
 
 class SearchDialog : public QDialog
@@ -37,13 +31,8 @@ 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,10 +35,7 @@
         </widget>
        </item>
        <item row="0" column="1">
-        <widget class="HexLineEdit" name="hexEdit">
-         <property name="editAsGuid">
-          <bool>false</bool>
-         </property>
+        <widget class="QLineEdit" name="hexEdit">
          <property name="inputMask">
           <string/>
          </property>
@@ -92,10 +89,7 @@
         </widget>
        </item>
        <item row="0" column="1">
-        <widget class="HexLineEdit" name="guidEdit">
-         <property name="editAsGuid">
-          <bool>true</bool>
-         </property>
+        <widget class="GuidLineEdit" name="guidEdit">
          <property name="inputMask">
           <string>xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx</string>
          </property>
@@ -247,9 +241,9 @@
  </widget>
  <customwidgets>
   <customwidget>
-   <class>HexLineEdit</class>
+   <class>GuidLineEdit</class>
    <extends>QLineEdit</extends>
-   <header>hexlineedit.h</header>
+   <header>guidlineedit.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>

UEFITool/uefitool.desktop

@@ -3,8 +3,9 @@ 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;UEFI;
+Keywords=BIOS;

UEFITool/uefitool.entitlements

@@ -1,20 +0,0 @@
-<?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,19 +22,15 @@
 #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>
 
@@ -44,13 +40,10 @@
 #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 {
@@ -70,22 +63,16 @@ public:
 
 private slots:
     void init();
-    void populateUi(const QItemSelection &selected);
     void populateUi(const QModelIndex &current);
-    void scrollTreeView(QListWidgetItem* item); // For messages
-    void scrollTreeView(QTableWidgetItem* item); // For FIT table entries
+    void scrollTreeView(QListWidgetItem* item);
 
     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);
@@ -111,47 +98,28 @@ 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 eventFilter(QObject* obj, QEvent* event);
+    bool enableExtractBodyUncompressed(const QModelIndex &current);
+
     void dragEnterEvent(QDragEnterEvent* event);
     void dropEvent(QDropEvent* event);
     void contextMenuEvent(QContextMenuEvent* event);
@@ -159,16 +127,7 @@ 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,44 +1,30 @@
-QT += core gui widgets
+QT += core gui
+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 \
- gotobasedialog.h \
- gotoaddressdialog.h \
- hexlineedit.h \
+ messagelistitem.h \
+ guidlineedit.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 \
@@ -46,61 +32,18 @@ HEADERS += uefitool.h \
  ../common/Tiano/EfiTianoCompress.h \
  ../common/ustring.h \
  ../common/ubytearray.h \
- ../common/umemstream.h \
- ../common/digest/sha1.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
+ ../qhexedit2/qhexedit.h \
+ ../qhexedit2/chunks.h \
+ ../qhexedit2/commands.h 
 
 SOURCES += uefitool_main.cpp \
  uefitool.cpp \
  searchdialog.cpp \
  hexviewdialog.cpp \
- hexlineedit.cpp \
+ messagelistitem.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 \
@@ -109,14 +52,10 @@ 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 \
@@ -124,68 +63,15 @@ SOURCES += uefitool_main.cpp \
  ../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_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/
+ ../qhexedit2/qhexedit.cpp \
+ ../qhexedit2/chunks.cpp \
+ ../qhexedit2/commands.cpp
 
 FORMS += uefitool.ui \
  searchdialog.ui \
- hexviewdialog.ui \
- gotobasedialog.ui \
- gotoaddressdialog.ui
+ hexviewdialog.ui
 
-RESOURCES += uefitool.qrc
 RC_FILE = uefitool.rc
+
 ICON = icons/uefitool.icns
-QMAKE_BUNDLE_DATA += ICONFILE
-QMAKE_INFO_PLIST = Info.plist
+

UEFITool/uefitool.qrc

@@ -1,5 +0,0 @@
-<!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,44 +203,6 @@
          </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>
@@ -311,7 +273,7 @@
      <x>0</x>
      <y>0</y>
      <width>851</width>
-     <height>31</height>
+     <height>21</height>
     </rect>
    </property>
    <widget class="QMenu" name="menuFile">
@@ -322,12 +284,7 @@
     <addaction name="actionOpenImageFileInNewWindow"/>
     <addaction name="actionSaveImageFile"/>
     <addaction name="separator"/>
-    <addaction name="actionGenerateReport"/>
-    <addaction name="separator"/>
-    <addaction name="actionLoadGuidDatabase"/>
-    <addaction name="actionLoadDefaultGuidDatabase"/>
-    <addaction name="actionUnloadGuidDatabase"/>
-    <addaction name="actionExportDiscoveredGuids"/>
+    <addaction name="actionSearch"/>
     <addaction name="separator"/>
     <addaction name="actionQuit"/>
    </widget>
@@ -343,23 +300,15 @@
      <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>
@@ -368,9 +317,6 @@
      <addaction name="actionExtract"/>
     </widget>
     <widget class="QMenu" name="menuRegionActions">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
      <property name="title">
       <string>&amp;Region</string>
      </property>
@@ -383,9 +329,6 @@
      <addaction name="actionReplace"/>
     </widget>
     <widget class="QMenu" name="menuPaddingActions">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
      <property name="title">
       <string>&amp;Padding</string>
      </property>
@@ -394,15 +337,10 @@
      <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"/>
@@ -415,15 +353,10 @@
      <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"/>
@@ -440,15 +373,10 @@
      <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"/>
@@ -465,10 +393,7 @@
      <addaction name="separator"/>
      <addaction name="actionRemove"/>
     </widget>
-    <widget class="QMenu" name="menuMessageActions">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
+    <widget class="QMenu" name="menuMessages">
      <property name="title">
       <string>&amp;Messages</string>
      </property>
@@ -477,16 +402,11 @@
      <addaction name="separator"/>
      <addaction name="actionMessagesClear"/>
     </widget>
-    <widget class="QMenu" name="menuEntryActions">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
+    <widget class="QMenu" name="menuVariableActions">
      <property name="title">
-      <string>&amp;Entry</string>
+      <string>Variable</string>
      </property>
      <addaction name="actionHexView"/>
-     <addaction name="actionBodyHexView"/>
-     <addaction name="actionUncompressedHexView"/>
      <addaction name="separator"/>
      <addaction name="actionGoToData"/>
      <addaction name="separator"/>
@@ -504,15 +424,10 @@
      <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"/>
@@ -526,10 +441,6 @@
      <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"/>
@@ -537,21 +448,13 @@
     <addaction name="menuVolumeActions"/>
     <addaction name="menuFileActions"/>
     <addaction name="menuSectionActions"/>
-    <addaction name="separator"/>
     <addaction name="menuStoreActions"/>
-    <addaction name="menuEntryActions"/>
+    <addaction name="menuVariableActions"/>
     <addaction name="separator"/>
-    <addaction name="menuMessageActions"/>
-   </widget>
-   <widget class="QMenu" name="menuView">
-    <property name="title">
-     <string>&amp;View</string>
-    </property>
-    <addaction name="actionToggleBootGuardMarking"/>
+    <addaction name="menuMessages"/>
    </widget>
    <addaction name="menuFile"/>
    <addaction name="menuAction"/>
-   <addaction name="menuView"/>
    <addaction name="menuHelp"/>
   </widget>
   <action name="actionInsertAfter">
@@ -706,9 +609,6 @@
    <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>
@@ -717,9 +617,6 @@
    <property name="text">
     <string>&amp;Quit</string>
    </property>
-   <property name="shortcut">
-    <string>Alt+X</string>
-   </property>
    <property name="menuRole">
     <enum>QAction::QuitRole</enum>
    </property>
@@ -729,16 +626,13 @@
     <bool>false</bool>
    </property>
    <property name="text">
-    <string>Searc&amp;h...</string>
+    <string>Sear&amp;ch...</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>
@@ -764,9 +658,6 @@
    </property>
   </action>
   <action name="actionMessagesCopy">
-   <property name="enabled">
-    <bool>false</bool>
-   </property>
    <property name="text">
     <string>&amp;Copy</string>
    </property>
@@ -775,9 +666,6 @@
    </property>
   </action>
   <action name="actionMessagesCopyAll">
-   <property name="enabled">
-    <bool>false</bool>
-   </property>
    <property name="text">
     <string>Copy &amp;all</string>
    </property>
@@ -812,10 +700,7 @@
     <bool>false</bool>
    </property>
    <property name="text">
-    <string>Go &amp;to data</string>
-   </property>
-   <property name="shortcut">
-    <string>Ctrl+T</string>
+    <string>Go to &amp;data</string>
    </property>
   </action>
   <action name="actionHexView">
@@ -829,113 +714,6 @@
     <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) 2022, Nikolaj Schlej. All rights reserved.
+  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
@@ -15,50 +15,18 @@
 #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[])
 {
-    UEFIToolApplication a(argc, argv);
-    return a.startup();
+    QApplication a(argc, argv);
+    a.setOrganizationName("CodeRush");
+    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

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

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

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

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

@@ -0,0 +1,115 @@
+/*
+ * 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/bstrlib.c

@@ -102,7 +102,7 @@ static int snapUpSize (int i) {
 
 /*  int balloc (bstring b, int len)
  *
- *  Increase the size of the memory backing the bstring b to at least olen + 1.
+ *  Increase the size of the memory backing the bstring b to at least len.
  */
 int balloc (bstring b, int olen) {
 	int len;
@@ -124,14 +124,14 @@ int balloc (bstring b, int olen) {
 
 			reallocStrategy:;
 
-			x = (unsigned char *) bstr__realloc (b->data, (size_t) len + 1);
+			x = (unsigned char *) bstr__realloc (b->data, (size_t) len);
 			if (x == NULL) {
 
 				/* Since we failed, try allocating the tighest possible
 				   allocation */
 
 				len = olen;
-				x = (unsigned char *) bstr__realloc (b->data, (size_t) len + 1);
+				x = (unsigned char *) bstr__realloc (b->data, (size_t) olen);
 				if (NULL == x) {
 					return BSTR_ERR;
 				}
@@ -142,7 +142,7 @@ int balloc (bstring b, int olen) {
 			   the extra bytes that are allocated, but not considered part of
 			   the string */
 
-			if (NULL == (x = (unsigned char *) bstr__alloc ((size_t) len + 1))) {
+			if (NULL == (x = (unsigned char *) bstr__alloc ((size_t) len))) {
 
 				/* Perhaps there is no available memory for the two
 				   allocations to be in memory at once */
@@ -317,7 +317,7 @@ char * r;
 
 	if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
 	l = b->slen;
-	r = (char *) bstr__alloc ((size_t)l + 1);
+	r = (char *) bstr__alloc ((size_t) (l + 1));
 	if (r == NULL) return r;
 
 	for (i=0; i < l; i ++) {
@@ -557,7 +557,7 @@ size_t len;
 
 	a->slen = i;
 	len = strlen (str + i);
-	if (len + 1 > (size_t) INT_MAX - i ||
+	if (len + 1 > INT_MAX - i ||
 	    0 > balloc (a, (int) (i + len + 1))) return BSTR_ERR;
 	bBlockCopy (a->data + i, str + i, (size_t) len + 1);
 	a->slen += (int) len;
@@ -739,8 +739,24 @@ int i;
  *  termination characters are not treated in any special way.
  */
 int biseqcaseless (const_bstring b0, const_bstring b1) {
+#if 0
+int i, n;
+
+	if (bdata (b0) == NULL || b0->slen < 0 ||
+	    bdata (b1) == NULL || b1->slen < 0) return BSTR_ERR;
+	if (b0->slen != b1->slen) return BSTR_OK;
+	if (b0->data == b1->data || b0->slen == 0) return 1;
+	for (i=0, n=b0->slen; i < n; i++) {
+		if (b0->data[i] != b1->data[i]) {
+			unsigned char c = (unsigned char) downcase (b0->data[i]);
+			if (c != (unsigned char) downcase (b1->data[i])) return 0;
+		}
+	}
+	return 1;
+#else
 	if (NULL == b1) return BSTR_ERR;
 	return biseqcaselessblk (b0, b1->data, b1->slen);
+#endif
 }
 
 /*  int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len)
@@ -2398,14 +2414,8 @@ int i, c, v;
 	} else {
 		v = (bl->qty - 1) * len;
 		if ((bl->qty > 512 || len > 127) &&
-			v / len != bl->qty - 1) {
-			bstr__free (b);
-			return NULL; /* Overflow */
-		}
-		if (v > INT_MAX - c) {
-			bstr__free (b);
-			return NULL;    /* Overflow */
-		}
+		    v / len != bl->qty - 1) return NULL; /* Overflow */
+		if (v > INT_MAX - c) return NULL;	/* Overflow */
 		c += v;
 		p = b->data = (unsigned char *) bstr__alloc (c);
 		if (p == NULL) {
@@ -2438,7 +2448,7 @@ int i, c, v;
  *  NULL is returned, otherwise a bstring with the correct result is returned.
  */
 bstring bjoin (const struct bstrList * bl, const_bstring sep) {
-	if (sep == NULL || (sep->slen < 0 || sep->data == NULL)) return NULL;
+	if (sep != NULL && (sep->slen < 0 || sep->data == NULL)) return NULL;
 	return bjoinblk (bl, sep->data, sep->slen);
 }
 
@@ -2466,7 +2476,7 @@ int bssplitscb (struct bStream * s, const_bstring splitStr,
 	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) {
 struct charField chrs;
 bstring buff;
-	int i = 0, p = 0, ret = 0;
+int i, p, ret;
 
 	if (cb == NULL || s == NULL || s->readFnPtr == NULL ||
 	    splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
@@ -2479,6 +2489,7 @@ int bssplitscb (struct bStream * s, const_bstring splitStr,
 			ret = 0;
 	} else {
 		buildCharField (&chrs, splitStr);
+		ret = p = i = 0;
 		for (;;) {
 			if (i >= buff->slen) {
 				bsreada (buff, s, BSSSC_BUFF_LEN);
@@ -2531,7 +2542,7 @@ int bssplitscb (struct bStream * s, const_bstring splitStr,
 int bssplitstrcb (struct bStream * s, const_bstring splitStr,
 	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) {
 bstring buff;
-	int i = 0, p = 0, ret = 0;
+int i, p, ret;
 
 	if (cb == NULL || s == NULL || s->readFnPtr == NULL
 	 || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
@@ -2548,10 +2559,10 @@ int bssplitstrcb (struct bStream * s, const_bstring splitStr,
 			}
 			buff->slen = 0;
 		}
-		bdestroy (buff);
 		return BSTR_OK;
 	} else {
-		for (;;) {
+		ret = p = i = 0;
+		for (i=p=0;;) {
 			if ((ret = binstr (buff, 0, splitStr)) >= 0) {
 				struct tagbstring t;
 				blk2tbstr (t, buff->data, ret);

bstrlib/bstrlib.h

@@ -29,12 +29,6 @@ extern "C" {
 # endif
 #endif
 
-#if defined(__clang__) || defined(__GNUC__)
-#define ATTRIBUTE_FORMAT_(t,f,a) __attribute__((format(t, f, a)))
-#else
-#define ATTRIBUTE_FORMAT_(t,f,a)
-#endif
-
 #define BSTR_ERR (-1)
 #define BSTR_OK (0)
 #define BSTR_BS_BUFF_LENGTH_GET (0)
@@ -42,11 +36,6 @@ extern "C" {
 typedef struct tagbstring * bstring;
 typedef const struct tagbstring * const_bstring;
 
-/* Version */
-#define BSTR_VER_MAJOR  1
-#define BSTR_VER_MINOR  0
-#define BSTR_VER_UPDATE 0
-
 /* Copy functions */
 #define cstr2bstr bfromcstr
 extern bstring bfromcstr (const char * str);
@@ -144,9 +133,9 @@ extern int brtrimws (bstring b);
 extern int btrimws (bstring b);
 
 #if !defined (BSTRLIB_NOVSNP)
-extern bstring bformat (const char * fmt, ...) ATTRIBUTE_FORMAT_(printf, 1, 2);
-extern int bformata (bstring b, const char * fmt, ...) ATTRIBUTE_FORMAT_(printf, 2, 3);
-extern int bassignformat (bstring b, const char * fmt, ...) ATTRIBUTE_FORMAT_(printf, 2, 3);
+extern bstring bformat (const char * fmt, ...);
+extern int bformata (bstring b, const char * fmt, ...);
+extern int bassignformat (bstring b, const char * fmt, ...);
 extern int bvcformata (bstring b, int count, const char * fmt, va_list arglist);
 
 #define bvformata(ret, b, fmt, lastarg) { \

bstrlib/bstrwrap.cpp

@@ -697,9 +697,9 @@ int CBString::find (const CBString& b, int pos) const {
 int CBString::find (const char * b, int pos) const {
 int ii, j;
 unsigned char c0;
-int i, l;
-unsigned char cx;
-unsigned char * pdata;
+register int i, l;
+register unsigned char cx;
+register unsigned char * pdata;
 
 	if (NULL == b) {
 #ifdef BSTRLIB_THROWS_EXCEPTIONS
@@ -1491,7 +1491,8 @@ int p, i;
 
 static int streamSplitCb (void * parm, int ofs, const_bstring entry) {
 CBStringList * r = (CBStringList *) parm;
-	(void)ofs;
+
+	ofs = ofs;
 	r->push_back (CBString (*entry));
 	return 0;
 }
@@ -1539,7 +1540,7 @@ std::istream& operator >> (std::istream& sin, CBString& b) {
 	do {
 		b.gets ((bNgetc) istreamGets, &sin, '\n');
 		if (b.slen > 0 && b.data[b.slen-1] == '\n') b.slen--;
-	} while (b.slen == 0 && !sin.eof() && !sin.fail());
+	} while (b.slen == 0 && !sin.eof ());
  	return sin;
 }